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