freshlybakedca.ke
Git fork
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 "sideband.h"
8#include "trace.h"
9#include "write-or-die.h"
10
11char packet_buffer[LARGE_PACKET_MAX];
12static const char *packet_trace_prefix = "git";
13static struct trace_key trace_packet = TRACE_KEY_INIT(PACKET);
14static struct trace_key trace_pack = TRACE_KEY_INIT(PACKFILE);
15
16void packet_trace_identity(const char *prog)
17{
18 packet_trace_prefix = xstrdup(prog);
19}
20
21static const char *get_trace_prefix(void)
22{
23 return in_async() ? "sideband" : packet_trace_prefix;
24}
25
26static int packet_trace_pack(const char *buf, unsigned int len, int sideband)
27{
28 if (!sideband) {
29 trace_verbatim(&trace_pack, buf, len);
30 return 1;
31 } else if (len && *buf == '\1') {
32 trace_verbatim(&trace_pack, buf + 1, len - 1);
33 return 1;
34 } else {
35 /* it's another non-pack sideband */
36 return 0;
37 }
38}
39
40static void packet_trace(const char *buf, unsigned int len, int write)
41{
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 (unsigned int 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 */
93void 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
100void 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
107void 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
114int 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
122void packet_buf_flush(struct strbuf *buf)
123{
124 packet_trace("0000", 4, 1);
125 strbuf_add(buf, "0000", 4);
126}
127
128void packet_buf_delim(struct strbuf *buf)
129{
130 packet_trace("0001", 4, 1);
131 strbuf_add(buf, "0001", 4);
132}
133
134void 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
146static 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
164static 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
182void 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
191int 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
202static 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
233static 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
244void 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
251void 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
267void 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
281void 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
288void 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
297int 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
317int 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
339static int get_packet_data(int fd, char **src_buf, size_t *src_size,
340 void *dst, size_t size, int options)
341{
342 size_t bytes_read;
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 bytes_read = size < *src_size ? size : *src_size;
350 memcpy(dst, *src_buf, bytes_read);
351 *src_buf += bytes_read;
352 *src_size -= bytes_read;
353 } else {
354 ssize_t 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 bytes_read = (size_t) ret;
362 }
363
364 /* And complain if we didn't get enough bytes to satisfy the read. */
365 if (bytes_read != size) {
366 if (options & PACKET_READ_GENTLE_ON_EOF)
367 return -1;
368
369 if (options & PACKET_READ_GENTLE_ON_READ_ERROR)
370 return error(_("the remote end hung up unexpectedly"));
371 die(_("the remote end hung up unexpectedly"));
372 }
373
374 return 0;
375}
376
377int packet_length(const char lenbuf_hex[4], size_t size)
378{
379 if (size < 4)
380 BUG("buffer too small");
381 return hexval(lenbuf_hex[0]) << 12 |
382 hexval(lenbuf_hex[1]) << 8 |
383 hexval(lenbuf_hex[2]) << 4 |
384 hexval(lenbuf_hex[3]);
385}
386
387static char *find_packfile_uri_path(const char *buffer)
388{
389 const char *URI_MARK = "://";
390 char *path;
391 int len;
392
393 /* First char is sideband mark */
394 buffer += 1;
395
396 len = strspn(buffer, "0123456789abcdefABCDEF");
397 /* size of SHA1 and SHA256 hash */
398 if (!(len == 40 || len == 64) || buffer[len] != ' ')
399 return NULL; /* required "<hash>SP" not seen */
400
401 path = strstr(buffer + len + 1, URI_MARK);
402 if (!path)
403 return NULL;
404
405 path = strchr(path + strlen(URI_MARK), '/');
406 if (!path || !*(path + 1))
407 return NULL;
408
409 /* position after '/' */
410 return ++path;
411}
412
413enum packet_read_status packet_read_with_status(int fd, char **src_buffer,
414 size_t *src_len, char *buffer,
415 unsigned size, int *pktlen,
416 int options)
417{
418 int len;
419 char linelen[4];
420 char *uri_path_start;
421
422 if (get_packet_data(fd, src_buffer, src_len, linelen, 4, options) < 0) {
423 *pktlen = -1;
424 return PACKET_READ_EOF;
425 }
426
427 len = packet_length(linelen, sizeof(linelen));
428
429 if (len < 0) {
430 if (options & PACKET_READ_GENTLE_ON_READ_ERROR)
431 return error(_("protocol error: bad line length "
432 "character: %.4s"), linelen);
433 die(_("protocol error: bad line length character: %.4s"), linelen);
434 } else if (!len) {
435 packet_trace("0000", 4, 0);
436 *pktlen = 0;
437 return PACKET_READ_FLUSH;
438 } else if (len == 1) {
439 packet_trace("0001", 4, 0);
440 *pktlen = 0;
441 return PACKET_READ_DELIM;
442 } else if (len == 2) {
443 packet_trace("0002", 4, 0);
444 *pktlen = 0;
445 return PACKET_READ_RESPONSE_END;
446 } else if (len < 4) {
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 len -= 4;
454 if ((unsigned)len >= size) {
455 if (options & PACKET_READ_GENTLE_ON_READ_ERROR)
456 return error(_("protocol error: bad line length %d"),
457 len);
458 die(_("protocol error: bad line length %d"), len);
459 }
460
461 if (get_packet_data(fd, src_buffer, src_len, buffer, len, options) < 0) {
462 *pktlen = -1;
463 return PACKET_READ_EOF;
464 }
465
466 if ((options & PACKET_READ_CHOMP_NEWLINE) &&
467 len && buffer[len-1] == '\n') {
468 if (options & PACKET_READ_USE_SIDEBAND) {
469 int band = *buffer & 0xff;
470 switch (band) {
471 case 1:
472 /* Chomp newline for payload */
473 len--;
474 break;
475 case 2:
476 case 3:
477 /*
478 * Do not chomp newline for progress and error
479 * message.
480 */
481 break;
482 default:
483 /*
484 * Bad sideband, let's leave it to
485 * demultiplex_sideband() to catch this error.
486 */
487 break;
488 }
489 } else {
490 len--;
491 }
492 }
493
494 buffer[len] = 0;
495 if (options & PACKET_READ_REDACT_URI_PATH &&
496 (uri_path_start = find_packfile_uri_path(buffer))) {
497 const char *redacted = "<redacted>";
498 struct strbuf tracebuf = STRBUF_INIT;
499 strbuf_insert(&tracebuf, 0, buffer, len);
500 strbuf_splice(&tracebuf, uri_path_start - buffer,
501 strlen(uri_path_start), redacted, strlen(redacted));
502 packet_trace(tracebuf.buf, tracebuf.len, 0);
503 strbuf_release(&tracebuf);
504 } else {
505 packet_trace(buffer, len, 0);
506 }
507
508 if ((options & PACKET_READ_DIE_ON_ERR_PACKET) &&
509 starts_with(buffer, "ERR "))
510 die(_("remote error: %s"), buffer + 4);
511
512 *pktlen = len;
513 return PACKET_READ_NORMAL;
514}
515
516int packet_read(int fd, char *buffer, unsigned size, int options)
517{
518 int pktlen = -1;
519
520 packet_read_with_status(fd, NULL, NULL, buffer, size, &pktlen,
521 options);
522
523 return pktlen;
524}
525
526char *packet_read_line(int fd, int *dst_len)
527{
528 int len = packet_read(fd, packet_buffer, sizeof(packet_buffer),
529 PACKET_READ_CHOMP_NEWLINE);
530 if (dst_len)
531 *dst_len = len;
532 return (len > 0) ? packet_buffer : NULL;
533}
534
535int packet_read_line_gently(int fd, int *dst_len, char **dst_line)
536{
537 int len = packet_read(fd, packet_buffer, sizeof(packet_buffer),
538 PACKET_READ_CHOMP_NEWLINE|PACKET_READ_GENTLE_ON_EOF);
539 if (dst_len)
540 *dst_len = len;
541 if (dst_line)
542 *dst_line = (len > 0) ? packet_buffer : NULL;
543 return len;
544}
545
546ssize_t read_packetized_to_strbuf(int fd_in, struct strbuf *sb_out, int options)
547{
548 int packet_len;
549
550 size_t orig_len = sb_out->len;
551 size_t orig_alloc = sb_out->alloc;
552
553 for (;;) {
554 strbuf_grow(sb_out, LARGE_PACKET_DATA_MAX);
555 packet_len = packet_read(fd_in,
556 /* strbuf_grow() above always allocates one extra byte to
557 * store a '\0' at the end of the string. packet_read()
558 * writes a '\0' extra byte at the end, too. Let it know
559 * that there is already room for the extra byte.
560 */
561 sb_out->buf + sb_out->len, LARGE_PACKET_DATA_MAX+1,
562 options);
563 if (packet_len <= 0)
564 break;
565 sb_out->len += packet_len;
566 }
567
568 if (packet_len < 0) {
569 if (orig_alloc == 0)
570 strbuf_release(sb_out);
571 else
572 strbuf_setlen(sb_out, orig_len);
573 return packet_len;
574 }
575 return sb_out->len - orig_len;
576}
577
578int recv_sideband(const char *me, int in_stream, int out)
579{
580 char buf[LARGE_PACKET_MAX + 1];
581 int len;
582 struct strbuf scratch = STRBUF_INIT;
583 enum sideband_type sideband_type;
584
585 while (1) {
586 int status = packet_read_with_status(in_stream, NULL, NULL,
587 buf, LARGE_PACKET_MAX,
588 &len,
589 PACKET_READ_GENTLE_ON_EOF);
590 if (!demultiplex_sideband(me, status, buf, len, 0, &scratch,
591 &sideband_type))
592 continue;
593 switch (sideband_type) {
594 case SIDEBAND_PRIMARY:
595 write_or_die(out, buf + 1, len - 1);
596 break;
597 default: /* errors: message already written */
598 if (scratch.len > 0)
599 BUG("unhandled incomplete sideband: '%s'",
600 scratch.buf);
601 return sideband_type;
602 }
603 }
604}
605
606/* Packet Reader Functions */
607void packet_reader_init(struct packet_reader *reader, int fd,
608 char *src_buffer, size_t src_len,
609 int options)
610{
611 memset(reader, 0, sizeof(*reader));
612
613 reader->fd = fd;
614 reader->src_buffer = src_buffer;
615 reader->src_len = src_len;
616 reader->buffer = packet_buffer;
617 reader->buffer_size = sizeof(packet_buffer);
618 reader->options = options;
619 reader->me = "git";
620 reader->hash_algo = &hash_algos[GIT_HASH_SHA1_LEGACY];
621 strbuf_init(&reader->scratch, 0);
622}
623
624enum packet_read_status packet_reader_read(struct packet_reader *reader)
625{
626 if (reader->line_peeked) {
627 reader->line_peeked = 0;
628 return reader->status;
629 }
630
631 if (reader->use_sideband)
632 reader->options |= PACKET_READ_USE_SIDEBAND;
633
634 /*
635 * Consume all progress packets until a primary payload packet is
636 * received
637 */
638 while (1) {
639 enum sideband_type sideband_type;
640 reader->status = packet_read_with_status(reader->fd,
641 &reader->src_buffer,
642 &reader->src_len,
643 reader->buffer,
644 reader->buffer_size,
645 &reader->pktlen,
646 reader->options);
647 if (!reader->use_sideband)
648 break;
649 if (demultiplex_sideband(reader->me, reader->status,
650 reader->buffer, reader->pktlen, 1,
651 &reader->scratch, &sideband_type))
652 break;
653 }
654
655 if (reader->status == PACKET_READ_NORMAL)
656 /* Skip the sideband designator if sideband is used */
657 reader->line = reader->use_sideband ?
658 reader->buffer + 1 : reader->buffer;
659 else
660 reader->line = NULL;
661
662 return reader->status;
663}
664
665enum packet_read_status packet_reader_peek(struct packet_reader *reader)
666{
667 /* Only allow peeking a single line */
668 if (reader->line_peeked)
669 return reader->status;
670
671 /* Peek a line by reading it and setting peeked flag */
672 packet_reader_read(reader);
673 reader->line_peeked = 1;
674 return reader->status;
675}
676
677void packet_writer_init(struct packet_writer *writer, int dest_fd)
678{
679 writer->dest_fd = dest_fd;
680 writer->use_sideband = 0;
681}
682
683void packet_writer_write(struct packet_writer *writer, const char *fmt, ...)
684{
685 va_list args;
686
687 va_start(args, fmt);
688 packet_write_fmt_1(writer->dest_fd, 0,
689 writer->use_sideband ? "\001" : "", fmt, args);
690 va_end(args);
691}
692
693void packet_writer_error(struct packet_writer *writer, const char *fmt, ...)
694{
695 va_list args;
696
697 va_start(args, fmt);
698 packet_write_fmt_1(writer->dest_fd, 0,
699 writer->use_sideband ? "\003" : "ERR ", fmt, args);
700 va_end(args);
701}
702
703void packet_writer_delim(struct packet_writer *writer)
704{
705 packet_delim(writer->dest_fd);
706}
707
708void packet_writer_flush(struct packet_writer *writer)
709{
710 packet_flush(writer->dest_fd);
711}