5 #include "run-command.h"
7 #include "write-or-die.h"
9 char packet_buffer
[LARGE_PACKET_MAX
];
10 static const char *packet_trace_prefix
= "git";
11 static struct trace_key trace_packet
= TRACE_KEY_INIT(PACKET
);
12 static struct trace_key trace_pack
= TRACE_KEY_INIT(PACKFILE
);
14 void packet_trace_identity(const char *prog
)
16 packet_trace_prefix
= xstrdup(prog
);
19 static const char *get_trace_prefix(void)
21 return in_async() ? "sideband" : packet_trace_prefix
;
24 static int packet_trace_pack(const char *buf
, unsigned int len
, int sideband
)
27 trace_verbatim(&trace_pack
, buf
, len
);
29 } else if (len
&& *buf
== '\1') {
30 trace_verbatim(&trace_pack
, buf
+ 1, len
- 1);
33 /* it's another non-pack sideband */
38 static void packet_trace(const char *buf
, unsigned int len
, int write
)
42 static int in_pack
, sideband
;
44 if (!trace_want(&trace_packet
) && !trace_want(&trace_pack
))
48 if (packet_trace_pack(buf
, len
, sideband
))
50 } else if (starts_with(buf
, "PACK") || starts_with(buf
, "\1PACK")) {
52 sideband
= *buf
== '\1';
53 packet_trace_pack(buf
, len
, sideband
);
56 * Make a note in the human-readable trace that the pack data
63 if (!trace_want(&trace_packet
))
66 /* +32 is just a guess for header + quoting */
67 strbuf_init(&out
, len
+32);
69 strbuf_addf(&out
, "packet: %12s%c ",
70 get_trace_prefix(), write
? '>' : '<');
72 /* XXX we should really handle printable utf8 */
73 for (i
= 0; i
< len
; i
++) {
74 /* suppress newlines */
77 if (buf
[i
] >= 0x20 && buf
[i
] <= 0x7e)
78 strbuf_addch(&out
, buf
[i
]);
80 strbuf_addf(&out
, "\\%o", buf
[i
]);
83 strbuf_addch(&out
, '\n');
84 trace_strbuf(&trace_packet
, &out
);
89 * If we buffered things up above (we don't, but we should),
92 void packet_flush(int fd
)
94 packet_trace("0000", 4, 1);
95 if (write_in_full(fd
, "0000", 4) < 0)
96 die_errno(_("unable to write flush packet"));
99 void packet_delim(int fd
)
101 packet_trace("0001", 4, 1);
102 if (write_in_full(fd
, "0001", 4) < 0)
103 die_errno(_("unable to write delim packet"));
106 void packet_response_end(int fd
)
108 packet_trace("0002", 4, 1);
109 if (write_in_full(fd
, "0002", 4) < 0)
110 die_errno(_("unable to write response end packet"));
113 int packet_flush_gently(int fd
)
115 packet_trace("0000", 4, 1);
116 if (write_in_full(fd
, "0000", 4) < 0)
117 return error(_("flush packet write failed"));
121 void packet_buf_flush(struct strbuf
*buf
)
123 packet_trace("0000", 4, 1);
124 strbuf_add(buf
, "0000", 4);
127 void packet_buf_delim(struct strbuf
*buf
)
129 packet_trace("0001", 4, 1);
130 strbuf_add(buf
, "0001", 4);
133 void set_packet_header(char *buf
, int size
)
135 static char hexchar
[] = "0123456789abcdef";
137 #define hex(a) (hexchar[(a) & 15])
138 buf
[0] = hex(size
>> 12);
139 buf
[1] = hex(size
>> 8);
140 buf
[2] = hex(size
>> 4);
145 static void format_packet(struct strbuf
*out
, const char *prefix
,
146 const char *fmt
, va_list args
)
151 strbuf_addstr(out
, "0000");
152 strbuf_addstr(out
, prefix
);
153 strbuf_vaddf(out
, fmt
, args
);
154 n
= out
->len
- orig_len
;
156 if (n
> LARGE_PACKET_MAX
)
157 die(_("protocol error: impossibly long line"));
159 set_packet_header(&out
->buf
[orig_len
], n
);
160 packet_trace(out
->buf
+ orig_len
+ 4, n
- 4, 1);
163 static int packet_write_fmt_1(int fd
, int gently
, const char *prefix
,
164 const char *fmt
, va_list args
)
166 static struct strbuf buf
= STRBUF_INIT
;
169 format_packet(&buf
, prefix
, fmt
, args
);
170 if (write_in_full(fd
, buf
.buf
, buf
.len
) < 0) {
173 die_errno(_("packet write with format failed"));
175 return error(_("packet write with format failed"));
181 void packet_write_fmt(int fd
, const char *fmt
, ...)
186 packet_write_fmt_1(fd
, 0, "", fmt
, args
);
190 int packet_write_fmt_gently(int fd
, const char *fmt
, ...)
196 status
= packet_write_fmt_1(fd
, 1, "", fmt
, args
);
201 static int do_packet_write(const int fd_out
, const char *buf
, size_t size
,
207 if (size
> LARGE_PACKET_DATA_MAX
) {
208 strbuf_addstr(err
, _("packet write failed - data exceeds max packet size"));
212 packet_trace(buf
, size
, 1);
213 packet_size
= size
+ 4;
215 set_packet_header(header
, packet_size
);
218 * Write the header and the buffer in 2 parts so that we do
219 * not need to allocate a buffer or rely on a static buffer.
220 * This also avoids putting a large buffer on the stack which
221 * might have multi-threading issues.
224 if (write_in_full(fd_out
, header
, 4) < 0 ||
225 write_in_full(fd_out
, buf
, size
) < 0) {
226 strbuf_addf(err
, _("packet write failed: %s"), strerror(errno
));
232 static int packet_write_gently(const int fd_out
, const char *buf
, size_t size
)
234 struct strbuf err
= STRBUF_INIT
;
235 if (do_packet_write(fd_out
, buf
, size
, &err
)) {
236 error("%s", err
.buf
);
237 strbuf_release(&err
);
243 void packet_write(int fd_out
, const char *buf
, size_t size
)
245 struct strbuf err
= STRBUF_INIT
;
246 if (do_packet_write(fd_out
, buf
, size
, &err
))
250 void packet_fwrite(FILE *f
, const char *buf
, size_t size
)
255 if (size
> LARGE_PACKET_DATA_MAX
)
256 die(_("packet write failed - data exceeds max packet size"));
258 packet_trace(buf
, size
, 1);
259 packet_size
= size
+ 4;
261 set_packet_header(header
, packet_size
);
262 fwrite_or_die(f
, header
, 4);
263 fwrite_or_die(f
, buf
, size
);
266 void packet_fwrite_fmt(FILE *fh
, const char *fmt
, ...)
268 static struct strbuf buf
= STRBUF_INIT
;
274 format_packet(&buf
, "", fmt
, args
);
277 fwrite_or_die(fh
, buf
.buf
, buf
.len
);
280 void packet_fflush(FILE *f
)
282 packet_trace("0000", 4, 1);
283 fwrite_or_die(f
, "0000", 4);
287 void packet_buf_write(struct strbuf
*buf
, const char *fmt
, ...)
292 format_packet(buf
, "", fmt
, args
);
296 int write_packetized_from_fd_no_flush(int fd_in
, int fd_out
)
298 char *buf
= xmalloc(LARGE_PACKET_DATA_MAX
);
300 ssize_t bytes_to_write
;
303 bytes_to_write
= xread(fd_in
, buf
, LARGE_PACKET_DATA_MAX
);
304 if (bytes_to_write
< 0) {
306 return COPY_READ_ERROR
;
308 if (bytes_to_write
== 0)
310 err
= packet_write_gently(fd_out
, buf
, bytes_to_write
);
316 int write_packetized_from_buf_no_flush_count(const char *src_in
, size_t len
,
317 int fd_out
, int *packet_counter
)
320 size_t bytes_written
= 0;
321 size_t bytes_to_write
;
324 if ((len
- bytes_written
) > LARGE_PACKET_DATA_MAX
)
325 bytes_to_write
= LARGE_PACKET_DATA_MAX
;
327 bytes_to_write
= len
- bytes_written
;
328 if (bytes_to_write
== 0)
330 err
= packet_write_gently(fd_out
, src_in
+ bytes_written
, bytes_to_write
);
331 bytes_written
+= bytes_to_write
;
338 static int get_packet_data(int fd
, char **src_buf
, size_t *src_size
,
339 void *dst
, unsigned size
, int options
)
343 if (fd
>= 0 && src_buf
&& *src_buf
)
344 BUG("multiple sources given to packet_read");
346 /* Read up to "size" bytes from our source, whatever it is. */
347 if (src_buf
&& *src_buf
) {
348 ret
= size
< *src_size
? size
: *src_size
;
349 memcpy(dst
, *src_buf
, ret
);
353 ret
= read_in_full(fd
, dst
, size
);
355 if (options
& PACKET_READ_GENTLE_ON_READ_ERROR
)
356 return error_errno(_("read error"));
357 die_errno(_("read error"));
361 /* And complain if we didn't get enough bytes to satisfy the read. */
363 if (options
& PACKET_READ_GENTLE_ON_EOF
)
366 if (options
& PACKET_READ_GENTLE_ON_READ_ERROR
)
367 return error(_("the remote end hung up unexpectedly"));
368 die(_("the remote end hung up unexpectedly"));
374 int packet_length(const char lenbuf_hex
[4])
376 int val
= hex2chr(lenbuf_hex
);
377 return (val
< 0) ? val
: (val
<< 8) | hex2chr(lenbuf_hex
+ 2);
380 static char *find_packfile_uri_path(const char *buffer
)
382 const char *URI_MARK
= "://";
386 /* First char is sideband mark */
389 len
= strspn(buffer
, "0123456789abcdefABCDEF");
390 /* size of SHA1 and SHA256 hash */
391 if (!(len
== 40 || len
== 64) || buffer
[len
] != ' ')
392 return NULL
; /* required "<hash>SP" not seen */
394 path
= strstr(buffer
+ len
+ 1, URI_MARK
);
398 path
= strchr(path
+ strlen(URI_MARK
), '/');
399 if (!path
|| !*(path
+ 1))
402 /* position after '/' */
406 enum packet_read_status
packet_read_with_status(int fd
, char **src_buffer
,
407 size_t *src_len
, char *buffer
,
408 unsigned size
, int *pktlen
,
413 char *uri_path_start
;
415 if (get_packet_data(fd
, src_buffer
, src_len
, linelen
, 4, options
) < 0) {
417 return PACKET_READ_EOF
;
420 len
= packet_length(linelen
);
423 if (options
& PACKET_READ_GENTLE_ON_READ_ERROR
)
424 return error(_("protocol error: bad line length "
425 "character: %.4s"), linelen
);
426 die(_("protocol error: bad line length character: %.4s"), linelen
);
428 packet_trace("0000", 4, 0);
430 return PACKET_READ_FLUSH
;
431 } else if (len
== 1) {
432 packet_trace("0001", 4, 0);
434 return PACKET_READ_DELIM
;
435 } else if (len
== 2) {
436 packet_trace("0002", 4, 0);
438 return PACKET_READ_RESPONSE_END
;
439 } else if (len
< 4) {
440 if (options
& PACKET_READ_GENTLE_ON_READ_ERROR
)
441 return error(_("protocol error: bad line length %d"),
443 die(_("protocol error: bad line length %d"), len
);
447 if ((unsigned)len
>= size
) {
448 if (options
& PACKET_READ_GENTLE_ON_READ_ERROR
)
449 return error(_("protocol error: bad line length %d"),
451 die(_("protocol error: bad line length %d"), len
);
454 if (get_packet_data(fd
, src_buffer
, src_len
, buffer
, len
, options
) < 0) {
456 return PACKET_READ_EOF
;
459 if ((options
& PACKET_READ_CHOMP_NEWLINE
) &&
460 len
&& buffer
[len
-1] == '\n')
464 if (options
& PACKET_READ_REDACT_URI_PATH
&&
465 (uri_path_start
= find_packfile_uri_path(buffer
))) {
466 const char *redacted
= "<redacted>";
467 struct strbuf tracebuf
= STRBUF_INIT
;
468 strbuf_insert(&tracebuf
, 0, buffer
, len
);
469 strbuf_splice(&tracebuf
, uri_path_start
- buffer
,
470 strlen(uri_path_start
), redacted
, strlen(redacted
));
471 packet_trace(tracebuf
.buf
, tracebuf
.len
, 0);
472 strbuf_release(&tracebuf
);
474 packet_trace(buffer
, len
, 0);
477 if ((options
& PACKET_READ_DIE_ON_ERR_PACKET
) &&
478 starts_with(buffer
, "ERR "))
479 die(_("remote error: %s"), buffer
+ 4);
482 return PACKET_READ_NORMAL
;
485 int packet_read(int fd
, char *buffer
, unsigned size
, int options
)
489 packet_read_with_status(fd
, NULL
, NULL
, buffer
, size
, &pktlen
,
495 char *packet_read_line(int fd
, int *dst_len
)
497 int len
= packet_read(fd
, packet_buffer
, sizeof(packet_buffer
),
498 PACKET_READ_CHOMP_NEWLINE
);
501 return (len
> 0) ? packet_buffer
: NULL
;
504 int packet_read_line_gently(int fd
, int *dst_len
, char **dst_line
)
506 int len
= packet_read(fd
, packet_buffer
, sizeof(packet_buffer
),
507 PACKET_READ_CHOMP_NEWLINE
|PACKET_READ_GENTLE_ON_EOF
);
511 *dst_line
= (len
> 0) ? packet_buffer
: NULL
;
515 ssize_t
read_packetized_to_strbuf(int fd_in
, struct strbuf
*sb_out
, int options
)
519 size_t orig_len
= sb_out
->len
;
520 size_t orig_alloc
= sb_out
->alloc
;
523 strbuf_grow(sb_out
, LARGE_PACKET_DATA_MAX
);
524 packet_len
= packet_read(fd_in
,
525 /* strbuf_grow() above always allocates one extra byte to
526 * store a '\0' at the end of the string. packet_read()
527 * writes a '\0' extra byte at the end, too. Let it know
528 * that there is already room for the extra byte.
530 sb_out
->buf
+ sb_out
->len
, LARGE_PACKET_DATA_MAX
+1,
534 sb_out
->len
+= packet_len
;
537 if (packet_len
< 0) {
539 strbuf_release(sb_out
);
541 strbuf_setlen(sb_out
, orig_len
);
544 return sb_out
->len
- orig_len
;
547 int recv_sideband(const char *me
, int in_stream
, int out
)
549 char buf
[LARGE_PACKET_MAX
+ 1];
551 struct strbuf scratch
= STRBUF_INIT
;
552 enum sideband_type sideband_type
;
555 int status
= packet_read_with_status(in_stream
, NULL
, NULL
,
556 buf
, LARGE_PACKET_MAX
,
558 PACKET_READ_GENTLE_ON_EOF
);
559 if (!demultiplex_sideband(me
, status
, buf
, len
, 0, &scratch
,
562 switch (sideband_type
) {
563 case SIDEBAND_PRIMARY
:
564 write_or_die(out
, buf
+ 1, len
- 1);
566 default: /* errors: message already written */
568 BUG("unhandled incomplete sideband: '%s'",
570 return sideband_type
;
575 /* Packet Reader Functions */
576 void packet_reader_init(struct packet_reader
*reader
, int fd
,
577 char *src_buffer
, size_t src_len
,
580 memset(reader
, 0, sizeof(*reader
));
583 reader
->src_buffer
= src_buffer
;
584 reader
->src_len
= src_len
;
585 reader
->buffer
= packet_buffer
;
586 reader
->buffer_size
= sizeof(packet_buffer
);
587 reader
->options
= options
;
589 reader
->hash_algo
= &hash_algos
[GIT_HASH_SHA1
];
592 enum packet_read_status
packet_reader_read(struct packet_reader
*reader
)
594 struct strbuf scratch
= STRBUF_INIT
;
596 if (reader
->line_peeked
) {
597 reader
->line_peeked
= 0;
598 return reader
->status
;
602 * Consume all progress packets until a primary payload packet is
606 enum sideband_type sideband_type
;
607 reader
->status
= packet_read_with_status(reader
->fd
,
614 if (!reader
->use_sideband
)
616 if (demultiplex_sideband(reader
->me
, reader
->status
,
617 reader
->buffer
, reader
->pktlen
, 1,
618 &scratch
, &sideband_type
))
622 if (reader
->status
== PACKET_READ_NORMAL
)
623 /* Skip the sideband designator if sideband is used */
624 reader
->line
= reader
->use_sideband
?
625 reader
->buffer
+ 1 : reader
->buffer
;
629 return reader
->status
;
632 enum packet_read_status
packet_reader_peek(struct packet_reader
*reader
)
634 /* Only allow peeking a single line */
635 if (reader
->line_peeked
)
636 return reader
->status
;
638 /* Peek a line by reading it and setting peeked flag */
639 packet_reader_read(reader
);
640 reader
->line_peeked
= 1;
641 return reader
->status
;
644 void packet_writer_init(struct packet_writer
*writer
, int dest_fd
)
646 writer
->dest_fd
= dest_fd
;
647 writer
->use_sideband
= 0;
650 void packet_writer_write(struct packet_writer
*writer
, const char *fmt
, ...)
655 packet_write_fmt_1(writer
->dest_fd
, 0,
656 writer
->use_sideband
? "\001" : "", fmt
, args
);
660 void packet_writer_error(struct packet_writer
*writer
, const char *fmt
, ...)
665 packet_write_fmt_1(writer
->dest_fd
, 0,
666 writer
->use_sideband
? "\003" : "ERR ", fmt
, args
);
670 void packet_writer_delim(struct packet_writer
*writer
)
672 packet_delim(writer
->dest_fd
);
675 void packet_writer_flush(struct packet_writer
*writer
)
677 packet_flush(writer
->dest_fd
);