pkt-line.c

   1 #include "git-compat-util.h"
   2 #include "copy.h"
   3 #include "pkt-line.h"
   4 #include "gettext.h"
   5 #include "hex.h"
   6 #include "run-command.h"
   7 #include "trace.h"
   8 #include "write-or-die.h"
   9
  10 char packet_buffer[LARGE_PACKET_MAX];
  11 static const char *packet_trace_prefix = "git";
  12 static struct trace_key trace_packet = TRACE_KEY_INIT(PACKET);
  13 static struct trace_key trace_pack = TRACE_KEY_INIT(PACKFILE);
  14
  15 void packet_trace_identity(const char *prog)
  16 {
  17         packet_trace_prefix = xstrdup(prog);
  18 }
  19
  20 static const char *get_trace_prefix(void)
  21 {
  22         return in_async() ? "sideband" : packet_trace_prefix;
  23 }
  24
  25 static int packet_trace_pack(const char *buf, unsigned int len, int sideband)
  26 {
  27         if (!sideband) {
  28                 trace_verbatim(&trace_pack, buf, len);
  29                 return 1;
  30         } else if (len && *buf == '\1') {
  31                 trace_verbatim(&trace_pack, buf + 1, len - 1);
  32                 return 1;
  33         } else {
  34                 /* it's another non-pack sideband */
  35                 return 0;
  36         }
  37 }
  38
  39 static void packet_trace(const char *buf, unsigned int len, int write)
  40 {
  41         int i;
  42         struct strbuf out;
  43         static int in_pack, sideband;
  44
  45         if (!trace_want(&trace_packet) && !trace_want(&trace_pack))
  46                 return;
  47
  48         if (in_pack) {
  49                 if (packet_trace_pack(buf, len, sideband))
  50                         return;
  51         } else if (starts_with(buf, "PACK") || starts_with(buf, "\1PACK")) {
  52                 in_pack = 1;
  53                 sideband = *buf == '\1';
  54                 packet_trace_pack(buf, len, sideband);
  55
  56                 /*
  57                  * Make a note in the human-readable trace that the pack data
  58                  * started.
  59                  */
  60                 buf = "PACK ...";
  61                 len = strlen(buf);
  62         }
  63
  64         if (!trace_want(&trace_packet))
  65                 return;
  66
  67         /* +32 is just a guess for header + quoting */
  68         strbuf_init(&out, len+32);
  69
  70         strbuf_addf(&out, "packet: %12s%c ",
  71                     get_trace_prefix(), write ? '>' : '<');
  72
  73         /* XXX we should really handle printable utf8 */
  74         for (i = 0; i < len; i++) {
  75                 /* suppress newlines */
  76                 if (buf[i] == '\n')
  77                         continue;
  78                 if (buf[i] >= 0x20 && buf[i] <= 0x7e)
  79                         strbuf_addch(&out, buf[i]);
  80                 else
  81                         strbuf_addf(&out, "\\%o", buf[i]);
  82         }
  83
  84         strbuf_addch(&out, '\n');
  85         trace_strbuf(&trace_packet, &out);
  86         strbuf_release(&out);
  87 }
  88
  89 /*
  90  * If we buffered things up above (we don't, but we should),
  91  * we'd flush it here
  92  */
  93 void packet_flush(int fd)
  94 {
  95         packet_trace("0000", 4, 1);
  96         if (write_in_full(fd, "0000", 4) < 0)
  97                 die_errno(_("unable to write flush packet"));
  98 }
  99
 100 void packet_delim(int fd)
 101 {
 102         packet_trace("0001", 4, 1);
 103         if (write_in_full(fd, "0001", 4) < 0)
 104                 die_errno(_("unable to write delim packet"));
 105 }
 106
 107 void packet_response_end(int fd)
 108 {
 109         packet_trace("0002", 4, 1);
 110         if (write_in_full(fd, "0002", 4) < 0)
 111                 die_errno(_("unable to write response end packet"));
 112 }
 113
 114 int packet_flush_gently(int fd)
 115 {
 116         packet_trace("0000", 4, 1);
 117         if (write_in_full(fd, "0000", 4) < 0)
 118                 return error(_("flush packet write failed"));
 119         return 0;
 120 }
 121
 122 void packet_buf_flush(struct strbuf *buf)
 123 {
 124         packet_trace("0000", 4, 1);
 125         strbuf_add(buf, "0000", 4);
 126 }
 127
 128 void packet_buf_delim(struct strbuf *buf)
 129 {
 130         packet_trace("0001", 4, 1);
 131         strbuf_add(buf, "0001", 4);
 132 }
 133
 134 void set_packet_header(char *buf, int size)
 135 {
 136         static char hexchar[] = "0123456789abcdef";
 137
 138         #define hex(a) (hexchar[(a) & 15])
 139         buf[0] = hex(size >> 12);
 140         buf[1] = hex(size >> 8);
 141         buf[2] = hex(size >> 4);
 142         buf[3] = hex(size);
 143         #undef hex
 144 }
 145
 146 static void format_packet(struct strbuf *out, const char *prefix,
 147                           const char *fmt, va_list args)
 148 {
 149         size_t orig_len, n;
 150
 151         orig_len = out->len;
 152         strbuf_addstr(out, "0000");
 153         strbuf_addstr(out, prefix);
 154         strbuf_vaddf(out, fmt, args);
 155         n = out->len - orig_len;
 156
 157         if (n > LARGE_PACKET_MAX)
 158                 die(_("protocol error: impossibly long line"));
 159
 160         set_packet_header(&out->buf[orig_len], n);
 161         packet_trace(out->buf + orig_len + 4, n - 4, 1);
 162 }
 163
 164 static int packet_write_fmt_1(int fd, int gently, const char *prefix,
 165                               const char *fmt, va_list args)
 166 {
 167         static struct strbuf buf = STRBUF_INIT;
 168
 169         strbuf_reset(&buf);
 170         format_packet(&buf, prefix, fmt, args);
 171         if (write_in_full(fd, buf.buf, buf.len) < 0) {
 172                 if (!gently) {
 173                         check_pipe(errno);
 174                         die_errno(_("packet write with format failed"));
 175                 }
 176                 return error(_("packet write with format failed"));
 177         }
 178
 179         return 0;
 180 }
 181
 182 void packet_write_fmt(int fd, const char *fmt, ...)
 183 {
 184         va_list args;
 185
 186         va_start(args, fmt);
 187         packet_write_fmt_1(fd, 0, "", fmt, args);
 188         va_end(args);
 189 }
 190
 191 int packet_write_fmt_gently(int fd, const char *fmt, ...)
 192 {
 193         int status;
 194         va_list args;
 195
 196         va_start(args, fmt);
 197         status = packet_write_fmt_1(fd, 1, "", fmt, args);
 198         va_end(args);
 199         return status;
 200 }
 201
 202 static int do_packet_write(const int fd_out, const char *buf, size_t size,
 203                            struct strbuf *err)
 204 {
 205         char header[4];
 206         size_t packet_size;
 207
 208         if (size > LARGE_PACKET_DATA_MAX) {
 209                 strbuf_addstr(err, _("packet write failed - data exceeds max packet size"));
 210                 return -1;
 211         }
 212
 213         packet_trace(buf, size, 1);
 214         packet_size = size + 4;
 215
 216         set_packet_header(header, packet_size);
 217
 218         /*
 219          * Write the header and the buffer in 2 parts so that we do
 220          * not need to allocate a buffer or rely on a static buffer.
 221          * This also avoids putting a large buffer on the stack which
 222          * might have multi-threading issues.
 223          */
 224
 225         if (write_in_full(fd_out, header, 4) < 0 ||
 226             write_in_full(fd_out, buf, size) < 0) {
 227                 strbuf_addf(err, _("packet write failed: %s"), strerror(errno));
 228                 return -1;
 229         }
 230         return 0;
 231 }
 232
 233 static int packet_write_gently(const int fd_out, const char *buf, size_t size)
 234 {
 235         struct strbuf err = STRBUF_INIT;
 236         if (do_packet_write(fd_out, buf, size, &err)) {
 237                 error("%s", err.buf);
 238                 strbuf_release(&err);
 239                 return -1;
 240         }
 241         return 0;
 242 }
 243
 244 void packet_write(int fd_out, const char *buf, size_t size)
 245 {
 246         struct strbuf err = STRBUF_INIT;
 247         if (do_packet_write(fd_out, buf, size, &err))
 248                 die("%s", err.buf);
 249 }
 250
 251 void packet_fwrite(FILE *f, const char *buf, size_t size)
 252 {
 253         size_t packet_size;
 254         char header[4];
 255
 256         if (size > LARGE_PACKET_DATA_MAX)
 257                 die(_("packet write failed - data exceeds max packet size"));
 258
 259         packet_trace(buf, size, 1);
 260         packet_size = size + 4;
 261
 262         set_packet_header(header, packet_size);
 263         fwrite_or_die(f, header, 4);
 264         fwrite_or_die(f, buf, size);
 265 }
 266
 267 void packet_fwrite_fmt(FILE *fh, const char *fmt, ...)
 268 {
 269        static struct strbuf buf = STRBUF_INIT;
 270        va_list args;
 271
 272        strbuf_reset(&buf);
 273
 274        va_start(args, fmt);
 275        format_packet(&buf, "", fmt, args);
 276        va_end(args);
 277
 278        fwrite_or_die(fh, buf.buf, buf.len);
 279 }
 280
 281 void packet_fflush(FILE *f)
 282 {
 283         packet_trace("0000", 4, 1);
 284         fwrite_or_die(f, "0000", 4);
 285         fflush_or_die(f);
 286 }
 287
 288 void packet_buf_write(struct strbuf *buf, const char *fmt, ...)
 289 {
 290         va_list args;
 291
 292         va_start(args, fmt);
 293         format_packet(buf, "", fmt, args);
 294         va_end(args);
 295 }
 296
 297 int write_packetized_from_fd_no_flush(int fd_in, int fd_out)
 298 {
 299         char *buf = xmalloc(LARGE_PACKET_DATA_MAX);
 300         int err = 0;
 301         ssize_t bytes_to_write;
 302
 303         while (!err) {
 304                 bytes_to_write = xread(fd_in, buf, LARGE_PACKET_DATA_MAX);
 305                 if (bytes_to_write < 0) {
 306                         free(buf);
 307                         return COPY_READ_ERROR;
 308                 }
 309                 if (bytes_to_write == 0)
 310                         break;
 311                 err = packet_write_gently(fd_out, buf, bytes_to_write);
 312         }
 313         free(buf);
 314         return err;
 315 }
 316
 317 int write_packetized_from_buf_no_flush_count(const char *src_in, size_t len,
 318                                              int fd_out, int *packet_counter)
 319 {
 320         int err = 0;
 321         size_t bytes_written = 0;
 322         size_t bytes_to_write;
 323
 324         while (!err) {
 325                 if ((len - bytes_written) > LARGE_PACKET_DATA_MAX)
 326                         bytes_to_write = LARGE_PACKET_DATA_MAX;
 327                 else
 328                         bytes_to_write = len - bytes_written;
 329                 if (bytes_to_write == 0)
 330                         break;
 331                 err = packet_write_gently(fd_out, src_in + bytes_written, bytes_to_write);
 332                 bytes_written += bytes_to_write;
 333                 if (packet_counter)
 334                         (*packet_counter)++;
 335         }
 336         return err;
 337 }
 338
 339 static int get_packet_data(int fd, char **src_buf, size_t *src_size,
 340                            void *dst, unsigned size, int options)
 341 {
 342         ssize_t ret;
 343
 344         if (fd >= 0 && src_buf && *src_buf)
 345                 BUG("multiple sources given to packet_read");
 346
 347         /* Read up to "size" bytes from our source, whatever it is. */
 348         if (src_buf && *src_buf) {
 349                 ret = size < *src_size ? size : *src_size;
 350                 memcpy(dst, *src_buf, ret);
 351                 *src_buf += ret;
 352                 *src_size -= ret;
 353         } else {
 354                 ret = read_in_full(fd, dst, size);
 355                 if (ret < 0) {
 356                         if (options & PACKET_READ_GENTLE_ON_READ_ERROR)
 357                                 return error_errno(_("read error"));
 358                         die_errno(_("read error"));
 359                 }
 360         }
 361
 362         /* And complain if we didn't get enough bytes to satisfy the read. */
 363         if (ret != size) {
 364                 if (options & PACKET_READ_GENTLE_ON_EOF)
 365                         return -1;
 366
 367                 if (options & PACKET_READ_GENTLE_ON_READ_ERROR)
 368                         return error(_("the remote end hung up unexpectedly"));
 369                 die(_("the remote end hung up unexpectedly"));
 370         }
 371
 372         return ret;
 373 }
 374
 375 int packet_length(const char lenbuf_hex[4], size_t size)
 376 {
 377         if (size < 4)
 378                 BUG("buffer too small");
 379         return  hexval(lenbuf_hex[0]) << 12 |
 380                 hexval(lenbuf_hex[1]) <<  8 |
 381                 hexval(lenbuf_hex[2]) <<  4 |
 382                 hexval(lenbuf_hex[3]);
 383 }
 384
 385 static char *find_packfile_uri_path(const char *buffer)
 386 {
 387         const char *URI_MARK = "://";
 388         char *path;
 389         int len;
 390
 391         /* First char is sideband mark */
 392         buffer += 1;
 393
 394         len = strspn(buffer, "0123456789abcdefABCDEF");
 395         /* size of SHA1 and SHA256 hash */
 396         if (!(len == 40 || len == 64) || buffer[len] != ' ')
 397                 return NULL; /* required "<hash>SP" not seen */
 398
 399         path = strstr(buffer + len + 1, URI_MARK);
 400         if (!path)
 401                 return NULL;
 402
 403         path = strchr(path + strlen(URI_MARK), '/');
 404         if (!path || !*(path + 1))
 405                 return NULL;
 406
 407         /* position after '/' */
 408         return ++path;
 409 }
 410
 411 enum packet_read_status packet_read_with_status(int fd, char **src_buffer,
 412                                                 size_t *src_len, char *buffer,
 413                                                 unsigned size, int *pktlen,
 414                                                 int options)
 415 {
 416         int len;
 417         char linelen[4];
 418         char *uri_path_start;
 419
 420         if (get_packet_data(fd, src_buffer, src_len, linelen, 4, options) < 0) {
 421                 *pktlen = -1;
 422                 return PACKET_READ_EOF;
 423         }
 424
 425         len = packet_length(linelen, sizeof(linelen));
 426
 427         if (len < 0) {
 428                 if (options & PACKET_READ_GENTLE_ON_READ_ERROR)
 429                         return error(_("protocol error: bad line length "
 430                                        "character: %.4s"), linelen);
 431                 die(_("protocol error: bad line length character: %.4s"), linelen);
 432         } else if (!len) {
 433                 packet_trace("0000", 4, 0);
 434                 *pktlen = 0;
 435                 return PACKET_READ_FLUSH;
 436         } else if (len == 1) {
 437                 packet_trace("0001", 4, 0);
 438                 *pktlen = 0;
 439                 return PACKET_READ_DELIM;
 440         } else if (len == 2) {
 441                 packet_trace("0002", 4, 0);
 442                 *pktlen = 0;
 443                 return PACKET_READ_RESPONSE_END;
 444         } else if (len < 4) {
 445                 if (options & PACKET_READ_GENTLE_ON_READ_ERROR)
 446                         return error(_("protocol error: bad line length %d"),
 447                                      len);
 448                 die(_("protocol error: bad line length %d"), len);
 449         }
 450
 451         len -= 4;
 452         if ((unsigned)len >= size) {
 453                 if (options & PACKET_READ_GENTLE_ON_READ_ERROR)
 454                         return error(_("protocol error: bad line length %d"),
 455                                      len);
 456                 die(_("protocol error: bad line length %d"), len);
 457         }
 458
 459         if (get_packet_data(fd, src_buffer, src_len, buffer, len, options) < 0) {
 460                 *pktlen = -1;
 461                 return PACKET_READ_EOF;
 462         }
 463
 464         if ((options & PACKET_READ_CHOMP_NEWLINE) &&
 465             len && buffer[len-1] == '\n')
 466                 len--;
 467
 468         buffer[len] = 0;
 469         if (options & PACKET_READ_REDACT_URI_PATH &&
 470             (uri_path_start = find_packfile_uri_path(buffer))) {
 471                 const char *redacted = "<redacted>";
 472                 struct strbuf tracebuf = STRBUF_INIT;
 473                 strbuf_insert(&tracebuf, 0, buffer, len);
 474                 strbuf_splice(&tracebuf, uri_path_start - buffer,
 475                               strlen(uri_path_start), redacted, strlen(redacted));
 476                 packet_trace(tracebuf.buf, tracebuf.len, 0);
 477                 strbuf_release(&tracebuf);
 478         } else {
 479                 packet_trace(buffer, len, 0);
 480         }
 481
 482         if ((options & PACKET_READ_DIE_ON_ERR_PACKET) &&
 483             starts_with(buffer, "ERR "))
 484                 die(_("remote error: %s"), buffer + 4);
 485
 486         *pktlen = len;
 487         return PACKET_READ_NORMAL;
 488 }
 489
 490 int packet_read(int fd, char *buffer, unsigned size, int options)
 491 {
 492         int pktlen = -1;
 493
 494         packet_read_with_status(fd, NULL, NULL, buffer, size, &pktlen,
 495                                 options);
 496
 497         return pktlen;
 498 }
 499
 500 char *packet_read_line(int fd, int *dst_len)
 501 {
 502         int len = packet_read(fd, packet_buffer, sizeof(packet_buffer),
 503                               PACKET_READ_CHOMP_NEWLINE);
 504         if (dst_len)
 505                 *dst_len = len;
 506         return (len > 0) ? packet_buffer : NULL;
 507 }
 508
 509 int packet_read_line_gently(int fd, int *dst_len, char **dst_line)
 510 {
 511         int len = packet_read(fd, packet_buffer, sizeof(packet_buffer),
 512                               PACKET_READ_CHOMP_NEWLINE|PACKET_READ_GENTLE_ON_EOF);
 513         if (dst_len)
 514                 *dst_len = len;
 515         if (dst_line)
 516                 *dst_line = (len > 0) ? packet_buffer : NULL;
 517         return len;
 518 }
 519
 520 ssize_t read_packetized_to_strbuf(int fd_in, struct strbuf *sb_out, int options)
 521 {
 522         int packet_len;
 523
 524         size_t orig_len = sb_out->len;
 525         size_t orig_alloc = sb_out->alloc;
 526
 527         for (;;) {
 528                 strbuf_grow(sb_out, LARGE_PACKET_DATA_MAX);
 529                 packet_len = packet_read(fd_in,
 530                         /* strbuf_grow() above always allocates one extra byte to
 531                          * store a '\0' at the end of the string. packet_read()
 532                          * writes a '\0' extra byte at the end, too. Let it know
 533                          * that there is already room for the extra byte.
 534                          */
 535                         sb_out->buf + sb_out->len, LARGE_PACKET_DATA_MAX+1,
 536                         options);
 537                 if (packet_len <= 0)
 538                         break;
 539                 sb_out->len += packet_len;
 540         }
 541
 542         if (packet_len < 0) {
 543                 if (orig_alloc == 0)
 544                         strbuf_release(sb_out);
 545                 else
 546                         strbuf_setlen(sb_out, orig_len);
 547                 return packet_len;
 548         }
 549         return sb_out->len - orig_len;
 550 }
 551
 552 int recv_sideband(const char *me, int in_stream, int out)
 553 {
 554         char buf[LARGE_PACKET_MAX + 1];
 555         int len;
 556         struct strbuf scratch = STRBUF_INIT;
 557         enum sideband_type sideband_type;
 558
 559         while (1) {
 560                 int status = packet_read_with_status(in_stream, NULL, NULL,
 561                                                      buf, LARGE_PACKET_MAX,
 562                                                      &len,
 563                                                      PACKET_READ_GENTLE_ON_EOF);
 564                 if (!demultiplex_sideband(me, status, buf, len, 0, &scratch,
 565                                           &sideband_type))
 566                         continue;
 567                 switch (sideband_type) {
 568                 case SIDEBAND_PRIMARY:
 569                         write_or_die(out, buf + 1, len - 1);
 570                         break;
 571                 default: /* errors: message already written */
 572                         if (scratch.len > 0)
 573                                 BUG("unhandled incomplete sideband: '%s'",
 574                                     scratch.buf);
 575                         return sideband_type;
 576                 }
 577         }
 578 }
 579
 580 /* Packet Reader Functions */
 581 void packet_reader_init(struct packet_reader *reader, int fd,
 582                         char *src_buffer, size_t src_len,
 583                         int options)
 584 {
 585         memset(reader, 0, sizeof(*reader));
 586
 587         reader->fd = fd;
 588         reader->src_buffer = src_buffer;
 589         reader->src_len = src_len;
 590         reader->buffer = packet_buffer;
 591         reader->buffer_size = sizeof(packet_buffer);
 592         reader->options = options;
 593         reader->me = "git";
 594         reader->hash_algo = &hash_algos[GIT_HASH_SHA1];
 595 }
 596
 597 enum packet_read_status packet_reader_read(struct packet_reader *reader)
 598 {
 599         struct strbuf scratch = STRBUF_INIT;
 600
 601         if (reader->line_peeked) {
 602                 reader->line_peeked = 0;
 603                 return reader->status;
 604         }
 605
 606         /*
 607          * Consume all progress packets until a primary payload packet is
 608          * received
 609          */
 610         while (1) {
 611                 enum sideband_type sideband_type;
 612                 reader->status = packet_read_with_status(reader->fd,
 613                                                          &reader->src_buffer,
 614                                                          &reader->src_len,
 615                                                          reader->buffer,
 616                                                          reader->buffer_size,
 617                                                          &reader->pktlen,
 618                                                          reader->options);
 619                 if (!reader->use_sideband)
 620                         break;
 621                 if (demultiplex_sideband(reader->me, reader->status,
 622                                          reader->buffer, reader->pktlen, 1,
 623                                          &scratch, &sideband_type))
 624                         break;
 625         }
 626
 627         if (reader->status == PACKET_READ_NORMAL)
 628                 /* Skip the sideband designator if sideband is used */
 629                 reader->line = reader->use_sideband ?
 630                         reader->buffer + 1 : reader->buffer;
 631         else
 632                 reader->line = NULL;
 633
 634         return reader->status;
 635 }
 636
 637 enum packet_read_status packet_reader_peek(struct packet_reader *reader)
 638 {
 639         /* Only allow peeking a single line */
 640         if (reader->line_peeked)
 641                 return reader->status;
 642
 643         /* Peek a line by reading it and setting peeked flag */
 644         packet_reader_read(reader);
 645         reader->line_peeked = 1;
 646         return reader->status;
 647 }
 648
 649 void packet_writer_init(struct packet_writer *writer, int dest_fd)
 650 {
 651         writer->dest_fd = dest_fd;
 652         writer->use_sideband = 0;
 653 }
 654
 655 void packet_writer_write(struct packet_writer *writer, const char *fmt, ...)
 656 {
 657         va_list args;
 658
 659         va_start(args, fmt);
 660         packet_write_fmt_1(writer->dest_fd, 0,
 661                            writer->use_sideband ? "\001" : "", fmt, args);
 662         va_end(args);
 663 }
 664
 665 void packet_writer_error(struct packet_writer *writer, const char *fmt, ...)
 666 {
 667         va_list args;
 668
 669         va_start(args, fmt);
 670         packet_write_fmt_1(writer->dest_fd, 0,
 671                            writer->use_sideband ? "\003" : "ERR ", fmt, args);
 672         va_end(args);
 673 }
 674
 675 void packet_writer_delim(struct packet_writer *writer)
 676 {
 677         packet_delim(writer->dest_fd);
 678 }
 679
 680 void packet_writer_flush(struct packet_writer *writer)
 681 {
 682         packet_flush(writer->dest_fd);
 683 }