]>
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); |
37c80012 JK |
91 | if (write_in_full(fd, "0000", 4) < 0) |
92 | die_errno(_("unable to write flush packet")); | |
f3a3214e LT |
93 | } |
94 | ||
a4cfd41c BW |
95 | void packet_delim(int fd) |
96 | { | |
97 | packet_trace("0001", 4, 1); | |
37c80012 JK |
98 | if (write_in_full(fd, "0001", 4) < 0) |
99 | die_errno(_("unable to write delim packet")); | |
a4cfd41c BW |
100 | } |
101 | ||
0181b600 DL |
102 | void packet_response_end(int fd) |
103 | { | |
104 | packet_trace("0002", 4, 1); | |
105 | if (write_in_full(fd, "0002", 4) < 0) | |
8232a0ff | 106 | die_errno(_("unable to write response end packet")); |
0181b600 DL |
107 | } |
108 | ||
038ce90f LS |
109 | int packet_flush_gently(int fd) |
110 | { | |
111 | packet_trace("0000", 4, 1); | |
4c95e3dd | 112 | if (write_in_full(fd, "0000", 4) < 0) |
c60d7697 | 113 | return error(_("flush packet write failed")); |
4c95e3dd | 114 | return 0; |
038ce90f LS |
115 | } |
116 | ||
f5615d24 SP |
117 | void packet_buf_flush(struct strbuf *buf) |
118 | { | |
bbc30f99 | 119 | packet_trace("0000", 4, 1); |
f5615d24 SP |
120 | strbuf_add(buf, "0000", 4); |
121 | } | |
122 | ||
a4cfd41c BW |
123 | void packet_buf_delim(struct strbuf *buf) |
124 | { | |
125 | packet_trace("0001", 4, 1); | |
126 | strbuf_add(buf, "0001", 4); | |
127 | } | |
128 | ||
56bea280 | 129 | void set_packet_header(char *buf, int size) |
f3a3214e | 130 | { |
f3a3214e | 131 | static char hexchar[] = "0123456789abcdef"; |
2f60bdd1 LS |
132 | |
133 | #define hex(a) (hexchar[(a) & 15]) | |
134 | buf[0] = hex(size >> 12); | |
135 | buf[1] = hex(size >> 8); | |
136 | buf[2] = hex(size >> 4); | |
137 | buf[3] = hex(size); | |
138 | #undef hex | |
139 | } | |
140 | ||
bc2e795c JT |
141 | static void format_packet(struct strbuf *out, const char *prefix, |
142 | const char *fmt, va_list args) | |
2f60bdd1 | 143 | { |
8e9faf27 | 144 | size_t orig_len, n; |
f3a3214e | 145 | |
8e9faf27 JK |
146 | orig_len = out->len; |
147 | strbuf_addstr(out, "0000"); | |
bc2e795c | 148 | strbuf_addstr(out, prefix); |
8e9faf27 JK |
149 | strbuf_vaddf(out, fmt, args); |
150 | n = out->len - orig_len; | |
151 | ||
152 | if (n > LARGE_PACKET_MAX) | |
c60d7697 | 153 | die(_("protocol error: impossibly long line")); |
8e9faf27 | 154 | |
2f60bdd1 | 155 | set_packet_header(&out->buf[orig_len], n); |
8e9faf27 | 156 | packet_trace(out->buf + orig_len + 4, n - 4, 1); |
f5615d24 SP |
157 | } |
158 | ||
bc2e795c | 159 | static int packet_write_fmt_1(int fd, int gently, const char *prefix, |
70428d1a LS |
160 | const char *fmt, va_list args) |
161 | { | |
150efef1 | 162 | static struct strbuf buf = STRBUF_INIT; |
70428d1a | 163 | |
150efef1 | 164 | strbuf_reset(&buf); |
bc2e795c | 165 | format_packet(&buf, prefix, fmt, args); |
4c95e3dd JK |
166 | if (write_in_full(fd, buf.buf, buf.len) < 0) { |
167 | if (!gently) { | |
168 | check_pipe(errno); | |
c60d7697 | 169 | die_errno(_("packet write with format failed")); |
4c95e3dd | 170 | } |
c60d7697 | 171 | return error(_("packet write with format failed")); |
70428d1a | 172 | } |
4c95e3dd JK |
173 | |
174 | return 0; | |
70428d1a LS |
175 | } |
176 | ||
81c634e9 | 177 | void packet_write_fmt(int fd, const char *fmt, ...) |
f5615d24 SP |
178 | { |
179 | va_list args; | |
f5615d24 SP |
180 | |
181 | va_start(args, fmt); | |
bc2e795c | 182 | packet_write_fmt_1(fd, 0, "", fmt, args); |
70428d1a LS |
183 | va_end(args); |
184 | } | |
185 | ||
186 | int packet_write_fmt_gently(int fd, const char *fmt, ...) | |
187 | { | |
188 | int status; | |
189 | va_list args; | |
190 | ||
191 | va_start(args, fmt); | |
bc2e795c | 192 | status = packet_write_fmt_1(fd, 1, "", fmt, args); |
f5615d24 | 193 | va_end(args); |
70428d1a | 194 | return status; |
f3a3214e LT |
195 | } |
196 | ||
332ec963 MT |
197 | static int do_packet_write(const int fd_out, const char *buf, size_t size, |
198 | struct strbuf *err) | |
edfb780c | 199 | { |
7455e05e | 200 | char header[4]; |
edfb780c LS |
201 | size_t packet_size; |
202 | ||
332ec963 MT |
203 | if (size > LARGE_PACKET_DATA_MAX) { |
204 | strbuf_addstr(err, _("packet write failed - data exceeds max packet size")); | |
205 | return -1; | |
206 | } | |
edfb780c LS |
207 | |
208 | packet_trace(buf, size, 1); | |
209 | packet_size = size + 4; | |
7455e05e JH |
210 | |
211 | set_packet_header(header, packet_size); | |
212 | ||
213 | /* | |
214 | * Write the header and the buffer in 2 parts so that we do | |
215 | * not need to allocate a buffer or rely on a static buffer. | |
216 | * This also avoids putting a large buffer on the stack which | |
217 | * might have multi-threading issues. | |
218 | */ | |
219 | ||
220 | if (write_in_full(fd_out, header, 4) < 0 || | |
332ec963 MT |
221 | write_in_full(fd_out, buf, size) < 0) { |
222 | strbuf_addf(err, _("packet write failed: %s"), strerror(errno)); | |
223 | return -1; | |
224 | } | |
225 | return 0; | |
226 | } | |
227 | ||
228 | static int packet_write_gently(const int fd_out, const char *buf, size_t size) | |
229 | { | |
230 | struct strbuf err = STRBUF_INIT; | |
231 | if (do_packet_write(fd_out, buf, size, &err)) { | |
232 | error("%s", err.buf); | |
233 | strbuf_release(&err); | |
234 | return -1; | |
235 | } | |
4c95e3dd | 236 | return 0; |
edfb780c LS |
237 | } |
238 | ||
5d2124b3 BW |
239 | void packet_write(int fd_out, const char *buf, size_t size) |
240 | { | |
332ec963 MT |
241 | struct strbuf err = STRBUF_INIT; |
242 | if (do_packet_write(fd_out, buf, size, &err)) | |
243 | die("%s", err.buf); | |
5d2124b3 BW |
244 | } |
245 | ||
f5615d24 SP |
246 | void packet_buf_write(struct strbuf *buf, const char *fmt, ...) |
247 | { | |
248 | va_list args; | |
f5615d24 SP |
249 | |
250 | va_start(args, fmt); | |
bc2e795c | 251 | format_packet(buf, "", fmt, args); |
f5615d24 | 252 | va_end(args); |
f5615d24 SP |
253 | } |
254 | ||
f1f4d8ac BW |
255 | void packet_buf_write_len(struct strbuf *buf, const char *data, size_t len) |
256 | { | |
257 | size_t orig_len, n; | |
258 | ||
259 | orig_len = buf->len; | |
260 | strbuf_addstr(buf, "0000"); | |
261 | strbuf_add(buf, data, len); | |
262 | n = buf->len - orig_len; | |
263 | ||
264 | if (n > LARGE_PACKET_MAX) | |
c60d7697 | 265 | die(_("protocol error: impossibly long line")); |
f1f4d8ac BW |
266 | |
267 | set_packet_header(&buf->buf[orig_len], n); | |
268 | packet_trace(data, len, 1); | |
269 | } | |
270 | ||
3a63c6a4 | 271 | int write_packetized_from_fd_no_flush(int fd_in, int fd_out) |
bb643d8b | 272 | { |
7455e05e | 273 | char *buf = xmalloc(LARGE_PACKET_DATA_MAX); |
bb643d8b LS |
274 | int err = 0; |
275 | ssize_t bytes_to_write; | |
276 | ||
277 | while (!err) { | |
7455e05e JH |
278 | bytes_to_write = xread(fd_in, buf, LARGE_PACKET_DATA_MAX); |
279 | if (bytes_to_write < 0) { | |
280 | free(buf); | |
bb643d8b | 281 | return COPY_READ_ERROR; |
7455e05e | 282 | } |
bb643d8b LS |
283 | if (bytes_to_write == 0) |
284 | break; | |
285 | err = packet_write_gently(fd_out, buf, bytes_to_write); | |
286 | } | |
7455e05e | 287 | free(buf); |
bb643d8b LS |
288 | return err; |
289 | } | |
290 | ||
3a63c6a4 | 291 | int write_packetized_from_buf_no_flush(const char *src_in, size_t len, int fd_out) |
bb643d8b LS |
292 | { |
293 | int err = 0; | |
294 | size_t bytes_written = 0; | |
295 | size_t bytes_to_write; | |
296 | ||
297 | while (!err) { | |
298 | if ((len - bytes_written) > LARGE_PACKET_DATA_MAX) | |
299 | bytes_to_write = LARGE_PACKET_DATA_MAX; | |
300 | else | |
301 | bytes_to_write = len - bytes_written; | |
302 | if (bytes_to_write == 0) | |
303 | break; | |
304 | err = packet_write_gently(fd_out, src_in + bytes_written, bytes_to_write); | |
305 | bytes_written += bytes_to_write; | |
306 | } | |
bb643d8b LS |
307 | return err; |
308 | } | |
309 | ||
4981fe75 JK |
310 | static int get_packet_data(int fd, char **src_buf, size_t *src_size, |
311 | void *dst, unsigned size, int options) | |
f3a3214e | 312 | { |
4981fe75 JK |
313 | ssize_t ret; |
314 | ||
315 | if (fd >= 0 && src_buf && *src_buf) | |
033abf97 | 316 | BUG("multiple sources given to packet_read"); |
4981fe75 JK |
317 | |
318 | /* Read up to "size" bytes from our source, whatever it is. */ | |
319 | if (src_buf && *src_buf) { | |
320 | ret = size < *src_size ? size : *src_size; | |
321 | memcpy(dst, *src_buf, ret); | |
322 | *src_buf += ret; | |
323 | *src_size -= ret; | |
324 | } else { | |
325 | ret = read_in_full(fd, dst, size); | |
c4ba5793 JS |
326 | if (ret < 0) { |
327 | if (options & PACKET_READ_GENTLE_ON_READ_ERROR) | |
328 | return error_errno(_("read error")); | |
c60d7697 | 329 | die_errno(_("read error")); |
c4ba5793 | 330 | } |
4981fe75 JK |
331 | } |
332 | ||
333 | /* And complain if we didn't get enough bytes to satisfy the read. */ | |
61d36330 | 334 | if (ret != size) { |
03809429 | 335 | if (options & PACKET_READ_GENTLE_ON_EOF) |
46284dd1 HV |
336 | return -1; |
337 | ||
c4ba5793 JS |
338 | if (options & PACKET_READ_GENTLE_ON_READ_ERROR) |
339 | return error(_("the remote end hung up unexpectedly")); | |
c60d7697 | 340 | die(_("the remote end hung up unexpectedly")); |
46284dd1 HV |
341 | } |
342 | ||
343 | return ret; | |
f3a3214e LT |
344 | } |
345 | ||
101736a1 | 346 | int packet_length(const char lenbuf_hex[4]) |
f3a3214e | 347 | { |
101736a1 DL |
348 | int val = hex2chr(lenbuf_hex); |
349 | return (val < 0) ? val : (val << 8) | hex2chr(lenbuf_hex + 2); | |
f5615d24 SP |
350 | } |
351 | ||
2153d478 BW |
352 | enum packet_read_status packet_read_with_status(int fd, char **src_buffer, |
353 | size_t *src_len, char *buffer, | |
354 | unsigned size, int *pktlen, | |
355 | int options) | |
f5615d24 | 356 | { |
2153d478 | 357 | int len; |
f5615d24 SP |
358 | char linelen[4]; |
359 | ||
2153d478 BW |
360 | if (get_packet_data(fd, src_buffer, src_len, linelen, 4, options) < 0) { |
361 | *pktlen = -1; | |
362 | return PACKET_READ_EOF; | |
363 | } | |
364 | ||
f5615d24 | 365 | len = packet_length(linelen); |
2153d478 BW |
366 | |
367 | if (len < 0) { | |
c4ba5793 JS |
368 | if (options & PACKET_READ_GENTLE_ON_READ_ERROR) |
369 | return error(_("protocol error: bad line length " | |
370 | "character: %.4s"), linelen); | |
c60d7697 | 371 | die(_("protocol error: bad line length character: %.4s"), linelen); |
2153d478 | 372 | } else if (!len) { |
bbc30f99 | 373 | packet_trace("0000", 4, 0); |
2153d478 BW |
374 | *pktlen = 0; |
375 | return PACKET_READ_FLUSH; | |
a4cfd41c BW |
376 | } else if (len == 1) { |
377 | packet_trace("0001", 4, 0); | |
378 | *pktlen = 0; | |
379 | return PACKET_READ_DELIM; | |
0181b600 DL |
380 | } else if (len == 2) { |
381 | packet_trace("0002", 4, 0); | |
382 | *pktlen = 0; | |
383 | return PACKET_READ_RESPONSE_END; | |
2153d478 | 384 | } else if (len < 4) { |
c4ba5793 JS |
385 | if (options & PACKET_READ_GENTLE_ON_READ_ERROR) |
386 | return error(_("protocol error: bad line length %d"), | |
387 | len); | |
c60d7697 | 388 | die(_("protocol error: bad line length %d"), len); |
bbc30f99 | 389 | } |
2153d478 | 390 | |
f3a3214e | 391 | len -= 4; |
c4ba5793 JS |
392 | if ((unsigned)len >= size) { |
393 | if (options & PACKET_READ_GENTLE_ON_READ_ERROR) | |
394 | return error(_("protocol error: bad line length %d"), | |
395 | len); | |
c60d7697 | 396 | die(_("protocol error: bad line length %d"), len); |
c4ba5793 | 397 | } |
2153d478 BW |
398 | |
399 | if (get_packet_data(fd, src_buffer, src_len, buffer, len, options) < 0) { | |
400 | *pktlen = -1; | |
401 | return PACKET_READ_EOF; | |
402 | } | |
819b929d JK |
403 | |
404 | if ((options & PACKET_READ_CHOMP_NEWLINE) && | |
405 | len && buffer[len-1] == '\n') | |
406 | len--; | |
407 | ||
f3a3214e | 408 | buffer[len] = 0; |
bbc30f99 | 409 | packet_trace(buffer, len, 0); |
533ddba4 JK |
410 | |
411 | if ((options & PACKET_READ_DIE_ON_ERR_PACKET) && | |
412 | starts_with(buffer, "ERR ")) | |
413 | die(_("remote error: %s"), buffer + 4); | |
414 | ||
2153d478 BW |
415 | *pktlen = len; |
416 | return PACKET_READ_NORMAL; | |
417 | } | |
418 | ||
419 | int packet_read(int fd, char **src_buffer, size_t *src_len, | |
420 | char *buffer, unsigned size, int options) | |
421 | { | |
422 | int pktlen = -1; | |
423 | ||
424 | packet_read_with_status(fd, src_buffer, src_len, buffer, size, | |
425 | &pktlen, options); | |
426 | ||
427 | return pktlen; | |
f3a3214e | 428 | } |
f5615d24 | 429 | |
4981fe75 JK |
430 | static char *packet_read_line_generic(int fd, |
431 | char **src, size_t *src_len, | |
432 | int *dst_len) | |
46284dd1 | 433 | { |
4981fe75 JK |
434 | int len = packet_read(fd, src, src_len, |
435 | packet_buffer, sizeof(packet_buffer), | |
74543a04 | 436 | PACKET_READ_CHOMP_NEWLINE); |
4981fe75 JK |
437 | if (dst_len) |
438 | *dst_len = len; | |
974b50c5 | 439 | return (len > 0) ? packet_buffer : NULL; |
46284dd1 HV |
440 | } |
441 | ||
4981fe75 | 442 | char *packet_read_line(int fd, int *len_p) |
f5615d24 | 443 | { |
4981fe75 JK |
444 | return packet_read_line_generic(fd, NULL, NULL, len_p); |
445 | } | |
f5615d24 | 446 | |
825b9226 BP |
447 | int packet_read_line_gently(int fd, int *dst_len, char **dst_line) |
448 | { | |
449 | int len = packet_read(fd, NULL, NULL, | |
450 | packet_buffer, sizeof(packet_buffer), | |
451 | PACKET_READ_CHOMP_NEWLINE|PACKET_READ_GENTLE_ON_EOF); | |
452 | if (dst_len) | |
453 | *dst_len = len; | |
454 | if (dst_line) | |
455 | *dst_line = (len > 0) ? packet_buffer : NULL; | |
456 | return len; | |
457 | } | |
458 | ||
4981fe75 JK |
459 | char *packet_read_line_buf(char **src, size_t *src_len, int *dst_len) |
460 | { | |
461 | return packet_read_line_generic(-1, src, src_len, dst_len); | |
f5615d24 | 462 | } |
bb643d8b | 463 | |
8c2efa5d | 464 | ssize_t read_packetized_to_strbuf(int fd_in, struct strbuf *sb_out, int options) |
bb643d8b LS |
465 | { |
466 | int packet_len; | |
467 | ||
468 | size_t orig_len = sb_out->len; | |
469 | size_t orig_alloc = sb_out->alloc; | |
470 | ||
471 | for (;;) { | |
472 | strbuf_grow(sb_out, LARGE_PACKET_DATA_MAX); | |
473 | packet_len = packet_read(fd_in, NULL, NULL, | |
474 | /* strbuf_grow() above always allocates one extra byte to | |
475 | * store a '\0' at the end of the string. packet_read() | |
476 | * writes a '\0' extra byte at the end, too. Let it know | |
477 | * that there is already room for the extra byte. | |
478 | */ | |
479 | sb_out->buf + sb_out->len, LARGE_PACKET_DATA_MAX+1, | |
8c2efa5d | 480 | options); |
bb643d8b LS |
481 | if (packet_len <= 0) |
482 | break; | |
483 | sb_out->len += packet_len; | |
484 | } | |
485 | ||
486 | if (packet_len < 0) { | |
487 | if (orig_alloc == 0) | |
488 | strbuf_release(sb_out); | |
489 | else | |
490 | strbuf_setlen(sb_out, orig_len); | |
491 | return packet_len; | |
492 | } | |
493 | return sb_out->len - orig_len; | |
494 | } | |
77dabc14 | 495 | |
fbd76cd4 JT |
496 | int recv_sideband(const char *me, int in_stream, int out) |
497 | { | |
498 | char buf[LARGE_PACKET_MAX + 1]; | |
499 | int len; | |
500 | struct strbuf scratch = STRBUF_INIT; | |
501 | enum sideband_type sideband_type; | |
502 | ||
503 | while (1) { | |
af22a63c JK |
504 | int status = packet_read_with_status(in_stream, NULL, NULL, |
505 | buf, LARGE_PACKET_MAX, | |
506 | &len, | |
507 | PACKET_READ_GENTLE_ON_EOF); | |
508 | if (!demultiplex_sideband(me, status, buf, len, 0, &scratch, | |
fbd76cd4 JT |
509 | &sideband_type)) |
510 | continue; | |
511 | switch (sideband_type) { | |
512 | case SIDEBAND_PRIMARY: | |
513 | write_or_die(out, buf + 1, len - 1); | |
514 | break; | |
515 | default: /* errors: message already written */ | |
8e86cf65 JS |
516 | if (scratch.len > 0) |
517 | BUG("unhandled incomplete sideband: '%s'", | |
518 | scratch.buf); | |
fbd76cd4 JT |
519 | return sideband_type; |
520 | } | |
521 | } | |
522 | } | |
523 | ||
77dabc14 BW |
524 | /* Packet Reader Functions */ |
525 | void packet_reader_init(struct packet_reader *reader, int fd, | |
526 | char *src_buffer, size_t src_len, | |
527 | int options) | |
528 | { | |
529 | memset(reader, 0, sizeof(*reader)); | |
530 | ||
531 | reader->fd = fd; | |
532 | reader->src_buffer = src_buffer; | |
533 | reader->src_len = src_len; | |
534 | reader->buffer = packet_buffer; | |
535 | reader->buffer_size = sizeof(packet_buffer); | |
536 | reader->options = options; | |
0bbc0bc5 | 537 | reader->me = "git"; |
9a9f0d3f | 538 | reader->hash_algo = &hash_algos[GIT_HASH_SHA1]; |
77dabc14 BW |
539 | } |
540 | ||
541 | enum packet_read_status packet_reader_read(struct packet_reader *reader) | |
542 | { | |
0bbc0bc5 JT |
543 | struct strbuf scratch = STRBUF_INIT; |
544 | ||
77dabc14 BW |
545 | if (reader->line_peeked) { |
546 | reader->line_peeked = 0; | |
547 | return reader->status; | |
548 | } | |
549 | ||
0bbc0bc5 JT |
550 | /* |
551 | * Consume all progress packets until a primary payload packet is | |
552 | * received | |
553 | */ | |
554 | while (1) { | |
555 | enum sideband_type sideband_type; | |
556 | reader->status = packet_read_with_status(reader->fd, | |
557 | &reader->src_buffer, | |
558 | &reader->src_len, | |
559 | reader->buffer, | |
560 | reader->buffer_size, | |
561 | &reader->pktlen, | |
562 | reader->options); | |
563 | if (!reader->use_sideband) | |
564 | break; | |
af22a63c JK |
565 | if (demultiplex_sideband(reader->me, reader->status, |
566 | reader->buffer, reader->pktlen, 1, | |
567 | &scratch, &sideband_type)) | |
0bbc0bc5 JT |
568 | break; |
569 | } | |
77dabc14 BW |
570 | |
571 | if (reader->status == PACKET_READ_NORMAL) | |
0bbc0bc5 JT |
572 | /* Skip the sideband designator if sideband is used */ |
573 | reader->line = reader->use_sideband ? | |
574 | reader->buffer + 1 : reader->buffer; | |
77dabc14 BW |
575 | else |
576 | reader->line = NULL; | |
577 | ||
578 | return reader->status; | |
579 | } | |
580 | ||
581 | enum packet_read_status packet_reader_peek(struct packet_reader *reader) | |
582 | { | |
583 | /* Only allow peeking a single line */ | |
584 | if (reader->line_peeked) | |
585 | return reader->status; | |
586 | ||
587 | /* Peek a line by reading it and setting peeked flag */ | |
588 | packet_reader_read(reader); | |
589 | reader->line_peeked = 1; | |
590 | return reader->status; | |
591 | } | |
bc2e795c JT |
592 | |
593 | void packet_writer_init(struct packet_writer *writer, int dest_fd) | |
594 | { | |
595 | writer->dest_fd = dest_fd; | |
0bbc0bc5 | 596 | writer->use_sideband = 0; |
bc2e795c JT |
597 | } |
598 | ||
599 | void packet_writer_write(struct packet_writer *writer, const char *fmt, ...) | |
600 | { | |
601 | va_list args; | |
602 | ||
603 | va_start(args, fmt); | |
0bbc0bc5 JT |
604 | packet_write_fmt_1(writer->dest_fd, 0, |
605 | writer->use_sideband ? "\001" : "", fmt, args); | |
bc2e795c JT |
606 | va_end(args); |
607 | } | |
608 | ||
609 | void packet_writer_error(struct packet_writer *writer, const char *fmt, ...) | |
610 | { | |
611 | va_list args; | |
612 | ||
613 | va_start(args, fmt); | |
0bbc0bc5 JT |
614 | packet_write_fmt_1(writer->dest_fd, 0, |
615 | writer->use_sideband ? "\003" : "ERR ", fmt, args); | |
bc2e795c JT |
616 | va_end(args); |
617 | } | |
618 | ||
619 | void packet_writer_delim(struct packet_writer *writer) | |
620 | { | |
621 | packet_delim(writer->dest_fd); | |
622 | } | |
623 | ||
624 | void packet_writer_flush(struct packet_writer *writer) | |
625 | { | |
626 | packet_flush(writer->dest_fd); | |
627 | } |