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