]>
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 | ||
f5615d24 SP |
94 | void packet_buf_flush(struct strbuf *buf) |
95 | { | |
bbc30f99 | 96 | packet_trace("0000", 4, 1); |
f5615d24 SP |
97 | strbuf_add(buf, "0000", 4); |
98 | } | |
99 | ||
2f60bdd1 | 100 | static void set_packet_header(char *buf, const int size) |
f3a3214e | 101 | { |
f3a3214e | 102 | static char hexchar[] = "0123456789abcdef"; |
2f60bdd1 LS |
103 | |
104 | #define hex(a) (hexchar[(a) & 15]) | |
105 | buf[0] = hex(size >> 12); | |
106 | buf[1] = hex(size >> 8); | |
107 | buf[2] = hex(size >> 4); | |
108 | buf[3] = hex(size); | |
109 | #undef hex | |
110 | } | |
111 | ||
112 | static void format_packet(struct strbuf *out, const char *fmt, va_list args) | |
113 | { | |
8e9faf27 | 114 | size_t orig_len, n; |
f3a3214e | 115 | |
8e9faf27 JK |
116 | orig_len = out->len; |
117 | strbuf_addstr(out, "0000"); | |
118 | strbuf_vaddf(out, fmt, args); | |
119 | n = out->len - orig_len; | |
120 | ||
121 | if (n > LARGE_PACKET_MAX) | |
f3a3214e | 122 | die("protocol error: impossibly long line"); |
8e9faf27 | 123 | |
2f60bdd1 | 124 | set_packet_header(&out->buf[orig_len], n); |
8e9faf27 | 125 | packet_trace(out->buf + orig_len + 4, n - 4, 1); |
f5615d24 SP |
126 | } |
127 | ||
81c634e9 | 128 | void packet_write_fmt(int fd, const char *fmt, ...) |
f5615d24 | 129 | { |
8e9faf27 | 130 | static struct strbuf buf = STRBUF_INIT; |
f5615d24 | 131 | va_list args; |
f5615d24 | 132 | |
8e9faf27 | 133 | strbuf_reset(&buf); |
f5615d24 | 134 | va_start(args, fmt); |
8e9faf27 | 135 | format_packet(&buf, fmt, args); |
f5615d24 | 136 | va_end(args); |
8e9faf27 | 137 | write_or_die(fd, buf.buf, buf.len); |
f3a3214e LT |
138 | } |
139 | ||
f5615d24 SP |
140 | void packet_buf_write(struct strbuf *buf, const char *fmt, ...) |
141 | { | |
142 | va_list args; | |
f5615d24 SP |
143 | |
144 | va_start(args, fmt); | |
8e9faf27 | 145 | format_packet(buf, fmt, args); |
f5615d24 | 146 | va_end(args); |
f5615d24 SP |
147 | } |
148 | ||
4981fe75 JK |
149 | static int get_packet_data(int fd, char **src_buf, size_t *src_size, |
150 | void *dst, unsigned size, int options) | |
f3a3214e | 151 | { |
4981fe75 JK |
152 | ssize_t ret; |
153 | ||
154 | if (fd >= 0 && src_buf && *src_buf) | |
155 | die("BUG: multiple sources given to packet_read"); | |
156 | ||
157 | /* Read up to "size" bytes from our source, whatever it is. */ | |
158 | if (src_buf && *src_buf) { | |
159 | ret = size < *src_size ? size : *src_size; | |
160 | memcpy(dst, *src_buf, ret); | |
161 | *src_buf += ret; | |
162 | *src_size -= ret; | |
163 | } else { | |
164 | ret = read_in_full(fd, dst, size); | |
165 | if (ret < 0) | |
166 | die_errno("read error"); | |
167 | } | |
168 | ||
169 | /* And complain if we didn't get enough bytes to satisfy the read. */ | |
170 | if (ret < size) { | |
03809429 | 171 | if (options & PACKET_READ_GENTLE_ON_EOF) |
46284dd1 HV |
172 | return -1; |
173 | ||
c697ad14 | 174 | die("The remote end hung up unexpectedly"); |
46284dd1 HV |
175 | } |
176 | ||
177 | return ret; | |
f3a3214e LT |
178 | } |
179 | ||
f5615d24 | 180 | static int packet_length(const char *linelen) |
f3a3214e | 181 | { |
d2330973 RS |
182 | int val = hex2chr(linelen); |
183 | return (val < 0) ? val : (val << 8) | hex2chr(linelen + 2); | |
f5615d24 SP |
184 | } |
185 | ||
4981fe75 JK |
186 | int packet_read(int fd, char **src_buf, size_t *src_len, |
187 | char *buffer, unsigned size, int options) | |
f5615d24 | 188 | { |
46284dd1 | 189 | int len, ret; |
f5615d24 SP |
190 | char linelen[4]; |
191 | ||
4981fe75 | 192 | ret = get_packet_data(fd, src_buf, src_len, linelen, 4, options); |
03809429 | 193 | if (ret < 0) |
46284dd1 | 194 | return ret; |
f5615d24 SP |
195 | len = packet_length(linelen); |
196 | if (len < 0) | |
743c4b7b | 197 | die("protocol error: bad line length character: %.4s", linelen); |
bbc30f99 JK |
198 | if (!len) { |
199 | packet_trace("0000", 4, 0); | |
f3a3214e | 200 | return 0; |
bbc30f99 | 201 | } |
f3a3214e LT |
202 | len -= 4; |
203 | if (len >= size) | |
204 | die("protocol error: bad line length %d", len); | |
4981fe75 | 205 | ret = get_packet_data(fd, src_buf, src_len, buffer, len, options); |
03809429 | 206 | if (ret < 0) |
46284dd1 | 207 | return ret; |
819b929d JK |
208 | |
209 | if ((options & PACKET_READ_CHOMP_NEWLINE) && | |
210 | len && buffer[len-1] == '\n') | |
211 | len--; | |
212 | ||
f3a3214e | 213 | buffer[len] = 0; |
bbc30f99 | 214 | packet_trace(buffer, len, 0); |
f3a3214e LT |
215 | return len; |
216 | } | |
f5615d24 | 217 | |
4981fe75 JK |
218 | static char *packet_read_line_generic(int fd, |
219 | char **src, size_t *src_len, | |
220 | int *dst_len) | |
46284dd1 | 221 | { |
4981fe75 JK |
222 | int len = packet_read(fd, src, src_len, |
223 | packet_buffer, sizeof(packet_buffer), | |
74543a04 | 224 | PACKET_READ_CHOMP_NEWLINE); |
4981fe75 JK |
225 | if (dst_len) |
226 | *dst_len = len; | |
74543a04 | 227 | return len ? packet_buffer : NULL; |
46284dd1 HV |
228 | } |
229 | ||
4981fe75 | 230 | char *packet_read_line(int fd, int *len_p) |
f5615d24 | 231 | { |
4981fe75 JK |
232 | return packet_read_line_generic(fd, NULL, NULL, len_p); |
233 | } | |
f5615d24 | 234 | |
4981fe75 JK |
235 | char *packet_read_line_buf(char **src, size_t *src_len, int *dst_len) |
236 | { | |
237 | return packet_read_line_generic(-1, src, src_len, dst_len); | |
f5615d24 | 238 | } |