]>
Commit | Line | Data |
---|---|---|
f3a3214e LT |
1 | #include "cache.h" |
2 | #include "pkt-line.h" | |
3 | ||
74543a04 | 4 | char packet_buffer[LARGE_PACKET_MAX]; |
1e4cd68c | 5 | static const char *packet_trace_prefix = "git"; |
6aa30857 | 6 | static struct trace_key trace_packet = TRACE_KEY_INIT(PACKET); |
bbc30f99 JK |
7 | |
8 | void packet_trace_identity(const char *prog) | |
9 | { | |
10 | packet_trace_prefix = xstrdup(prog); | |
11 | } | |
12 | ||
13 | static void packet_trace(const char *buf, unsigned int len, int write) | |
14 | { | |
15 | int i; | |
16 | struct strbuf out; | |
17 | ||
6aa30857 | 18 | if (!trace_want(&trace_packet)) |
bbc30f99 JK |
19 | return; |
20 | ||
21 | /* +32 is just a guess for header + quoting */ | |
22 | strbuf_init(&out, len+32); | |
23 | ||
24 | strbuf_addf(&out, "packet: %12s%c ", | |
25 | packet_trace_prefix, write ? '>' : '<'); | |
26 | ||
59556548 CC |
27 | if ((len >= 4 && starts_with(buf, "PACK")) || |
28 | (len >= 5 && starts_with(buf+1, "PACK"))) { | |
bbc30f99 | 29 | strbuf_addstr(&out, "PACK ..."); |
6aa30857 | 30 | trace_disable(&trace_packet); |
bbc30f99 JK |
31 | } |
32 | else { | |
33 | /* XXX we should really handle printable utf8 */ | |
34 | for (i = 0; i < len; i++) { | |
35 | /* suppress newlines */ | |
36 | if (buf[i] == '\n') | |
37 | continue; | |
38 | if (buf[i] >= 0x20 && buf[i] <= 0x7e) | |
39 | strbuf_addch(&out, buf[i]); | |
40 | else | |
41 | strbuf_addf(&out, "\\%o", buf[i]); | |
42 | } | |
43 | } | |
44 | ||
45 | strbuf_addch(&out, '\n'); | |
6aa30857 | 46 | trace_strbuf(&trace_packet, &out); |
bbc30f99 JK |
47 | strbuf_release(&out); |
48 | } | |
49 | ||
f3a3214e LT |
50 | /* |
51 | * If we buffered things up above (we don't, but we should), | |
52 | * we'd flush it here | |
53 | */ | |
54 | void packet_flush(int fd) | |
55 | { | |
bbc30f99 | 56 | packet_trace("0000", 4, 1); |
cdf4fb8e | 57 | write_or_die(fd, "0000", 4); |
f3a3214e LT |
58 | } |
59 | ||
f5615d24 SP |
60 | void packet_buf_flush(struct strbuf *buf) |
61 | { | |
bbc30f99 | 62 | packet_trace("0000", 4, 1); |
f5615d24 SP |
63 | strbuf_add(buf, "0000", 4); |
64 | } | |
65 | ||
f3a3214e | 66 | #define hex(a) (hexchar[(a) & 15]) |
8e9faf27 | 67 | static void format_packet(struct strbuf *out, const char *fmt, va_list args) |
f3a3214e | 68 | { |
f3a3214e | 69 | static char hexchar[] = "0123456789abcdef"; |
8e9faf27 | 70 | size_t orig_len, n; |
f3a3214e | 71 | |
8e9faf27 JK |
72 | orig_len = out->len; |
73 | strbuf_addstr(out, "0000"); | |
74 | strbuf_vaddf(out, fmt, args); | |
75 | n = out->len - orig_len; | |
76 | ||
77 | if (n > LARGE_PACKET_MAX) | |
f3a3214e | 78 | die("protocol error: impossibly long line"); |
8e9faf27 JK |
79 | |
80 | out->buf[orig_len + 0] = hex(n >> 12); | |
81 | out->buf[orig_len + 1] = hex(n >> 8); | |
82 | out->buf[orig_len + 2] = hex(n >> 4); | |
83 | out->buf[orig_len + 3] = hex(n); | |
84 | packet_trace(out->buf + orig_len + 4, n - 4, 1); | |
f5615d24 SP |
85 | } |
86 | ||
87 | void packet_write(int fd, const char *fmt, ...) | |
88 | { | |
8e9faf27 | 89 | static struct strbuf buf = STRBUF_INIT; |
f5615d24 | 90 | va_list args; |
f5615d24 | 91 | |
8e9faf27 | 92 | strbuf_reset(&buf); |
f5615d24 | 93 | va_start(args, fmt); |
8e9faf27 | 94 | format_packet(&buf, fmt, args); |
f5615d24 | 95 | va_end(args); |
8e9faf27 | 96 | write_or_die(fd, buf.buf, buf.len); |
f3a3214e LT |
97 | } |
98 | ||
f5615d24 SP |
99 | void packet_buf_write(struct strbuf *buf, const char *fmt, ...) |
100 | { | |
101 | va_list args; | |
f5615d24 SP |
102 | |
103 | va_start(args, fmt); | |
8e9faf27 | 104 | format_packet(buf, fmt, args); |
f5615d24 | 105 | va_end(args); |
f5615d24 SP |
106 | } |
107 | ||
4981fe75 JK |
108 | static int get_packet_data(int fd, char **src_buf, size_t *src_size, |
109 | void *dst, unsigned size, int options) | |
f3a3214e | 110 | { |
4981fe75 JK |
111 | ssize_t ret; |
112 | ||
113 | if (fd >= 0 && src_buf && *src_buf) | |
114 | die("BUG: multiple sources given to packet_read"); | |
115 | ||
116 | /* Read up to "size" bytes from our source, whatever it is. */ | |
117 | if (src_buf && *src_buf) { | |
118 | ret = size < *src_size ? size : *src_size; | |
119 | memcpy(dst, *src_buf, ret); | |
120 | *src_buf += ret; | |
121 | *src_size -= ret; | |
122 | } else { | |
123 | ret = read_in_full(fd, dst, size); | |
124 | if (ret < 0) | |
125 | die_errno("read error"); | |
126 | } | |
127 | ||
128 | /* And complain if we didn't get enough bytes to satisfy the read. */ | |
129 | if (ret < size) { | |
03809429 | 130 | if (options & PACKET_READ_GENTLE_ON_EOF) |
46284dd1 HV |
131 | return -1; |
132 | ||
c697ad14 | 133 | die("The remote end hung up unexpectedly"); |
46284dd1 HV |
134 | } |
135 | ||
136 | return ret; | |
f3a3214e LT |
137 | } |
138 | ||
f5615d24 | 139 | static int packet_length(const char *linelen) |
f3a3214e LT |
140 | { |
141 | int n; | |
f5615d24 | 142 | int len = 0; |
f3a3214e | 143 | |
f3a3214e LT |
144 | for (n = 0; n < 4; n++) { |
145 | unsigned char c = linelen[n]; | |
146 | len <<= 4; | |
147 | if (c >= '0' && c <= '9') { | |
148 | len += c - '0'; | |
149 | continue; | |
150 | } | |
151 | if (c >= 'a' && c <= 'f') { | |
152 | len += c - 'a' + 10; | |
153 | continue; | |
154 | } | |
155 | if (c >= 'A' && c <= 'F') { | |
156 | len += c - 'A' + 10; | |
157 | continue; | |
158 | } | |
f5615d24 | 159 | return -1; |
f3a3214e | 160 | } |
f5615d24 SP |
161 | return len; |
162 | } | |
163 | ||
4981fe75 JK |
164 | int packet_read(int fd, char **src_buf, size_t *src_len, |
165 | char *buffer, unsigned size, int options) | |
f5615d24 | 166 | { |
46284dd1 | 167 | int len, ret; |
f5615d24 SP |
168 | char linelen[4]; |
169 | ||
4981fe75 | 170 | ret = get_packet_data(fd, src_buf, src_len, linelen, 4, options); |
03809429 | 171 | if (ret < 0) |
46284dd1 | 172 | return ret; |
f5615d24 SP |
173 | len = packet_length(linelen); |
174 | if (len < 0) | |
743c4b7b | 175 | die("protocol error: bad line length character: %.4s", linelen); |
bbc30f99 JK |
176 | if (!len) { |
177 | packet_trace("0000", 4, 0); | |
f3a3214e | 178 | return 0; |
bbc30f99 | 179 | } |
f3a3214e LT |
180 | len -= 4; |
181 | if (len >= size) | |
182 | die("protocol error: bad line length %d", len); | |
4981fe75 | 183 | ret = get_packet_data(fd, src_buf, src_len, buffer, len, options); |
03809429 | 184 | if (ret < 0) |
46284dd1 | 185 | return ret; |
819b929d JK |
186 | |
187 | if ((options & PACKET_READ_CHOMP_NEWLINE) && | |
188 | len && buffer[len-1] == '\n') | |
189 | len--; | |
190 | ||
f3a3214e | 191 | buffer[len] = 0; |
bbc30f99 | 192 | packet_trace(buffer, len, 0); |
f3a3214e LT |
193 | return len; |
194 | } | |
f5615d24 | 195 | |
4981fe75 JK |
196 | static char *packet_read_line_generic(int fd, |
197 | char **src, size_t *src_len, | |
198 | int *dst_len) | |
46284dd1 | 199 | { |
4981fe75 JK |
200 | int len = packet_read(fd, src, src_len, |
201 | packet_buffer, sizeof(packet_buffer), | |
74543a04 | 202 | PACKET_READ_CHOMP_NEWLINE); |
4981fe75 JK |
203 | if (dst_len) |
204 | *dst_len = len; | |
74543a04 | 205 | return len ? packet_buffer : NULL; |
46284dd1 HV |
206 | } |
207 | ||
4981fe75 | 208 | char *packet_read_line(int fd, int *len_p) |
f5615d24 | 209 | { |
4981fe75 JK |
210 | return packet_read_line_generic(fd, NULL, NULL, len_p); |
211 | } | |
f5615d24 | 212 | |
4981fe75 JK |
213 | char *packet_read_line_buf(char **src, size_t *src_len, int *dst_len) |
214 | { | |
215 | return packet_read_line_generic(-1, src, src_len, dst_len); | |
f5615d24 | 216 | } |