pkt-line.c

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