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 "trace.h"
   7 #include "wrapper.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])
 376 {
 377         int val = hex2chr(lenbuf_hex);
 378         return (val < 0) ? val : (val << 8) | hex2chr(lenbuf_hex + 2);
 379 }
 380
 381 static char *find_packfile_uri_path(const char *buffer)
 382 {
 383         const char *URI_MARK = "://";
 384         char *path;
 385         int len;
 386
 387         /* First char is sideband mark */
 388         buffer += 1;
 389
 390         len = strspn(buffer, "0123456789abcdefABCDEF");
 391         /* size of SHA1 and SHA256 hash */
 392         if (!(len == 40 || len == 64) || buffer[len] != ' ')
 393                 return NULL; /* required "<hash>SP" not seen */
 394
 395         path = strstr(buffer + len + 1, URI_MARK);
 396         if (!path)
 397                 return NULL;
 398
 399         path = strchr(path + strlen(URI_MARK), '/');
 400         if (!path || !*(path + 1))
 401                 return NULL;
 402
 403         /* position after '/' */
 404         return ++path;
 405 }
 406
 407 enum packet_read_status packet_read_with_status(int fd, char **src_buffer,
 408                                                 size_t *src_len, char *buffer,
 409                                                 unsigned size, int *pktlen,
 410                                                 int options)
 411 {
 412         int len;
 413         char linelen[4];
 414         char *uri_path_start;
 415
 416         if (get_packet_data(fd, src_buffer, src_len, linelen, 4, options) < 0) {
 417                 *pktlen = -1;
 418                 return PACKET_READ_EOF;
 419         }
 420
 421         len = packet_length(linelen);
 422
 423         if (len < 0) {
 424                 if (options & PACKET_READ_GENTLE_ON_READ_ERROR)
 425                         return error(_("protocol error: bad line length "
 426                                        "character: %.4s"), linelen);
 427                 die(_("protocol error: bad line length character: %.4s"), linelen);
 428         } else if (!len) {
 429                 packet_trace("0000", 4, 0);
 430                 *pktlen = 0;
 431                 return PACKET_READ_FLUSH;
 432         } else if (len == 1) {
 433                 packet_trace("0001", 4, 0);
 434                 *pktlen = 0;
 435                 return PACKET_READ_DELIM;
 436         } else if (len == 2) {
 437                 packet_trace("0002", 4, 0);
 438                 *pktlen = 0;
 439                 return PACKET_READ_RESPONSE_END;
 440         } else if (len < 4) {
 441                 if (options & PACKET_READ_GENTLE_ON_READ_ERROR)
 442                         return error(_("protocol error: bad line length %d"),
 443                                      len);
 444                 die(_("protocol error: bad line length %d"), len);
 445         }
 446
 447         len -= 4;
 448         if ((unsigned)len >= size) {
 449                 if (options & PACKET_READ_GENTLE_ON_READ_ERROR)
 450                         return error(_("protocol error: bad line length %d"),
 451                                      len);
 452                 die(_("protocol error: bad line length %d"), len);
 453         }
 454
 455         if (get_packet_data(fd, src_buffer, src_len, buffer, len, options) < 0) {
 456                 *pktlen = -1;
 457                 return PACKET_READ_EOF;
 458         }
 459
 460         if ((options & PACKET_READ_CHOMP_NEWLINE) &&
 461             len && buffer[len-1] == '\n')
 462                 len--;
 463
 464         buffer[len] = 0;
 465         if (options & PACKET_READ_REDACT_URI_PATH &&
 466             (uri_path_start = find_packfile_uri_path(buffer))) {
 467                 const char *redacted = "<redacted>";
 468                 struct strbuf tracebuf = STRBUF_INIT;
 469                 strbuf_insert(&tracebuf, 0, buffer, len);
 470                 strbuf_splice(&tracebuf, uri_path_start - buffer,
 471                               strlen(uri_path_start), redacted, strlen(redacted));
 472                 packet_trace(tracebuf.buf, tracebuf.len, 0);
 473                 strbuf_release(&tracebuf);
 474         } else {
 475                 packet_trace(buffer, len, 0);
 476         }
 477
 478         if ((options & PACKET_READ_DIE_ON_ERR_PACKET) &&
 479             starts_with(buffer, "ERR "))
 480                 die(_("remote error: %s"), buffer + 4);
 481
 482         *pktlen = len;
 483         return PACKET_READ_NORMAL;
 484 }
 485
 486 int packet_read(int fd, char *buffer, unsigned size, int options)
 487 {
 488         int pktlen = -1;
 489
 490         packet_read_with_status(fd, NULL, NULL, buffer, size, &pktlen,
 491                                 options);
 492
 493         return pktlen;
 494 }
 495
 496 char *packet_read_line(int fd, int *dst_len)
 497 {
 498         int len = packet_read(fd, packet_buffer, sizeof(packet_buffer),
 499                               PACKET_READ_CHOMP_NEWLINE);
 500         if (dst_len)
 501                 *dst_len = len;
 502         return (len > 0) ? packet_buffer : NULL;
 503 }
 504
 505 int packet_read_line_gently(int fd, int *dst_len, char **dst_line)
 506 {
 507         int len = packet_read(fd, packet_buffer, sizeof(packet_buffer),
 508                               PACKET_READ_CHOMP_NEWLINE|PACKET_READ_GENTLE_ON_EOF);
 509         if (dst_len)
 510                 *dst_len = len;
 511         if (dst_line)
 512                 *dst_line = (len > 0) ? packet_buffer : NULL;
 513         return len;
 514 }
 515
 516 ssize_t read_packetized_to_strbuf(int fd_in, struct strbuf *sb_out, int options)
 517 {
 518         int packet_len;
 519
 520         size_t orig_len = sb_out->len;
 521         size_t orig_alloc = sb_out->alloc;
 522
 523         for (;;) {
 524                 strbuf_grow(sb_out, LARGE_PACKET_DATA_MAX);
 525                 packet_len = packet_read(fd_in,
 526                         /* strbuf_grow() above always allocates one extra byte to
 527                          * store a '\0' at the end of the string. packet_read()
 528                          * writes a '\0' extra byte at the end, too. Let it know
 529                          * that there is already room for the extra byte.
 530                          */
 531                         sb_out->buf + sb_out->len, LARGE_PACKET_DATA_MAX+1,
 532                         options);
 533                 if (packet_len <= 0)
 534                         break;
 535                 sb_out->len += packet_len;
 536         }
 537
 538         if (packet_len < 0) {
 539                 if (orig_alloc == 0)
 540                         strbuf_release(sb_out);
 541                 else
 542                         strbuf_setlen(sb_out, orig_len);
 543                 return packet_len;
 544         }
 545         return sb_out->len - orig_len;
 546 }
 547
 548 int recv_sideband(const char *me, int in_stream, int out)
 549 {
 550         char buf[LARGE_PACKET_MAX + 1];
 551         int len;
 552         struct strbuf scratch = STRBUF_INIT;
 553         enum sideband_type sideband_type;
 554
 555         while (1) {
 556                 int status = packet_read_with_status(in_stream, NULL, NULL,
 557                                                      buf, LARGE_PACKET_MAX,
 558                                                      &len,
 559                                                      PACKET_READ_GENTLE_ON_EOF);
 560                 if (!demultiplex_sideband(me, status, buf, len, 0, &scratch,
 561                                           &sideband_type))
 562                         continue;
 563                 switch (sideband_type) {
 564                 case SIDEBAND_PRIMARY:
 565                         write_or_die(out, buf + 1, len - 1);
 566                         break;
 567                 default: /* errors: message already written */
 568                         if (scratch.len > 0)
 569                                 BUG("unhandled incomplete sideband: '%s'",
 570                                     scratch.buf);
 571                         return sideband_type;
 572                 }
 573         }
 574 }
 575
 576 /* Packet Reader Functions */
 577 void packet_reader_init(struct packet_reader *reader, int fd,
 578                         char *src_buffer, size_t src_len,
 579                         int options)
 580 {
 581         memset(reader, 0, sizeof(*reader));
 582
 583         reader->fd = fd;
 584         reader->src_buffer = src_buffer;
 585         reader->src_len = src_len;
 586         reader->buffer = packet_buffer;
 587         reader->buffer_size = sizeof(packet_buffer);
 588         reader->options = options;
 589         reader->me = "git";
 590         reader->hash_algo = &hash_algos[GIT_HASH_SHA1];
 591 }
 592
 593 enum packet_read_status packet_reader_read(struct packet_reader *reader)
 594 {
 595         struct strbuf scratch = STRBUF_INIT;
 596
 597         if (reader->line_peeked) {
 598                 reader->line_peeked = 0;
 599                 return reader->status;
 600         }
 601
 602         /*
 603          * Consume all progress packets until a primary payload packet is
 604          * received
 605          */
 606         while (1) {
 607                 enum sideband_type sideband_type;
 608                 reader->status = packet_read_with_status(reader->fd,
 609                                                          &reader->src_buffer,
 610                                                          &reader->src_len,
 611                                                          reader->buffer,
 612                                                          reader->buffer_size,
 613                                                          &reader->pktlen,
 614                                                          reader->options);
 615                 if (!reader->use_sideband)
 616                         break;
 617                 if (demultiplex_sideband(reader->me, reader->status,
 618                                          reader->buffer, reader->pktlen, 1,
 619                                          &scratch, &sideband_type))
 620                         break;
 621         }
 622
 623         if (reader->status == PACKET_READ_NORMAL)
 624                 /* Skip the sideband designator if sideband is used */
 625                 reader->line = reader->use_sideband ?
 626                         reader->buffer + 1 : reader->buffer;
 627         else
 628                 reader->line = NULL;
 629
 630         return reader->status;
 631 }
 632
 633 enum packet_read_status packet_reader_peek(struct packet_reader *reader)
 634 {
 635         /* Only allow peeking a single line */
 636         if (reader->line_peeked)
 637                 return reader->status;
 638
 639         /* Peek a line by reading it and setting peeked flag */
 640         packet_reader_read(reader);
 641         reader->line_peeked = 1;
 642         return reader->status;
 643 }
 644
 645 void packet_writer_init(struct packet_writer *writer, int dest_fd)
 646 {
 647         writer->dest_fd = dest_fd;
 648         writer->use_sideband = 0;
 649 }
 650
 651 void packet_writer_write(struct packet_writer *writer, const char *fmt, ...)
 652 {
 653         va_list args;
 654
 655         va_start(args, fmt);
 656         packet_write_fmt_1(writer->dest_fd, 0,
 657                            writer->use_sideband ? "\001" : "", fmt, args);
 658         va_end(args);
 659 }
 660
 661 void packet_writer_error(struct packet_writer *writer, const char *fmt, ...)
 662 {
 663         va_list args;
 664
 665         va_start(args, fmt);
 666         packet_write_fmt_1(writer->dest_fd, 0,
 667                            writer->use_sideband ? "\003" : "ERR ", fmt, args);
 668         va_end(args);
 669 }
 670
 671 void packet_writer_delim(struct packet_writer *writer)
 672 {
 673         packet_delim(writer->dest_fd);
 674 }
 675
 676 void packet_writer_flush(struct packet_writer *writer)
 677 {
 678         packet_flush(writer->dest_fd);
 679 }