]>
Commit | Line | Data |
---|---|---|
5e3f94df | 1 | #include "git-compat-util.h" |
d5fff46f | 2 | #include "copy.h" |
f3a3214e | 3 | #include "pkt-line.h" |
f394e093 | 4 | #include "gettext.h" |
41771fa4 | 5 | #include "hex.h" |
fd89433d | 6 | #include "run-command.h" |
545f7b50 | 7 | #include "sideband.h" |
74ea5c95 | 8 | #include "trace.h" |
d48be35c | 9 | #include "write-or-die.h" |
f3a3214e | 10 | |
74543a04 | 11 | char packet_buffer[LARGE_PACKET_MAX]; |
1e4cd68c | 12 | static const char *packet_trace_prefix = "git"; |
6aa30857 | 13 | static struct trace_key trace_packet = TRACE_KEY_INIT(PACKET); |
32359838 | 14 | static struct trace_key trace_pack = TRACE_KEY_INIT(PACKFILE); |
bbc30f99 JK |
15 | |
16 | void packet_trace_identity(const char *prog) | |
17 | { | |
18 | packet_trace_prefix = xstrdup(prog); | |
19 | } | |
20 | ||
fd89433d JK |
21 | static const char *get_trace_prefix(void) |
22 | { | |
23 | return in_async() ? "sideband" : packet_trace_prefix; | |
24 | } | |
25 | ||
32359838 JK |
26 | static 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 | ||
bbc30f99 JK |
40 | static void packet_trace(const char *buf, unsigned int len, int write) |
41 | { | |
42 | int i; | |
43 | struct strbuf out; | |
32359838 JK |
44 | static int in_pack, sideband; |
45 | ||
46 | if (!trace_want(&trace_packet) && !trace_want(&trace_pack)) | |
47 | return; | |
48 | ||
49 | if (in_pack) { | |
50 | if (packet_trace_pack(buf, len, sideband)) | |
51 | return; | |
52 | } else if (starts_with(buf, "PACK") || starts_with(buf, "\1PACK")) { | |
53 | in_pack = 1; | |
54 | sideband = *buf == '\1'; | |
55 | packet_trace_pack(buf, len, sideband); | |
56 | ||
57 | /* | |
58 | * Make a note in the human-readable trace that the pack data | |
59 | * started. | |
60 | */ | |
61 | buf = "PACK ..."; | |
62 | len = strlen(buf); | |
63 | } | |
bbc30f99 | 64 | |
6aa30857 | 65 | if (!trace_want(&trace_packet)) |
bbc30f99 JK |
66 | return; |
67 | ||
68 | /* +32 is just a guess for header + quoting */ | |
69 | strbuf_init(&out, len+32); | |
70 | ||
71 | strbuf_addf(&out, "packet: %12s%c ", | |
fd89433d | 72 | get_trace_prefix(), write ? '>' : '<'); |
bbc30f99 | 73 | |
32359838 JK |
74 | /* XXX we should really handle printable utf8 */ |
75 | for (i = 0; i < len; i++) { | |
76 | /* suppress newlines */ | |
77 | if (buf[i] == '\n') | |
78 | continue; | |
79 | if (buf[i] >= 0x20 && buf[i] <= 0x7e) | |
80 | strbuf_addch(&out, buf[i]); | |
81 | else | |
82 | strbuf_addf(&out, "\\%o", buf[i]); | |
bbc30f99 JK |
83 | } |
84 | ||
85 | strbuf_addch(&out, '\n'); | |
6aa30857 | 86 | trace_strbuf(&trace_packet, &out); |
bbc30f99 JK |
87 | strbuf_release(&out); |
88 | } | |
89 | ||
f3a3214e LT |
90 | /* |
91 | * If we buffered things up above (we don't, but we should), | |
92 | * we'd flush it here | |
93 | */ | |
94 | void packet_flush(int fd) | |
95 | { | |
bbc30f99 | 96 | packet_trace("0000", 4, 1); |
37c80012 JK |
97 | if (write_in_full(fd, "0000", 4) < 0) |
98 | die_errno(_("unable to write flush packet")); | |
f3a3214e LT |
99 | } |
100 | ||
a4cfd41c BW |
101 | void packet_delim(int fd) |
102 | { | |
103 | packet_trace("0001", 4, 1); | |
37c80012 JK |
104 | if (write_in_full(fd, "0001", 4) < 0) |
105 | die_errno(_("unable to write delim packet")); | |
a4cfd41c BW |
106 | } |
107 | ||
0181b600 DL |
108 | void packet_response_end(int fd) |
109 | { | |
110 | packet_trace("0002", 4, 1); | |
111 | if (write_in_full(fd, "0002", 4) < 0) | |
8232a0ff | 112 | die_errno(_("unable to write response end packet")); |
0181b600 DL |
113 | } |
114 | ||
038ce90f LS |
115 | int packet_flush_gently(int fd) |
116 | { | |
117 | packet_trace("0000", 4, 1); | |
4c95e3dd | 118 | if (write_in_full(fd, "0000", 4) < 0) |
c60d7697 | 119 | return error(_("flush packet write failed")); |
4c95e3dd | 120 | return 0; |
038ce90f LS |
121 | } |
122 | ||
f5615d24 SP |
123 | void packet_buf_flush(struct strbuf *buf) |
124 | { | |
bbc30f99 | 125 | packet_trace("0000", 4, 1); |
f5615d24 SP |
126 | strbuf_add(buf, "0000", 4); |
127 | } | |
128 | ||
a4cfd41c BW |
129 | void packet_buf_delim(struct strbuf *buf) |
130 | { | |
131 | packet_trace("0001", 4, 1); | |
132 | strbuf_add(buf, "0001", 4); | |
133 | } | |
134 | ||
56bea280 | 135 | void set_packet_header(char *buf, int size) |
f3a3214e | 136 | { |
f3a3214e | 137 | static char hexchar[] = "0123456789abcdef"; |
2f60bdd1 LS |
138 | |
139 | #define hex(a) (hexchar[(a) & 15]) | |
140 | buf[0] = hex(size >> 12); | |
141 | buf[1] = hex(size >> 8); | |
142 | buf[2] = hex(size >> 4); | |
143 | buf[3] = hex(size); | |
144 | #undef hex | |
145 | } | |
146 | ||
bc2e795c JT |
147 | static void format_packet(struct strbuf *out, const char *prefix, |
148 | const char *fmt, va_list args) | |
2f60bdd1 | 149 | { |
8e9faf27 | 150 | size_t orig_len, n; |
f3a3214e | 151 | |
8e9faf27 JK |
152 | orig_len = out->len; |
153 | strbuf_addstr(out, "0000"); | |
bc2e795c | 154 | strbuf_addstr(out, prefix); |
8e9faf27 JK |
155 | strbuf_vaddf(out, fmt, args); |
156 | n = out->len - orig_len; | |
157 | ||
158 | if (n > LARGE_PACKET_MAX) | |
c60d7697 | 159 | die(_("protocol error: impossibly long line")); |
8e9faf27 | 160 | |
2f60bdd1 | 161 | set_packet_header(&out->buf[orig_len], n); |
8e9faf27 | 162 | packet_trace(out->buf + orig_len + 4, n - 4, 1); |
f5615d24 SP |
163 | } |
164 | ||
bc2e795c | 165 | static int packet_write_fmt_1(int fd, int gently, const char *prefix, |
70428d1a LS |
166 | const char *fmt, va_list args) |
167 | { | |
150efef1 | 168 | static struct strbuf buf = STRBUF_INIT; |
70428d1a | 169 | |
150efef1 | 170 | strbuf_reset(&buf); |
bc2e795c | 171 | format_packet(&buf, prefix, fmt, args); |
4c95e3dd JK |
172 | if (write_in_full(fd, buf.buf, buf.len) < 0) { |
173 | if (!gently) { | |
174 | check_pipe(errno); | |
c60d7697 | 175 | die_errno(_("packet write with format failed")); |
4c95e3dd | 176 | } |
c60d7697 | 177 | return error(_("packet write with format failed")); |
70428d1a | 178 | } |
4c95e3dd JK |
179 | |
180 | return 0; | |
70428d1a LS |
181 | } |
182 | ||
81c634e9 | 183 | void packet_write_fmt(int fd, const char *fmt, ...) |
f5615d24 SP |
184 | { |
185 | va_list args; | |
f5615d24 SP |
186 | |
187 | va_start(args, fmt); | |
bc2e795c | 188 | packet_write_fmt_1(fd, 0, "", fmt, args); |
70428d1a LS |
189 | va_end(args); |
190 | } | |
191 | ||
192 | int packet_write_fmt_gently(int fd, const char *fmt, ...) | |
193 | { | |
194 | int status; | |
195 | va_list args; | |
196 | ||
197 | va_start(args, fmt); | |
bc2e795c | 198 | status = packet_write_fmt_1(fd, 1, "", fmt, args); |
f5615d24 | 199 | va_end(args); |
70428d1a | 200 | return status; |
f3a3214e LT |
201 | } |
202 | ||
332ec963 MT |
203 | static int do_packet_write(const int fd_out, const char *buf, size_t size, |
204 | struct strbuf *err) | |
edfb780c | 205 | { |
7455e05e | 206 | char header[4]; |
edfb780c LS |
207 | size_t packet_size; |
208 | ||
332ec963 MT |
209 | if (size > LARGE_PACKET_DATA_MAX) { |
210 | strbuf_addstr(err, _("packet write failed - data exceeds max packet size")); | |
211 | return -1; | |
212 | } | |
edfb780c LS |
213 | |
214 | packet_trace(buf, size, 1); | |
215 | packet_size = size + 4; | |
7455e05e JH |
216 | |
217 | set_packet_header(header, packet_size); | |
218 | ||
219 | /* | |
220 | * Write the header and the buffer in 2 parts so that we do | |
221 | * not need to allocate a buffer or rely on a static buffer. | |
222 | * This also avoids putting a large buffer on the stack which | |
223 | * might have multi-threading issues. | |
224 | */ | |
225 | ||
226 | if (write_in_full(fd_out, header, 4) < 0 || | |
332ec963 MT |
227 | write_in_full(fd_out, buf, size) < 0) { |
228 | strbuf_addf(err, _("packet write failed: %s"), strerror(errno)); | |
229 | return -1; | |
230 | } | |
231 | return 0; | |
232 | } | |
233 | ||
234 | static int packet_write_gently(const int fd_out, const char *buf, size_t size) | |
235 | { | |
236 | struct strbuf err = STRBUF_INIT; | |
237 | if (do_packet_write(fd_out, buf, size, &err)) { | |
238 | error("%s", err.buf); | |
239 | strbuf_release(&err); | |
240 | return -1; | |
241 | } | |
4c95e3dd | 242 | return 0; |
edfb780c LS |
243 | } |
244 | ||
5d2124b3 BW |
245 | void packet_write(int fd_out, const char *buf, size_t size) |
246 | { | |
332ec963 MT |
247 | struct strbuf err = STRBUF_INIT; |
248 | if (do_packet_write(fd_out, buf, size, &err)) | |
249 | die("%s", err.buf); | |
5d2124b3 BW |
250 | } |
251 | ||
96328398 JV |
252 | void packet_fwrite(FILE *f, const char *buf, size_t size) |
253 | { | |
254 | size_t packet_size; | |
255 | char header[4]; | |
256 | ||
257 | if (size > LARGE_PACKET_DATA_MAX) | |
258 | die(_("packet write failed - data exceeds max packet size")); | |
259 | ||
260 | packet_trace(buf, size, 1); | |
261 | packet_size = size + 4; | |
262 | ||
263 | set_packet_header(header, packet_size); | |
264 | fwrite_or_die(f, header, 4); | |
265 | fwrite_or_die(f, buf, size); | |
266 | } | |
267 | ||
268 | void packet_fwrite_fmt(FILE *fh, const char *fmt, ...) | |
269 | { | |
270 | static struct strbuf buf = STRBUF_INIT; | |
271 | va_list args; | |
272 | ||
273 | strbuf_reset(&buf); | |
274 | ||
275 | va_start(args, fmt); | |
276 | format_packet(&buf, "", fmt, args); | |
277 | va_end(args); | |
278 | ||
279 | fwrite_or_die(fh, buf.buf, buf.len); | |
280 | } | |
281 | ||
282 | void packet_fflush(FILE *f) | |
283 | { | |
284 | packet_trace("0000", 4, 1); | |
285 | fwrite_or_die(f, "0000", 4); | |
286 | fflush_or_die(f); | |
287 | } | |
288 | ||
f5615d24 SP |
289 | void packet_buf_write(struct strbuf *buf, const char *fmt, ...) |
290 | { | |
291 | va_list args; | |
f5615d24 SP |
292 | |
293 | va_start(args, fmt); | |
bc2e795c | 294 | format_packet(buf, "", fmt, args); |
f5615d24 | 295 | va_end(args); |
f5615d24 SP |
296 | } |
297 | ||
3a63c6a4 | 298 | int write_packetized_from_fd_no_flush(int fd_in, int fd_out) |
bb643d8b | 299 | { |
7455e05e | 300 | char *buf = xmalloc(LARGE_PACKET_DATA_MAX); |
bb643d8b LS |
301 | int err = 0; |
302 | ssize_t bytes_to_write; | |
303 | ||
304 | while (!err) { | |
7455e05e JH |
305 | bytes_to_write = xread(fd_in, buf, LARGE_PACKET_DATA_MAX); |
306 | if (bytes_to_write < 0) { | |
307 | free(buf); | |
bb643d8b | 308 | return COPY_READ_ERROR; |
7455e05e | 309 | } |
bb643d8b LS |
310 | if (bytes_to_write == 0) |
311 | break; | |
312 | err = packet_write_gently(fd_out, buf, bytes_to_write); | |
313 | } | |
7455e05e | 314 | free(buf); |
bb643d8b LS |
315 | return err; |
316 | } | |
317 | ||
52917a99 MT |
318 | int write_packetized_from_buf_no_flush_count(const char *src_in, size_t len, |
319 | int fd_out, int *packet_counter) | |
bb643d8b LS |
320 | { |
321 | int err = 0; | |
322 | size_t bytes_written = 0; | |
323 | size_t bytes_to_write; | |
324 | ||
325 | while (!err) { | |
326 | if ((len - bytes_written) > LARGE_PACKET_DATA_MAX) | |
327 | bytes_to_write = LARGE_PACKET_DATA_MAX; | |
328 | else | |
329 | bytes_to_write = len - bytes_written; | |
330 | if (bytes_to_write == 0) | |
331 | break; | |
332 | err = packet_write_gently(fd_out, src_in + bytes_written, bytes_to_write); | |
333 | bytes_written += bytes_to_write; | |
52917a99 MT |
334 | if (packet_counter) |
335 | (*packet_counter)++; | |
bb643d8b | 336 | } |
bb643d8b LS |
337 | return err; |
338 | } | |
339 | ||
4981fe75 JK |
340 | static int get_packet_data(int fd, char **src_buf, size_t *src_size, |
341 | void *dst, unsigned size, int options) | |
f3a3214e | 342 | { |
4981fe75 JK |
343 | ssize_t ret; |
344 | ||
345 | if (fd >= 0 && src_buf && *src_buf) | |
033abf97 | 346 | BUG("multiple sources given to packet_read"); |
4981fe75 JK |
347 | |
348 | /* Read up to "size" bytes from our source, whatever it is. */ | |
349 | if (src_buf && *src_buf) { | |
350 | ret = size < *src_size ? size : *src_size; | |
351 | memcpy(dst, *src_buf, ret); | |
352 | *src_buf += ret; | |
353 | *src_size -= ret; | |
354 | } else { | |
355 | ret = read_in_full(fd, dst, size); | |
c4ba5793 JS |
356 | if (ret < 0) { |
357 | if (options & PACKET_READ_GENTLE_ON_READ_ERROR) | |
358 | return error_errno(_("read error")); | |
c60d7697 | 359 | die_errno(_("read error")); |
c4ba5793 | 360 | } |
4981fe75 JK |
361 | } |
362 | ||
363 | /* And complain if we didn't get enough bytes to satisfy the read. */ | |
61d36330 | 364 | if (ret != size) { |
03809429 | 365 | if (options & PACKET_READ_GENTLE_ON_EOF) |
46284dd1 HV |
366 | return -1; |
367 | ||
c4ba5793 JS |
368 | if (options & PACKET_READ_GENTLE_ON_READ_ERROR) |
369 | return error(_("the remote end hung up unexpectedly")); | |
c60d7697 | 370 | die(_("the remote end hung up unexpectedly")); |
46284dd1 HV |
371 | } |
372 | ||
373 | return ret; | |
f3a3214e LT |
374 | } |
375 | ||
3e81b896 | 376 | int packet_length(const char lenbuf_hex[4], size_t size) |
f3a3214e | 377 | { |
3e81b896 RS |
378 | if (size < 4) |
379 | BUG("buffer too small"); | |
380 | return hexval(lenbuf_hex[0]) << 12 | | |
381 | hexval(lenbuf_hex[1]) << 8 | | |
382 | hexval(lenbuf_hex[2]) << 4 | | |
383 | hexval(lenbuf_hex[3]); | |
f5615d24 SP |
384 | } |
385 | ||
88e9b1e3 IF |
386 | static char *find_packfile_uri_path(const char *buffer) |
387 | { | |
388 | const char *URI_MARK = "://"; | |
389 | char *path; | |
390 | int len; | |
391 | ||
392 | /* First char is sideband mark */ | |
393 | buffer += 1; | |
394 | ||
395 | len = strspn(buffer, "0123456789abcdefABCDEF"); | |
396 | /* size of SHA1 and SHA256 hash */ | |
397 | if (!(len == 40 || len == 64) || buffer[len] != ' ') | |
398 | return NULL; /* required "<hash>SP" not seen */ | |
399 | ||
400 | path = strstr(buffer + len + 1, URI_MARK); | |
401 | if (!path) | |
402 | return NULL; | |
403 | ||
404 | path = strchr(path + strlen(URI_MARK), '/'); | |
405 | if (!path || !*(path + 1)) | |
406 | return NULL; | |
407 | ||
408 | /* position after '/' */ | |
409 | return ++path; | |
410 | } | |
411 | ||
2153d478 BW |
412 | enum packet_read_status packet_read_with_status(int fd, char **src_buffer, |
413 | size_t *src_len, char *buffer, | |
414 | unsigned size, int *pktlen, | |
415 | int options) | |
f5615d24 | 416 | { |
2153d478 | 417 | int len; |
f5615d24 | 418 | char linelen[4]; |
88e9b1e3 | 419 | char *uri_path_start; |
f5615d24 | 420 | |
2153d478 BW |
421 | if (get_packet_data(fd, src_buffer, src_len, linelen, 4, options) < 0) { |
422 | *pktlen = -1; | |
423 | return PACKET_READ_EOF; | |
424 | } | |
425 | ||
3e81b896 | 426 | len = packet_length(linelen, sizeof(linelen)); |
2153d478 BW |
427 | |
428 | if (len < 0) { | |
c4ba5793 JS |
429 | if (options & PACKET_READ_GENTLE_ON_READ_ERROR) |
430 | return error(_("protocol error: bad line length " | |
431 | "character: %.4s"), linelen); | |
c60d7697 | 432 | die(_("protocol error: bad line length character: %.4s"), linelen); |
2153d478 | 433 | } else if (!len) { |
bbc30f99 | 434 | packet_trace("0000", 4, 0); |
2153d478 BW |
435 | *pktlen = 0; |
436 | return PACKET_READ_FLUSH; | |
a4cfd41c BW |
437 | } else if (len == 1) { |
438 | packet_trace("0001", 4, 0); | |
439 | *pktlen = 0; | |
440 | return PACKET_READ_DELIM; | |
0181b600 DL |
441 | } else if (len == 2) { |
442 | packet_trace("0002", 4, 0); | |
443 | *pktlen = 0; | |
444 | return PACKET_READ_RESPONSE_END; | |
2153d478 | 445 | } else if (len < 4) { |
c4ba5793 JS |
446 | if (options & PACKET_READ_GENTLE_ON_READ_ERROR) |
447 | return error(_("protocol error: bad line length %d"), | |
448 | len); | |
c60d7697 | 449 | die(_("protocol error: bad line length %d"), len); |
bbc30f99 | 450 | } |
2153d478 | 451 | |
f3a3214e | 452 | len -= 4; |
c4ba5793 JS |
453 | if ((unsigned)len >= size) { |
454 | if (options & PACKET_READ_GENTLE_ON_READ_ERROR) | |
455 | return error(_("protocol error: bad line length %d"), | |
456 | len); | |
c60d7697 | 457 | die(_("protocol error: bad line length %d"), len); |
c4ba5793 | 458 | } |
2153d478 BW |
459 | |
460 | if (get_packet_data(fd, src_buffer, src_len, buffer, len, options) < 0) { | |
461 | *pktlen = -1; | |
462 | return PACKET_READ_EOF; | |
463 | } | |
819b929d JK |
464 | |
465 | if ((options & PACKET_READ_CHOMP_NEWLINE) && | |
7033d547 JX |
466 | len && buffer[len-1] == '\n') { |
467 | if (options & PACKET_READ_USE_SIDEBAND) { | |
468 | int band = *buffer & 0xff; | |
469 | switch (band) { | |
470 | case 1: | |
471 | /* Chomp newline for payload */ | |
472 | len--; | |
473 | break; | |
474 | case 2: | |
475 | case 3: | |
476 | /* | |
477 | * Do not chomp newline for progress and error | |
478 | * message. | |
479 | */ | |
480 | break; | |
481 | default: | |
482 | /* | |
483 | * Bad sideband, let's leave it to | |
484 | * demultiplex_sideband() to catch this error. | |
485 | */ | |
486 | break; | |
487 | } | |
488 | } else { | |
489 | len--; | |
490 | } | |
491 | } | |
819b929d | 492 | |
f3a3214e | 493 | buffer[len] = 0; |
88e9b1e3 IF |
494 | if (options & PACKET_READ_REDACT_URI_PATH && |
495 | (uri_path_start = find_packfile_uri_path(buffer))) { | |
496 | const char *redacted = "<redacted>"; | |
497 | struct strbuf tracebuf = STRBUF_INIT; | |
498 | strbuf_insert(&tracebuf, 0, buffer, len); | |
499 | strbuf_splice(&tracebuf, uri_path_start - buffer, | |
500 | strlen(uri_path_start), redacted, strlen(redacted)); | |
501 | packet_trace(tracebuf.buf, tracebuf.len, 0); | |
502 | strbuf_release(&tracebuf); | |
503 | } else { | |
504 | packet_trace(buffer, len, 0); | |
505 | } | |
533ddba4 JK |
506 | |
507 | if ((options & PACKET_READ_DIE_ON_ERR_PACKET) && | |
508 | starts_with(buffer, "ERR ")) | |
509 | die(_("remote error: %s"), buffer + 4); | |
510 | ||
2153d478 BW |
511 | *pktlen = len; |
512 | return PACKET_READ_NORMAL; | |
513 | } | |
514 | ||
ec9a37d6 | 515 | int packet_read(int fd, char *buffer, unsigned size, int options) |
2153d478 BW |
516 | { |
517 | int pktlen = -1; | |
518 | ||
ec9a37d6 ÆAB |
519 | packet_read_with_status(fd, NULL, NULL, buffer, size, &pktlen, |
520 | options); | |
2153d478 BW |
521 | |
522 | return pktlen; | |
f3a3214e | 523 | } |
f5615d24 | 524 | |
ec9a37d6 | 525 | char *packet_read_line(int fd, int *dst_len) |
46284dd1 | 526 | { |
ec9a37d6 | 527 | int len = packet_read(fd, packet_buffer, sizeof(packet_buffer), |
74543a04 | 528 | PACKET_READ_CHOMP_NEWLINE); |
4981fe75 JK |
529 | if (dst_len) |
530 | *dst_len = len; | |
974b50c5 | 531 | return (len > 0) ? packet_buffer : NULL; |
46284dd1 HV |
532 | } |
533 | ||
825b9226 BP |
534 | int packet_read_line_gently(int fd, int *dst_len, char **dst_line) |
535 | { | |
ec9a37d6 | 536 | int len = packet_read(fd, packet_buffer, sizeof(packet_buffer), |
825b9226 BP |
537 | PACKET_READ_CHOMP_NEWLINE|PACKET_READ_GENTLE_ON_EOF); |
538 | if (dst_len) | |
539 | *dst_len = len; | |
540 | if (dst_line) | |
541 | *dst_line = (len > 0) ? packet_buffer : NULL; | |
542 | return len; | |
543 | } | |
544 | ||
8c2efa5d | 545 | ssize_t read_packetized_to_strbuf(int fd_in, struct strbuf *sb_out, int options) |
bb643d8b LS |
546 | { |
547 | int packet_len; | |
548 | ||
549 | size_t orig_len = sb_out->len; | |
550 | size_t orig_alloc = sb_out->alloc; | |
551 | ||
552 | for (;;) { | |
553 | strbuf_grow(sb_out, LARGE_PACKET_DATA_MAX); | |
ec9a37d6 | 554 | packet_len = packet_read(fd_in, |
bb643d8b LS |
555 | /* strbuf_grow() above always allocates one extra byte to |
556 | * store a '\0' at the end of the string. packet_read() | |
557 | * writes a '\0' extra byte at the end, too. Let it know | |
558 | * that there is already room for the extra byte. | |
559 | */ | |
560 | sb_out->buf + sb_out->len, LARGE_PACKET_DATA_MAX+1, | |
8c2efa5d | 561 | options); |
bb643d8b LS |
562 | if (packet_len <= 0) |
563 | break; | |
564 | sb_out->len += packet_len; | |
565 | } | |
566 | ||
567 | if (packet_len < 0) { | |
568 | if (orig_alloc == 0) | |
569 | strbuf_release(sb_out); | |
570 | else | |
571 | strbuf_setlen(sb_out, orig_len); | |
572 | return packet_len; | |
573 | } | |
574 | return sb_out->len - orig_len; | |
575 | } | |
77dabc14 | 576 | |
fbd76cd4 JT |
577 | int recv_sideband(const char *me, int in_stream, int out) |
578 | { | |
579 | char buf[LARGE_PACKET_MAX + 1]; | |
580 | int len; | |
581 | struct strbuf scratch = STRBUF_INIT; | |
582 | enum sideband_type sideband_type; | |
583 | ||
584 | while (1) { | |
af22a63c JK |
585 | int status = packet_read_with_status(in_stream, NULL, NULL, |
586 | buf, LARGE_PACKET_MAX, | |
587 | &len, | |
588 | PACKET_READ_GENTLE_ON_EOF); | |
589 | if (!demultiplex_sideband(me, status, buf, len, 0, &scratch, | |
fbd76cd4 JT |
590 | &sideband_type)) |
591 | continue; | |
592 | switch (sideband_type) { | |
593 | case SIDEBAND_PRIMARY: | |
594 | write_or_die(out, buf + 1, len - 1); | |
595 | break; | |
596 | default: /* errors: message already written */ | |
8e86cf65 JS |
597 | if (scratch.len > 0) |
598 | BUG("unhandled incomplete sideband: '%s'", | |
599 | scratch.buf); | |
fbd76cd4 JT |
600 | return sideband_type; |
601 | } | |
602 | } | |
603 | } | |
604 | ||
77dabc14 BW |
605 | /* Packet Reader Functions */ |
606 | void packet_reader_init(struct packet_reader *reader, int fd, | |
607 | char *src_buffer, size_t src_len, | |
608 | int options) | |
609 | { | |
610 | memset(reader, 0, sizeof(*reader)); | |
611 | ||
612 | reader->fd = fd; | |
613 | reader->src_buffer = src_buffer; | |
614 | reader->src_len = src_len; | |
615 | reader->buffer = packet_buffer; | |
616 | reader->buffer_size = sizeof(packet_buffer); | |
617 | reader->options = options; | |
0bbc0bc5 | 618 | reader->me = "git"; |
9a9f0d3f | 619 | reader->hash_algo = &hash_algos[GIT_HASH_SHA1]; |
64220dc5 | 620 | strbuf_init(&reader->scratch, 0); |
77dabc14 BW |
621 | } |
622 | ||
623 | enum packet_read_status packet_reader_read(struct packet_reader *reader) | |
624 | { | |
625 | if (reader->line_peeked) { | |
626 | reader->line_peeked = 0; | |
627 | return reader->status; | |
628 | } | |
629 | ||
7033d547 JX |
630 | if (reader->use_sideband) |
631 | reader->options |= PACKET_READ_USE_SIDEBAND; | |
632 | ||
0bbc0bc5 JT |
633 | /* |
634 | * Consume all progress packets until a primary payload packet is | |
635 | * received | |
636 | */ | |
637 | while (1) { | |
638 | enum sideband_type sideband_type; | |
639 | reader->status = packet_read_with_status(reader->fd, | |
640 | &reader->src_buffer, | |
641 | &reader->src_len, | |
642 | reader->buffer, | |
643 | reader->buffer_size, | |
644 | &reader->pktlen, | |
645 | reader->options); | |
646 | if (!reader->use_sideband) | |
647 | break; | |
af22a63c JK |
648 | if (demultiplex_sideband(reader->me, reader->status, |
649 | reader->buffer, reader->pktlen, 1, | |
64220dc5 | 650 | &reader->scratch, &sideband_type)) |
0bbc0bc5 JT |
651 | break; |
652 | } | |
77dabc14 BW |
653 | |
654 | if (reader->status == PACKET_READ_NORMAL) | |
0bbc0bc5 JT |
655 | /* Skip the sideband designator if sideband is used */ |
656 | reader->line = reader->use_sideband ? | |
657 | reader->buffer + 1 : reader->buffer; | |
77dabc14 BW |
658 | else |
659 | reader->line = NULL; | |
660 | ||
661 | return reader->status; | |
662 | } | |
663 | ||
664 | enum packet_read_status packet_reader_peek(struct packet_reader *reader) | |
665 | { | |
666 | /* Only allow peeking a single line */ | |
667 | if (reader->line_peeked) | |
668 | return reader->status; | |
669 | ||
670 | /* Peek a line by reading it and setting peeked flag */ | |
671 | packet_reader_read(reader); | |
672 | reader->line_peeked = 1; | |
673 | return reader->status; | |
674 | } | |
bc2e795c JT |
675 | |
676 | void packet_writer_init(struct packet_writer *writer, int dest_fd) | |
677 | { | |
678 | writer->dest_fd = dest_fd; | |
0bbc0bc5 | 679 | writer->use_sideband = 0; |
bc2e795c JT |
680 | } |
681 | ||
682 | void packet_writer_write(struct packet_writer *writer, const char *fmt, ...) | |
683 | { | |
684 | va_list args; | |
685 | ||
686 | va_start(args, fmt); | |
0bbc0bc5 JT |
687 | packet_write_fmt_1(writer->dest_fd, 0, |
688 | writer->use_sideband ? "\001" : "", fmt, args); | |
bc2e795c JT |
689 | va_end(args); |
690 | } | |
691 | ||
692 | void packet_writer_error(struct packet_writer *writer, const char *fmt, ...) | |
693 | { | |
694 | va_list args; | |
695 | ||
696 | va_start(args, fmt); | |
0bbc0bc5 JT |
697 | packet_write_fmt_1(writer->dest_fd, 0, |
698 | writer->use_sideband ? "\003" : "ERR ", fmt, args); | |
bc2e795c JT |
699 | va_end(args); |
700 | } | |
701 | ||
702 | void packet_writer_delim(struct packet_writer *writer) | |
703 | { | |
704 | packet_delim(writer->dest_fd); | |
705 | } | |
706 | ||
707 | void packet_writer_flush(struct packet_writer *writer) | |
708 | { | |
709 | packet_flush(writer->dest_fd); | |
710 | } |