]>
Commit | Line | Data |
---|---|---|
f3a3214e LT |
1 | #include "cache.h" |
2 | #include "pkt-line.h" | |
fd89433d | 3 | #include "run-command.h" |
f3a3214e | 4 | |
74543a04 | 5 | char packet_buffer[LARGE_PACKET_MAX]; |
1e4cd68c | 6 | static const char *packet_trace_prefix = "git"; |
6aa30857 | 7 | static struct trace_key trace_packet = TRACE_KEY_INIT(PACKET); |
32359838 | 8 | static struct trace_key trace_pack = TRACE_KEY_INIT(PACKFILE); |
bbc30f99 JK |
9 | |
10 | void packet_trace_identity(const char *prog) | |
11 | { | |
12 | packet_trace_prefix = xstrdup(prog); | |
13 | } | |
14 | ||
fd89433d JK |
15 | static const char *get_trace_prefix(void) |
16 | { | |
17 | return in_async() ? "sideband" : packet_trace_prefix; | |
18 | } | |
19 | ||
32359838 JK |
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 | ||
bbc30f99 JK |
34 | static void packet_trace(const char *buf, unsigned int len, int write) |
35 | { | |
36 | int i; | |
37 | struct strbuf out; | |
32359838 JK |
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 | } | |
bbc30f99 | 58 | |
6aa30857 | 59 | if (!trace_want(&trace_packet)) |
bbc30f99 JK |
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 ", | |
fd89433d | 66 | get_trace_prefix(), write ? '>' : '<'); |
bbc30f99 | 67 | |
32359838 JK |
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]); | |
bbc30f99 JK |
77 | } |
78 | ||
79 | strbuf_addch(&out, '\n'); | |
6aa30857 | 80 | trace_strbuf(&trace_packet, &out); |
bbc30f99 JK |
81 | strbuf_release(&out); |
82 | } | |
83 | ||
f3a3214e LT |
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 | { | |
bbc30f99 | 90 | packet_trace("0000", 4, 1); |
cdf4fb8e | 91 | write_or_die(fd, "0000", 4); |
f3a3214e LT |
92 | } |
93 | ||
a4cfd41c BW |
94 | void packet_delim(int fd) |
95 | { | |
96 | packet_trace("0001", 4, 1); | |
97 | write_or_die(fd, "0001", 4); | |
98 | } | |
99 | ||
038ce90f LS |
100 | int packet_flush_gently(int fd) |
101 | { | |
102 | packet_trace("0000", 4, 1); | |
4c95e3dd JK |
103 | if (write_in_full(fd, "0000", 4) < 0) |
104 | return error("flush packet write failed"); | |
105 | return 0; | |
038ce90f LS |
106 | } |
107 | ||
f5615d24 SP |
108 | void packet_buf_flush(struct strbuf *buf) |
109 | { | |
bbc30f99 | 110 | packet_trace("0000", 4, 1); |
f5615d24 SP |
111 | strbuf_add(buf, "0000", 4); |
112 | } | |
113 | ||
a4cfd41c BW |
114 | void packet_buf_delim(struct strbuf *buf) |
115 | { | |
116 | packet_trace("0001", 4, 1); | |
117 | strbuf_add(buf, "0001", 4); | |
118 | } | |
119 | ||
2f60bdd1 | 120 | static void set_packet_header(char *buf, const int size) |
f3a3214e | 121 | { |
f3a3214e | 122 | static char hexchar[] = "0123456789abcdef"; |
2f60bdd1 LS |
123 | |
124 | #define hex(a) (hexchar[(a) & 15]) | |
125 | buf[0] = hex(size >> 12); | |
126 | buf[1] = hex(size >> 8); | |
127 | buf[2] = hex(size >> 4); | |
128 | buf[3] = hex(size); | |
129 | #undef hex | |
130 | } | |
131 | ||
132 | static void format_packet(struct strbuf *out, const char *fmt, va_list args) | |
133 | { | |
8e9faf27 | 134 | size_t orig_len, n; |
f3a3214e | 135 | |
8e9faf27 JK |
136 | orig_len = out->len; |
137 | strbuf_addstr(out, "0000"); | |
138 | strbuf_vaddf(out, fmt, args); | |
139 | n = out->len - orig_len; | |
140 | ||
141 | if (n > LARGE_PACKET_MAX) | |
f3a3214e | 142 | die("protocol error: impossibly long line"); |
8e9faf27 | 143 | |
2f60bdd1 | 144 | set_packet_header(&out->buf[orig_len], n); |
8e9faf27 | 145 | packet_trace(out->buf + orig_len + 4, n - 4, 1); |
f5615d24 SP |
146 | } |
147 | ||
70428d1a LS |
148 | static int packet_write_fmt_1(int fd, int gently, |
149 | const char *fmt, va_list args) | |
150 | { | |
150efef1 | 151 | static struct strbuf buf = STRBUF_INIT; |
70428d1a | 152 | |
150efef1 | 153 | strbuf_reset(&buf); |
70428d1a | 154 | format_packet(&buf, fmt, args); |
4c95e3dd JK |
155 | if (write_in_full(fd, buf.buf, buf.len) < 0) { |
156 | if (!gently) { | |
157 | check_pipe(errno); | |
158 | die_errno("packet write with format failed"); | |
159 | } | |
160 | return error("packet write with format failed"); | |
70428d1a | 161 | } |
4c95e3dd JK |
162 | |
163 | return 0; | |
70428d1a LS |
164 | } |
165 | ||
81c634e9 | 166 | void packet_write_fmt(int fd, const char *fmt, ...) |
f5615d24 SP |
167 | { |
168 | va_list args; | |
f5615d24 SP |
169 | |
170 | va_start(args, fmt); | |
70428d1a LS |
171 | packet_write_fmt_1(fd, 0, fmt, args); |
172 | va_end(args); | |
173 | } | |
174 | ||
175 | int packet_write_fmt_gently(int fd, const char *fmt, ...) | |
176 | { | |
177 | int status; | |
178 | va_list args; | |
179 | ||
180 | va_start(args, fmt); | |
181 | status = packet_write_fmt_1(fd, 1, fmt, args); | |
f5615d24 | 182 | va_end(args); |
70428d1a | 183 | return status; |
f3a3214e LT |
184 | } |
185 | ||
edfb780c LS |
186 | static int packet_write_gently(const int fd_out, const char *buf, size_t size) |
187 | { | |
188 | static char packet_write_buffer[LARGE_PACKET_MAX]; | |
189 | size_t packet_size; | |
190 | ||
191 | if (size > sizeof(packet_write_buffer) - 4) | |
192 | return error("packet write failed - data exceeds max packet size"); | |
193 | ||
194 | packet_trace(buf, size, 1); | |
195 | packet_size = size + 4; | |
196 | set_packet_header(packet_write_buffer, packet_size); | |
197 | memcpy(packet_write_buffer + 4, buf, size); | |
4c95e3dd JK |
198 | if (write_in_full(fd_out, packet_write_buffer, packet_size) < 0) |
199 | return error("packet write failed"); | |
200 | return 0; | |
edfb780c LS |
201 | } |
202 | ||
5d2124b3 BW |
203 | void packet_write(int fd_out, const char *buf, size_t size) |
204 | { | |
205 | if (packet_write_gently(fd_out, buf, size)) | |
206 | die_errno("packet write failed"); | |
207 | } | |
208 | ||
f5615d24 SP |
209 | void packet_buf_write(struct strbuf *buf, const char *fmt, ...) |
210 | { | |
211 | va_list args; | |
f5615d24 SP |
212 | |
213 | va_start(args, fmt); | |
8e9faf27 | 214 | format_packet(buf, fmt, args); |
f5615d24 | 215 | va_end(args); |
f5615d24 SP |
216 | } |
217 | ||
bb643d8b LS |
218 | int write_packetized_from_fd(int fd_in, int fd_out) |
219 | { | |
220 | static char buf[LARGE_PACKET_DATA_MAX]; | |
221 | int err = 0; | |
222 | ssize_t bytes_to_write; | |
223 | ||
224 | while (!err) { | |
225 | bytes_to_write = xread(fd_in, buf, sizeof(buf)); | |
226 | if (bytes_to_write < 0) | |
227 | return COPY_READ_ERROR; | |
228 | if (bytes_to_write == 0) | |
229 | break; | |
230 | err = packet_write_gently(fd_out, buf, bytes_to_write); | |
231 | } | |
232 | if (!err) | |
233 | err = packet_flush_gently(fd_out); | |
234 | return err; | |
235 | } | |
236 | ||
237 | int write_packetized_from_buf(const char *src_in, size_t len, int fd_out) | |
238 | { | |
239 | int err = 0; | |
240 | size_t bytes_written = 0; | |
241 | size_t bytes_to_write; | |
242 | ||
243 | while (!err) { | |
244 | if ((len - bytes_written) > LARGE_PACKET_DATA_MAX) | |
245 | bytes_to_write = LARGE_PACKET_DATA_MAX; | |
246 | else | |
247 | bytes_to_write = len - bytes_written; | |
248 | if (bytes_to_write == 0) | |
249 | break; | |
250 | err = packet_write_gently(fd_out, src_in + bytes_written, bytes_to_write); | |
251 | bytes_written += bytes_to_write; | |
252 | } | |
253 | if (!err) | |
254 | err = packet_flush_gently(fd_out); | |
255 | return err; | |
256 | } | |
257 | ||
4981fe75 JK |
258 | static int get_packet_data(int fd, char **src_buf, size_t *src_size, |
259 | void *dst, unsigned size, int options) | |
f3a3214e | 260 | { |
4981fe75 JK |
261 | ssize_t ret; |
262 | ||
263 | if (fd >= 0 && src_buf && *src_buf) | |
264 | die("BUG: multiple sources given to packet_read"); | |
265 | ||
266 | /* Read up to "size" bytes from our source, whatever it is. */ | |
267 | if (src_buf && *src_buf) { | |
268 | ret = size < *src_size ? size : *src_size; | |
269 | memcpy(dst, *src_buf, ret); | |
270 | *src_buf += ret; | |
271 | *src_size -= ret; | |
272 | } else { | |
273 | ret = read_in_full(fd, dst, size); | |
274 | if (ret < 0) | |
275 | die_errno("read error"); | |
276 | } | |
277 | ||
278 | /* And complain if we didn't get enough bytes to satisfy the read. */ | |
61d36330 | 279 | if (ret != size) { |
03809429 | 280 | if (options & PACKET_READ_GENTLE_ON_EOF) |
46284dd1 HV |
281 | return -1; |
282 | ||
c697ad14 | 283 | die("The remote end hung up unexpectedly"); |
46284dd1 HV |
284 | } |
285 | ||
286 | return ret; | |
f3a3214e LT |
287 | } |
288 | ||
f5615d24 | 289 | static int packet_length(const char *linelen) |
f3a3214e | 290 | { |
d2330973 RS |
291 | int val = hex2chr(linelen); |
292 | return (val < 0) ? val : (val << 8) | hex2chr(linelen + 2); | |
f5615d24 SP |
293 | } |
294 | ||
2153d478 BW |
295 | enum packet_read_status packet_read_with_status(int fd, char **src_buffer, |
296 | size_t *src_len, char *buffer, | |
297 | unsigned size, int *pktlen, | |
298 | int options) | |
f5615d24 | 299 | { |
2153d478 | 300 | int len; |
f5615d24 SP |
301 | char linelen[4]; |
302 | ||
2153d478 BW |
303 | if (get_packet_data(fd, src_buffer, src_len, linelen, 4, options) < 0) { |
304 | *pktlen = -1; | |
305 | return PACKET_READ_EOF; | |
306 | } | |
307 | ||
f5615d24 | 308 | len = packet_length(linelen); |
2153d478 BW |
309 | |
310 | if (len < 0) { | |
743c4b7b | 311 | die("protocol error: bad line length character: %.4s", linelen); |
2153d478 | 312 | } else if (!len) { |
bbc30f99 | 313 | packet_trace("0000", 4, 0); |
2153d478 BW |
314 | *pktlen = 0; |
315 | return PACKET_READ_FLUSH; | |
a4cfd41c BW |
316 | } else if (len == 1) { |
317 | packet_trace("0001", 4, 0); | |
318 | *pktlen = 0; | |
319 | return PACKET_READ_DELIM; | |
2153d478 BW |
320 | } else if (len < 4) { |
321 | die("protocol error: bad line length %d", len); | |
bbc30f99 | 322 | } |
2153d478 | 323 | |
f3a3214e | 324 | len -= 4; |
2153d478 | 325 | if ((unsigned)len >= size) |
f3a3214e | 326 | die("protocol error: bad line length %d", len); |
2153d478 BW |
327 | |
328 | if (get_packet_data(fd, src_buffer, src_len, buffer, len, options) < 0) { | |
329 | *pktlen = -1; | |
330 | return PACKET_READ_EOF; | |
331 | } | |
819b929d JK |
332 | |
333 | if ((options & PACKET_READ_CHOMP_NEWLINE) && | |
334 | len && buffer[len-1] == '\n') | |
335 | len--; | |
336 | ||
f3a3214e | 337 | buffer[len] = 0; |
bbc30f99 | 338 | packet_trace(buffer, len, 0); |
2153d478 BW |
339 | *pktlen = len; |
340 | return PACKET_READ_NORMAL; | |
341 | } | |
342 | ||
343 | int packet_read(int fd, char **src_buffer, size_t *src_len, | |
344 | char *buffer, unsigned size, int options) | |
345 | { | |
346 | int pktlen = -1; | |
347 | ||
348 | packet_read_with_status(fd, src_buffer, src_len, buffer, size, | |
349 | &pktlen, options); | |
350 | ||
351 | return pktlen; | |
f3a3214e | 352 | } |
f5615d24 | 353 | |
4981fe75 JK |
354 | static char *packet_read_line_generic(int fd, |
355 | char **src, size_t *src_len, | |
356 | int *dst_len) | |
46284dd1 | 357 | { |
4981fe75 JK |
358 | int len = packet_read(fd, src, src_len, |
359 | packet_buffer, sizeof(packet_buffer), | |
74543a04 | 360 | PACKET_READ_CHOMP_NEWLINE); |
4981fe75 JK |
361 | if (dst_len) |
362 | *dst_len = len; | |
974b50c5 | 363 | return (len > 0) ? packet_buffer : NULL; |
46284dd1 HV |
364 | } |
365 | ||
4981fe75 | 366 | char *packet_read_line(int fd, int *len_p) |
f5615d24 | 367 | { |
4981fe75 JK |
368 | return packet_read_line_generic(fd, NULL, NULL, len_p); |
369 | } | |
f5615d24 | 370 | |
825b9226 BP |
371 | int packet_read_line_gently(int fd, int *dst_len, char **dst_line) |
372 | { | |
373 | int len = packet_read(fd, NULL, NULL, | |
374 | packet_buffer, sizeof(packet_buffer), | |
375 | PACKET_READ_CHOMP_NEWLINE|PACKET_READ_GENTLE_ON_EOF); | |
376 | if (dst_len) | |
377 | *dst_len = len; | |
378 | if (dst_line) | |
379 | *dst_line = (len > 0) ? packet_buffer : NULL; | |
380 | return len; | |
381 | } | |
382 | ||
4981fe75 JK |
383 | char *packet_read_line_buf(char **src, size_t *src_len, int *dst_len) |
384 | { | |
385 | return packet_read_line_generic(-1, src, src_len, dst_len); | |
f5615d24 | 386 | } |
bb643d8b LS |
387 | |
388 | ssize_t read_packetized_to_strbuf(int fd_in, struct strbuf *sb_out) | |
389 | { | |
390 | int packet_len; | |
391 | ||
392 | size_t orig_len = sb_out->len; | |
393 | size_t orig_alloc = sb_out->alloc; | |
394 | ||
395 | for (;;) { | |
396 | strbuf_grow(sb_out, LARGE_PACKET_DATA_MAX); | |
397 | packet_len = packet_read(fd_in, NULL, NULL, | |
398 | /* strbuf_grow() above always allocates one extra byte to | |
399 | * store a '\0' at the end of the string. packet_read() | |
400 | * writes a '\0' extra byte at the end, too. Let it know | |
401 | * that there is already room for the extra byte. | |
402 | */ | |
403 | sb_out->buf + sb_out->len, LARGE_PACKET_DATA_MAX+1, | |
404 | PACKET_READ_GENTLE_ON_EOF); | |
405 | if (packet_len <= 0) | |
406 | break; | |
407 | sb_out->len += packet_len; | |
408 | } | |
409 | ||
410 | if (packet_len < 0) { | |
411 | if (orig_alloc == 0) | |
412 | strbuf_release(sb_out); | |
413 | else | |
414 | strbuf_setlen(sb_out, orig_len); | |
415 | return packet_len; | |
416 | } | |
417 | return sb_out->len - orig_len; | |
418 | } | |
77dabc14 BW |
419 | |
420 | /* Packet Reader Functions */ | |
421 | void packet_reader_init(struct packet_reader *reader, int fd, | |
422 | char *src_buffer, size_t src_len, | |
423 | int options) | |
424 | { | |
425 | memset(reader, 0, sizeof(*reader)); | |
426 | ||
427 | reader->fd = fd; | |
428 | reader->src_buffer = src_buffer; | |
429 | reader->src_len = src_len; | |
430 | reader->buffer = packet_buffer; | |
431 | reader->buffer_size = sizeof(packet_buffer); | |
432 | reader->options = options; | |
433 | } | |
434 | ||
435 | enum packet_read_status packet_reader_read(struct packet_reader *reader) | |
436 | { | |
437 | if (reader->line_peeked) { | |
438 | reader->line_peeked = 0; | |
439 | return reader->status; | |
440 | } | |
441 | ||
442 | reader->status = packet_read_with_status(reader->fd, | |
443 | &reader->src_buffer, | |
444 | &reader->src_len, | |
445 | reader->buffer, | |
446 | reader->buffer_size, | |
447 | &reader->pktlen, | |
448 | reader->options); | |
449 | ||
450 | if (reader->status == PACKET_READ_NORMAL) | |
451 | reader->line = reader->buffer; | |
452 | else | |
453 | reader->line = NULL; | |
454 | ||
455 | return reader->status; | |
456 | } | |
457 | ||
458 | enum packet_read_status packet_reader_peek(struct packet_reader *reader) | |
459 | { | |
460 | /* Only allow peeking a single line */ | |
461 | if (reader->line_peeked) | |
462 | return reader->status; | |
463 | ||
464 | /* Peek a line by reading it and setting peeked flag */ | |
465 | packet_reader_read(reader); | |
466 | reader->line_peeked = 1; | |
467 | return reader->status; | |
468 | } |