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