cvs_direct.c

   1 /*
   2  * Copyright 2001, 2002, 2003 David Mansfield and Cobite, Inc.
   3  * See COPYING file for license information
   4  */
   5
   6 #include <string.h>
   7 #ifdef __MINGW32__
   8 char * strsep(char **str, const char *delim);
   9 #endif
  10 #include <unistd.h>
  11 #include <stdlib.h>
  12 #include <limits.h>
  13 #include <stdarg.h>
  14 #include <zlib.h>
  15 #include <sys/socket.h>
  16 #include <cbtcommon/debug.h>
  17 #include <cbtcommon/text_util.h>
  18 #include <cbtcommon/tcpsocket.h>
  19 #include <cbtcommon/sio.h>
  20
  21 #include "cvs_direct.h"
  22 #include "util.h"
  23
  24 #define RD_BUFF_SIZE 4096
  25
  26 struct _CvsServerCtx
  27 {
  28     int read_fd;
  29     int write_fd;
  30     char root[PATH_MAX];
  31
  32     int is_pserver;
  33
  34     /* buffered reads from descriptor */
  35     char read_buff[RD_BUFF_SIZE];
  36     char * head;
  37     char * tail;
  38
  39     int compressed;
  40     z_stream zout;
  41     z_stream zin;
  42
  43     /* when reading compressed data, the compressed data buffer */
  44     char zread_buff[RD_BUFF_SIZE];
  45 };
  46
  47 static void get_cvspass(char *, const char *);
  48 static void send_string(CvsServerCtx *, const char *, ...);
  49 static int read_response(CvsServerCtx *, const char *);
  50 static void ctx_to_fp(CvsServerCtx * ctx, FILE * fp);
  51 static int read_line(CvsServerCtx * ctx, char * p);
  52
  53 static CvsServerCtx * open_ctx_pserver(CvsServerCtx *, const char *);
  54 static CvsServerCtx * open_ctx_forked(CvsServerCtx *, const char *);
  55
  56 CvsServerCtx * open_cvs_server(char * p_root, int compress)
  57 {
  58     CvsServerCtx * ctx = (CvsServerCtx*)malloc(sizeof(*ctx));
  59     char root[PATH_MAX];
  60     char * p = root, *tok;
  61
  62     if (!ctx)
  63         return NULL;
  64
  65     ctx->head = ctx->tail = ctx->read_buff;
  66     ctx->read_fd = ctx->write_fd = -1;
  67     ctx->compressed = 0;
  68     ctx->is_pserver = 0;
  69
  70     if (compress)
  71     {
  72         memset(&ctx->zout, 0, sizeof(z_stream));
  73         memset(&ctx->zin, 0, sizeof(z_stream));
  74
  75         /*
  76          * to 'prime' the reads, make it look like there was output
  77          * room available (i.e. we have processed all pending compressed
  78          * data
  79          */
  80         ctx->zin.avail_out = 1;
  81
  82         if (deflateInit(&ctx->zout, compress) != Z_OK)
  83         {
  84             free(ctx);
  85             return NULL;
  86         }
  87
  88         if (inflateInit(&ctx->zin) != Z_OK)
  89         {
  90             deflateEnd(&ctx->zout);
  91             free(ctx);
  92             return NULL;
  93         }
  94     }
  95
  96     strcpy(root, p_root);
  97
  98     tok = strsep(&p, ":");
  99
 100     /* if root string looks like :pserver:... then the first token will be empty */
 101     if (strlen(tok) == 0)
 102     {
 103         char * method = strsep(&p, ":");
 104         if (strcmp(method, "pserver") == 0)
 105         {
 106             ctx = open_ctx_pserver(ctx, p);
 107         }
 108         else if (strstr("local:ext:fork:server", method))
 109         {
 110             /* handle all of these via fork, even local */
 111             ctx = open_ctx_forked(ctx, p);
 112         }
 113         else
 114         {
 115             debug(DEBUG_APPERROR, "cvs_direct: unsupported cvs access method: %s", method);
 116             free(ctx);
 117             ctx = NULL;
 118         }
 119     }
 120     else
 121     {
 122         ctx = open_ctx_forked(ctx, p_root);
 123     }
 124
 125     if (ctx)
 126     {
 127         char buff[BUFSIZ];
 128
 129         send_string(ctx, "Root %s\n", ctx->root);
 130
 131         /* this is taken from 1.11.1p1 trace - but with Mbinary removed. we can't handle it (yet!) */
 132         send_string(ctx, "Valid-responses ok error Valid-requests Checked-in New-entry Checksum Copy-file Updated Created Update-existing Merged Patched Rcs-diff Mode Mod-time Removed Remove-entry Set-static-directory Clear-static-directory Set-sticky Clear-sticky Template Set-checkin-prog Set-update-prog Notified Module-expansion Wrapper-rcsOption M E F\n", ctx->root);
 133
 134         send_string(ctx, "valid-requests\n");
 135
 136         /* check for the commands we will issue */
 137         read_line(ctx, buff);
 138         if (strncmp(buff, "Valid-requests", 14) != 0)
 139         {
 140             debug(DEBUG_APPERROR, "cvs_direct: bad response to valid-requests command");
 141             close_cvs_server(ctx);
 142             return NULL;
 143         }
 144
 145         if (!strstr(buff, " version") ||
 146             !strstr(buff, " rlog") ||
 147             !strstr(buff, " rdiff") ||
 148             !strstr(buff, " diff") ||
 149             !strstr(buff, " co"))
 150         {
 151             debug(DEBUG_APPERROR, "cvs_direct: cvs server too old for cvs_direct");
 152             close_cvs_server(ctx);
 153             return NULL;
 154         }
 155
 156         read_line(ctx, buff);
 157         if (strcmp(buff, "ok") != 0)
 158         {
 159             debug(DEBUG_APPERROR, "cvs_direct: bad ok trailer to valid-requests command");
 160             close_cvs_server(ctx);
 161             return NULL;
 162         }
 163
 164         /* this is myterious but 'mandatory' */
 165         send_string(ctx, "UseUnchanged\n");
 166
 167         if (compress)
 168         {
 169             send_string(ctx, "Gzip-stream %d\n", compress);
 170             ctx->compressed = 1;
 171         }
 172
 173         debug(DEBUG_APPMSG1, "cvs_direct initialized to CVSROOT %s", ctx->root);
 174     }
 175
 176     return ctx;
 177 }
 178
 179 static CvsServerCtx * open_ctx_pserver(CvsServerCtx * ctx, const char * p_root)
 180 {
 181     char root[PATH_MAX];
 182     char full_root[PATH_MAX];
 183     char * p = root, *tok, *tok2;
 184     char user[BUFSIZ];
 185     char server[BUFSIZ];
 186     char pass[BUFSIZ];
 187     char port[8];
 188
 189     strcpy(root, p_root);
 190
 191     tok = strsep(&p, ":");
 192     if (strlen(tok) == 0 || !p)
 193     {
 194         debug(DEBUG_APPERROR, "parse error on third token");
 195         goto out_free_err;
 196     }
 197
 198     tok2 = strsep(&tok, "@");
 199     if (!strlen(tok2) || (!tok || !strlen(tok)))
 200     {
 201         debug(DEBUG_APPERROR, "parse error on user@server in pserver");
 202         goto out_free_err;
 203     }
 204
 205     strcpy(user, tok2);
 206     strcpy(server, tok);
 207
 208     if (*p != '/')
 209     {
 210         tok = strchr(p, '/');
 211         if (!tok)
 212         {
 213             debug(DEBUG_APPERROR, "parse error: expecting / in root");
 214             goto out_free_err;
 215         }
 216
 217         memset(port, 0, sizeof(port));
 218         memcpy(port, p, tok - p);
 219
 220         p = tok;
 221     }
 222     else
 223     {
 224         strcpy(port, "2401");
 225     }
 226
 227     /* the line from .cvspass is fully qualified, so rebuild */
 228     snprintf(full_root, PATH_MAX, ":pserver:%s@%s:%s%s", user, server, port, p);
 229     get_cvspass(pass, full_root);
 230
 231     debug(DEBUG_TCP, "user:%s server:%s port:%s pass:%s full_root:%s", user, server, port, pass, full_root);
 232
 233     if ((ctx->read_fd = tcp_create_socket(REUSE_ADDR)) < 0)
 234         goto out_free_err;
 235
 236     ctx->write_fd = dup(ctx->read_fd);
 237
 238     if (tcp_connect(ctx->read_fd, server, atoi(port)) < 0)
 239         goto out_close_err;
 240
 241     send_string(ctx, "BEGIN AUTH REQUEST\n");
 242     send_string(ctx, "%s\n", p);
 243     send_string(ctx, "%s\n", user);
 244     send_string(ctx, "%s\n", pass);
 245     send_string(ctx, "END AUTH REQUEST\n");
 246
 247     if (!read_response(ctx, "I LOVE YOU"))
 248         goto out_close_err;
 249
 250     strcpy(ctx->root, p);
 251     ctx->is_pserver = 1;
 252
 253     return ctx;
 254
 255  out_close_err:
 256     close(ctx->read_fd);
 257  out_free_err:
 258     free(ctx);
 259     return NULL;
 260 }
 261
 262 static CvsServerCtx * open_ctx_forked(CvsServerCtx * ctx, const char * p_root)
 263 {
 264 #ifdef __MINGW32__
 265     debug(DEBUG_SYSERROR, "cvs_direct: fork not supported on MinGW");
 266 #else
 267     char root[PATH_MAX];
 268     char * p = root, *tok, *tok2, *rep;
 269     char execcmd[PATH_MAX];
 270     int to_cvs[2];
 271     int from_cvs[2];
 272     pid_t pid;
 273     const char * cvs_server = getenv("CVS_SERVER");
 274
 275     if (!cvs_server)
 276         cvs_server = "cvs";
 277
 278     strcpy(root, p_root);
 279
 280     /* if there's a ':', it's remote */
 281     tok = strsep(&p, ":");
 282
 283     if (p)
 284     {
 285         const char * cvs_rsh = getenv("CVS_RSH");
 286
 287         if (!cvs_rsh)
 288             cvs_rsh = "rsh";
 289
 290         tok2 = strsep(&tok, "@");
 291
 292         if (tok)
 293             snprintf(execcmd, PATH_MAX, "%s -l %s %s %s server", cvs_rsh, tok2, tok, cvs_server);
 294         else
 295             snprintf(execcmd, PATH_MAX, "%s %s %s server", cvs_rsh, tok2, cvs_server);
 296
 297         rep = p;
 298     }
 299     else
 300     {
 301         snprintf(execcmd, PATH_MAX, "%s server", cvs_server);
 302         rep = tok;
 303     }
 304
 305     if (pipe(to_cvs) < 0)
 306     {
 307         debug(DEBUG_SYSERROR, "cvs_direct: failed to create pipe to_cvs");
 308         goto out_free_err;
 309     }
 310
 311     if (pipe(from_cvs) < 0)
 312     {
 313         debug(DEBUG_SYSERROR, "cvs_direct: failed to create pipe from_cvs");
 314         goto out_close_err;
 315     }
 316
 317     debug(DEBUG_TCP, "forked cmdline: %s", execcmd);
 318
 319     if ((pid = fork()) < 0)
 320     {
 321         debug(DEBUG_SYSERROR, "cvs_direct: can't fork");
 322         goto out_close2_err;
 323     }
 324     else if (pid == 0) /* child */
 325     {
 326         char * argp[4];
 327         argp[0] = "sh";
 328         argp[1] = "-c";
 329         argp[2] = execcmd;
 330         argp[3] = NULL;
 331
 332         close(to_cvs[1]);
 333         close(from_cvs[0]);
 334
 335         close(0);
 336         dup(to_cvs[0]);
 337         close(1);
 338         dup(from_cvs[1]);
 339
 340         execv("/bin/sh",argp);
 341
 342         debug(DEBUG_APPERROR, "cvs_direct: fatal: shouldn't be reached");
 343         exit(1);
 344     }
 345
 346     close(to_cvs[0]);
 347     close(from_cvs[1]);
 348     ctx->read_fd = from_cvs[0];
 349     ctx->write_fd = to_cvs[1];
 350
 351     strcpy(ctx->root, rep);
 352
 353     return ctx;
 354
 355  out_close2_err:
 356     close(from_cvs[0]);
 357     close(from_cvs[1]);
 358  out_close_err:
 359     close(to_cvs[0]);
 360     close(to_cvs[1]);
 361  out_free_err:
 362     free(ctx);
 363 #endif
 364     return NULL;
 365 }
 366
 367 void close_cvs_server(CvsServerCtx * ctx)
 368 {
 369     /* FIXME: some sort of flushing should be done for non-compressed case */
 370
 371     if (ctx->compressed)
 372     {
 373         int ret, len;
 374         char buff[BUFSIZ];
 375
 376         /*
 377          * there shouldn't be anything left, but we do want
 378          * to send an 'end of stream' marker, (if such a thing
 379          * actually exists..)
 380          */
 381         do
 382         {
 383             ctx->zout.next_out = buff;
 384             ctx->zout.avail_out = BUFSIZ;
 385             ret = deflate(&ctx->zout, Z_FINISH);
 386
 387             if ((ret == Z_OK || ret == Z_STREAM_END) && ctx->zout.avail_out != BUFSIZ)
 388             {
 389                 len = BUFSIZ - ctx->zout.avail_out;
 390                 if (writen(ctx->write_fd, buff, len) != len)
 391                     debug(DEBUG_APPERROR, "cvs_direct: zout: error writing final state");
 392
 393                 //hexdump(buff, len, "cvs_direct: zout: sending unsent data");
 394             }
 395         } while (ret == Z_OK);
 396
 397         if ((ret = deflateEnd(&ctx->zout)) != Z_OK)
 398             debug(DEBUG_APPERROR, "cvs_direct: zout: deflateEnd error: %s: %s",
 399                   (ret == Z_STREAM_ERROR) ? "Z_STREAM_ERROR":"Z_DATA_ERROR", ctx->zout.msg);
 400     }
 401
 402     /* we're done writing now */
 403     debug(DEBUG_TCP, "cvs_direct: closing cvs server write connection %d", ctx->write_fd);
 404     close(ctx->write_fd);
 405
 406     /*
 407      * if this is pserver, then read_fd is a bi-directional socket.
 408      * we want to shutdown the write side, just to make sure the
 409      * server get's eof
 410      */
 411     if (ctx->is_pserver)
 412     {
 413         debug(DEBUG_TCP, "cvs_direct: shutdown on read socket");
 414         if (shutdown(ctx->read_fd, SHUT_WR) < 0)
 415             debug(DEBUG_SYSERROR, "cvs_direct: error with shutdown on pserver socket");
 416     }
 417
 418     if (ctx->compressed)
 419     {
 420         int ret = Z_OK, len, eof = 0;
 421         char buff[BUFSIZ];
 422
 423         /* read to the 'eof'/'eos' marker.  there are two states we
 424          * track, looking for Z_STREAM_END (application level EOS)
 425          * and EOF on socket.  Both should happen at the same time,
 426          * but we need to do the read first, the first time through
 427          * the loop, but we want to do one read after getting Z_STREAM_END
 428          * too.  so this loop has really ugly exit conditions.
 429          */
 430         for(;;)
 431         {
 432             /*
 433              * if there's nothing in the avail_in, and we
 434              * inflated everything last pass (avail_out != 0)
 435              * then slurp some more from the descriptor,
 436              * if we get EOF, exit the loop
 437              */
 438             if (ctx->zin.avail_in == 0 && ctx->zin.avail_out != 0)
 439             {
 440                 debug(DEBUG_TCP, "cvs_direct: doing final slurp");
 441                 len = read(ctx->read_fd, ctx->zread_buff, RD_BUFF_SIZE);
 442                 debug(DEBUG_TCP, "cvs_direct: did final slurp: %d", len);
 443
 444                 if (len <= 0)
 445                 {
 446                     eof = 1;
 447                     break;
 448                 }
 449
 450                 /* put the data into the inflate input stream */
 451                 ctx->zin.next_in = ctx->zread_buff;
 452                 ctx->zin.avail_in = len;
 453             }
 454
 455             /*
 456              * if the last time through we got Z_STREAM_END, and we
 457              * get back here, it means we should've gotten EOF but
 458              * didn't
 459              */
 460             if (ret == Z_STREAM_END)
 461                 break;
 462
 463             ctx->zin.next_out = buff;
 464             ctx->zin.avail_out = BUFSIZ;
 465
 466             ret = inflate(&ctx->zin, Z_SYNC_FLUSH);
 467             len = BUFSIZ - ctx->zin.avail_out;
 468
 469             if (ret == Z_BUF_ERROR)
 470                 debug(DEBUG_APPERROR, "Z_BUF_ERROR");
 471
 472             if (ret == Z_OK && len == 0)
 473                 debug(DEBUG_TCP, "cvs_direct: no data out of inflate");
 474
 475             if (ret == Z_STREAM_END)
 476                 debug(DEBUG_TCP, "cvs_direct: got Z_STREAM_END");
 477
 478             if ((ret == Z_OK || ret == Z_STREAM_END) && len > 0)
 479                 hexdump(buff, BUFSIZ - ctx->zin.avail_out, "cvs_direct: zin: unread data at close");
 480         }
 481
 482         if (ret != Z_STREAM_END)
 483             debug(DEBUG_APPERROR, "cvs_direct: zin: Z_STREAM_END not encountered (premature EOF?)");
 484
 485         if (eof == 0)
 486             debug(DEBUG_APPERROR, "cvs_direct: zin: EOF not encountered (premature Z_STREAM_END?)");
 487
 488         if ((ret = inflateEnd(&ctx->zin)) != Z_OK)
 489             debug(DEBUG_APPERROR, "cvs_direct: zin: inflateEnd error: %s: %s",
 490                   (ret == Z_STREAM_ERROR) ? "Z_STREAM_ERROR":"Z_DATA_ERROR", ctx->zin.msg ? ctx->zin.msg : "");
 491     }
 492
 493     debug(DEBUG_TCP, "cvs_direct: closing cvs server read connection %d", ctx->read_fd);
 494     close(ctx->read_fd);
 495
 496     free(ctx);
 497 }
 498
 499 static void get_cvspass(char * pass, const char * root)
 500 {
 501     char cvspass[PATH_MAX];
 502     const char * home;
 503     FILE * fp;
 504
 505     pass[0] = 0;
 506
 507     if (!(home = getenv("HOME")))
 508     {
 509         debug(DEBUG_APPERROR, "HOME environment variable not set");
 510         exit(1);
 511     }
 512
 513     if (snprintf(cvspass, PATH_MAX, "%s/.cvspass", home) >= PATH_MAX)
 514     {
 515         debug(DEBUG_APPERROR, "prefix buffer overflow");
 516         exit(1);
 517     }
 518
 519     if ((fp = fopen(cvspass, "r")))
 520     {
 521         char buff[BUFSIZ];
 522         int len = strlen(root);
 523
 524         while (fgets(buff, BUFSIZ, fp))
 525         {
 526             /* FIXME: what does /1 mean? */
 527             if (strncmp(buff, "/1 ", 3) != 0)
 528                 continue;
 529
 530             if (strncmp(buff + 3, root, len) == 0)
 531             {
 532                 strcpy(pass, buff + 3 + len + 1);
 533                 chop(pass);
 534                 break;
 535             }
 536
 537         }
 538         fclose(fp);
 539     }
 540
 541     if (!pass[0])
 542         pass[0] = 'A';
 543 }
 544
 545 static void send_string(CvsServerCtx * ctx, const char * str, ...)
 546 {
 547     int len;
 548     char buff[BUFSIZ];
 549     va_list ap;
 550
 551     va_start(ap, str);
 552
 553     len = vsnprintf(buff, BUFSIZ, str, ap);
 554     if (len >= BUFSIZ)
 555     {
 556         debug(DEBUG_APPERROR, "cvs_direct: command send string overflow");
 557         exit(1);
 558     }
 559
 560     if (ctx->compressed)
 561     {
 562         char zbuff[BUFSIZ];
 563
 564         if  (ctx->zout.avail_in != 0)
 565         {
 566             debug(DEBUG_APPERROR, "cvs_direct: zout: last output command not flushed");
 567             exit(1);
 568         }
 569
 570         ctx->zout.next_in = buff;
 571         ctx->zout.avail_in = len;
 572         ctx->zout.avail_out = 0;
 573
 574         while (ctx->zout.avail_in > 0 || ctx->zout.avail_out == 0)
 575         {
 576             int ret;
 577
 578             ctx->zout.next_out = zbuff;
 579             ctx->zout.avail_out = BUFSIZ;
 580
 581             /* FIXME: for the arguments before a command, flushing is counterproductive */
 582             ret = deflate(&ctx->zout, Z_SYNC_FLUSH);
 583
 584             if (ret == Z_OK)
 585             {
 586                 len = BUFSIZ - ctx->zout.avail_out;
 587
 588                 if (writen(ctx->write_fd, zbuff, len) != len)
 589                 {
 590                     debug(DEBUG_SYSERROR, "cvs_direct: zout: can't write");
 591                     exit(1);
 592                 }
 593             }
 594             else
 595             {
 596                 debug(DEBUG_APPERROR, "cvs_direct: zout: error %d %s", ret, ctx->zout.msg);
 597             }
 598         }
 599     }
 600     else
 601     {
 602         if (writen(ctx->write_fd, buff, len)  != len)
 603         {
 604             debug(DEBUG_SYSERROR, "cvs_direct: can't send command");
 605             exit(1);
 606         }
 607     }
 608
 609     debug(DEBUG_TCP, "string: '%s' sent", buff);
 610 }
 611
 612 static int refill_buffer(CvsServerCtx * ctx)
 613 {
 614     int len;
 615
 616     if (ctx->head != ctx->tail)
 617     {
 618         debug(DEBUG_APPERROR, "cvs_direct: refill_buffer called on non-empty buffer");
 619         exit(1);
 620     }
 621
 622     ctx->head = ctx->read_buff;
 623     len = RD_BUFF_SIZE;
 624
 625     if (ctx->compressed)
 626     {
 627         int zlen, ret;
 628
 629         /* if there was leftover buffer room, it's time to slurp more data */
 630         do
 631         {
 632             if (ctx->zin.avail_out > 0)
 633             {
 634                 if (ctx->zin.avail_in != 0)
 635                 {
 636                     debug(DEBUG_APPERROR, "cvs_direct: zin: expect 0 avail_in");
 637                     exit(1);
 638                 }
 639                 zlen = read(ctx->read_fd, ctx->zread_buff, RD_BUFF_SIZE);
 640                 ctx->zin.next_in = ctx->zread_buff;
 641                 ctx->zin.avail_in = zlen;
 642             }
 643
 644             ctx->zin.next_out = ctx->head;
 645             ctx->zin.avail_out = len;
 646
 647             /* FIXME: we don't always need Z_SYNC_FLUSH, do we? */
 648             ret = inflate(&ctx->zin, Z_SYNC_FLUSH);
 649         }
 650         while (ctx->zin.avail_out == len);
 651
 652         if (ret == Z_OK)
 653         {
 654             ctx->tail = ctx->head + (len - ctx->zin.avail_out);
 655         }
 656         else
 657         {
 658             debug(DEBUG_APPERROR, "cvs_direct: zin: error %d %s", ret, ctx->zin.msg);
 659             exit(1);
 660         }
 661     }
 662     else
 663     {
 664         len = read(ctx->read_fd, ctx->head, len);
 665         ctx->tail = (len <= 0) ? ctx->head : ctx->head + len;
 666     }
 667
 668     return len;
 669 }
 670
 671 static int read_line(CvsServerCtx * ctx, char * p)
 672 {
 673     int len = 0;
 674     while (1)
 675     {
 676         if (ctx->head == ctx->tail)
 677             if (refill_buffer(ctx) <= 0)
 678                 return -1;
 679
 680         *p = *ctx->head++;
 681
 682         if (*p == '\n')
 683         {
 684             *p = 0;
 685             break;
 686         }
 687         p++;
 688         len++;
 689     }
 690
 691     return len;
 692 }
 693
 694 static int read_response(CvsServerCtx * ctx, const char * str)
 695 {
 696     /* FIXME: more than 1 char at a time */
 697     char resp[BUFSIZ];
 698
 699     if (read_line(ctx, resp) < 0)
 700         return 0;
 701
 702     debug(DEBUG_TCP, "response '%s' read", resp);
 703
 704     return (strcmp(resp, str) == 0);
 705 }
 706
 707 static void ctx_to_fp(CvsServerCtx * ctx, FILE * fp)
 708 {
 709     char line[BUFSIZ];
 710
 711     while (1)
 712     {
 713         read_line(ctx, line);
 714         debug(DEBUG_TCP, "ctx_to_fp: %s", line);
 715         if (memcmp(line, "M ", 2) == 0)
 716         {
 717             if (fp)
 718                 fprintf(fp, "%s\n", line + 2);
 719         }
 720         else if (memcmp(line, "E ", 2) == 0)
 721         {
 722             debug(DEBUG_APPMSG1, "%s", line + 2);
 723         }
 724         else if (strncmp(line, "ok", 2) == 0 || strncmp(line, "error", 5) == 0)
 725         {
 726             break;
 727         }
 728     }
 729
 730     if (fp)
 731         fflush(fp);
 732 }
 733
 734 void cvs_rdiff(CvsServerCtx * ctx,
 735                const char * rep, const char * file,
 736                const char * rev1, const char * rev2)
 737 {
 738     /* NOTE: opts are ignored for rdiff, '-u' is always used */
 739
 740     send_string(ctx, "Argument -u\n");
 741     send_string(ctx, "Argument -r\n");
 742     send_string(ctx, "Argument %s\n", rev1);
 743     send_string(ctx, "Argument -r\n");
 744     send_string(ctx, "Argument %s\n", rev2);
 745     send_string(ctx, "Argument %s%s\n", rep, file);
 746     send_string(ctx, "rdiff\n");
 747
 748     ctx_to_fp(ctx, stdout);
 749 }
 750
 751 void cvs_rupdate(CvsServerCtx * ctx, const char * rep, const char * file, const char * rev, int create, const char * opts)
 752 {
 753     FILE * fp;
 754     char cmdbuff[BUFSIZ];
 755
 756     snprintf(cmdbuff, BUFSIZ, "diff %s %s /dev/null %s | sed -e '%s s|^\\([+-][+-][+-]\\) -|\\1 %s/%s|g'",
 757              opts, create?"":"-", create?"-":"", create?"2":"1", rep, file);
 758
 759     debug(DEBUG_TCP, "cmdbuff: %s", cmdbuff);
 760
 761     if (!(fp = popen(cmdbuff, "w")))
 762     {
 763         debug(DEBUG_APPERROR, "cvs_direct: popen for diff failed: %s", cmdbuff);
 764         exit(1);
 765     }
 766
 767     send_string(ctx, "Argument -p\n");
 768     send_string(ctx, "Argument -r\n");
 769     send_string(ctx, "Argument %s\n", rev);
 770     send_string(ctx, "Argument %s/%s\n", rep, file);
 771     send_string(ctx, "co\n");
 772
 773     ctx_to_fp(ctx, fp);
 774
 775     pclose(fp);
 776 }
 777
 778 static int parse_patch_arg(char * arg, char ** str)
 779 {
 780     char *tok, *tok2 = "";
 781     tok = strsep(str, " ");
 782     if (!tok)
 783         return 0;
 784
 785     if (!*tok == '-')
 786     {
 787         debug(DEBUG_APPERROR, "diff_opts parse error: no '-' starting argument: %s", *str);
 788         return 0;
 789     }
 790
 791     /* if it's not 'long format' argument, we can process it efficiently */
 792     if (tok[1] == '-')
 793     {
 794         debug(DEBUG_APPERROR, "diff_opts parse_error: long format args not supported");
 795         return 0;
 796     }
 797
 798     /* see if command wants two args and they're separated by ' ' */
 799     if (tok[2] == 0 && strchr("BdDFgiorVxYz", tok[1]))
 800     {
 801         tok2 = strsep(str, " ");
 802         if (!tok2)
 803         {
 804             debug(DEBUG_APPERROR, "diff_opts parse_error: argument %s requires two arguments", tok);
 805             return 0;
 806         }
 807     }
 808
 809     snprintf(arg, 32, "%s%s", tok, tok2);
 810     return 1;
 811 }
 812
 813 void cvs_diff(CvsServerCtx * ctx,
 814                const char * rep, const char * file,
 815                const char * rev1, const char * rev2, const char * opts)
 816 {
 817     char argstr[BUFSIZ], *p = argstr;
 818     char arg[32];
 819     char file_buff[PATH_MAX], *basename;
 820
 821     strzncpy(argstr, opts, BUFSIZ);
 822     while (parse_patch_arg(arg, &p))
 823         send_string(ctx, "Argument %s\n", arg);
 824
 825     send_string(ctx, "Argument -r\n");
 826     send_string(ctx, "Argument %s\n", rev1);
 827     send_string(ctx, "Argument -r\n");
 828     send_string(ctx, "Argument %s\n", rev2);
 829
 830     /*
 831      * we need to separate the 'basename' of file in order to
 832      * generate the Directory directive(s)
 833      */
 834     strzncpy(file_buff, file, PATH_MAX);
 835     if ((basename = strrchr(file_buff, '/')))
 836     {
 837         *basename = 0;
 838         send_string(ctx, "Directory %s/%s\n", rep, file_buff);
 839         send_string(ctx, "%s/%s/%s\n", ctx->root, rep, file_buff);
 840     }
 841     else
 842     {
 843         send_string(ctx, "Directory %s\n", rep, file_buff);
 844         send_string(ctx, "%s/%s\n", ctx->root, rep);
 845     }
 846
 847     send_string(ctx, "Directory .\n");
 848     send_string(ctx, "%s\n", ctx->root);
 849     send_string(ctx, "Argument %s/%s\n", rep, file);
 850     send_string(ctx, "diff\n");
 851
 852     ctx_to_fp(ctx, stdout);
 853 }
 854
 855 /*
 856  * FIXME: the design of this sucks.  It was originally designed to fork a subprocess
 857  * which read the cvs response and send it back through a pipe the main process,
 858  * which fdopen(3)ed the other end, and juts used regular fgets.  This however
 859  * didn't work because the reads of compressed data in the child process altered
 860  * the compression state, and there was no way to resynchronize that state with
 861  * the parent process.  We could use threads...
 862  */
 863 FILE * cvs_rlog_open(CvsServerCtx * ctx, const char * rep, const char * date_str)
 864 {
 865     /* note: use of the date_str is handled in a non-standard, cvsps specific way */
 866     if (date_str && date_str[0])
 867     {
 868         send_string(ctx, "Argument -d\n", rep);
 869         send_string(ctx, "Argument %s<1 Jan 2038 05:00:00 -0000\n", date_str);
 870         send_string(ctx, "Argument -d\n", rep);
 871         send_string(ctx, "Argument %s\n", date_str);
 872     }
 873
 874     send_string(ctx, "Argument %s\n", rep);
 875     send_string(ctx, "rlog\n");
 876
 877     /*
 878      * FIXME: is it possible to create a 'fake' FILE * whose 'refill'
 879      * function is below?
 880      */
 881     return (FILE*)ctx;
 882 }
 883
 884 char * cvs_rlog_fgets(char * buff, int buflen, CvsServerCtx * ctx)
 885 {
 886     char lbuff[BUFSIZ];
 887     int len;
 888
 889     len = read_line(ctx, lbuff);
 890     debug(DEBUG_TCP, "cvs_direct: rlog: read %s", lbuff);
 891
 892     if (memcmp(lbuff, "M ", 2) == 0)
 893     {
 894         memcpy(buff, lbuff + 2, len - 2);
 895         buff[len - 2 ] = '\n';
 896         buff[len - 1 ] = 0;
 897     }
 898     else if (memcmp(lbuff, "E ", 2) == 0)
 899     {
 900         debug(DEBUG_APPMSG1, "%s", lbuff + 2);
 901     }
 902     else if (strcmp(lbuff, "ok") == 0 ||strcmp(lbuff, "error") == 0)
 903     {
 904         debug(DEBUG_TCP, "cvs_direct: rlog: got command completion");
 905         return NULL;
 906     }
 907
 908     return buff;
 909 }
 910
 911 void cvs_rlog_close(CvsServerCtx * ctx)
 912 {
 913 }
 914
 915 void cvs_version(CvsServerCtx * ctx, char * client_version, char * server_version)
 916 {
 917     char lbuff[BUFSIZ];
 918     strcpy(client_version, "Client: Concurrent Versions System (CVS) 99.99.99 (client/server) cvs-direct");
 919     send_string(ctx, "version\n");
 920     read_line(ctx, lbuff);
 921     if (memcmp(lbuff, "M ", 2) == 0)
 922         sprintf(server_version, "Server: %s", lbuff + 2);
 923     else
 924         debug(DEBUG_APPERROR, "cvs_direct: didn't read version: %s", lbuff);
 925
 926     read_line(ctx, lbuff);
 927     if (strcmp(lbuff, "ok") != 0)
 928         debug(DEBUG_APPERROR, "cvs_direct: protocol error reading version");
 929
 930     debug(DEBUG_TCP, "cvs_direct: client version %s", client_version);
 931     debug(DEBUG_TCP, "cvs_direct: server version %s", server_version);
 932 }