]>
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"; |
bbc30f99 JK |
6 | static const char trace_key[] = "GIT_TRACE_PACKET"; |
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 | ||
18 | if (!trace_want(trace_key)) | |
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 | ||
27 | if ((len >= 4 && !prefixcmp(buf, "PACK")) || | |
28 | (len >= 5 && !prefixcmp(buf+1, "PACK"))) { | |
29 | strbuf_addstr(&out, "PACK ..."); | |
30 | unsetenv(trace_key); | |
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'); | |
46 | trace_strbuf(trace_key, &out); | |
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]) |
f5615d24 SP |
67 | static char buffer[1000]; |
68 | static unsigned format_packet(const char *fmt, va_list args) | |
f3a3214e | 69 | { |
f3a3214e | 70 | static char hexchar[] = "0123456789abcdef"; |
f3a3214e LT |
71 | unsigned n; |
72 | ||
f3a3214e | 73 | n = vsnprintf(buffer + 4, sizeof(buffer) - 4, fmt, args); |
f3a3214e LT |
74 | if (n >= sizeof(buffer)-4) |
75 | die("protocol error: impossibly long line"); | |
76 | n += 4; | |
77 | buffer[0] = hex(n >> 12); | |
78 | buffer[1] = hex(n >> 8); | |
79 | buffer[2] = hex(n >> 4); | |
80 | buffer[3] = hex(n); | |
bbc30f99 | 81 | packet_trace(buffer+4, n-4, 1); |
f5615d24 SP |
82 | return n; |
83 | } | |
84 | ||
85 | void packet_write(int fd, const char *fmt, ...) | |
86 | { | |
87 | va_list args; | |
88 | unsigned n; | |
89 | ||
90 | va_start(args, fmt); | |
91 | n = format_packet(fmt, args); | |
92 | va_end(args); | |
cdf4fb8e | 93 | write_or_die(fd, buffer, n); |
f3a3214e LT |
94 | } |
95 | ||
f5615d24 SP |
96 | void packet_buf_write(struct strbuf *buf, const char *fmt, ...) |
97 | { | |
98 | va_list args; | |
99 | unsigned n; | |
100 | ||
101 | va_start(args, fmt); | |
102 | n = format_packet(fmt, args); | |
103 | va_end(args); | |
104 | strbuf_add(buf, buffer, n); | |
105 | } | |
106 | ||
03809429 | 107 | static int safe_read(int fd, void *buffer, unsigned size, int options) |
f3a3214e | 108 | { |
c697ad14 HO |
109 | ssize_t ret = read_in_full(fd, buffer, size); |
110 | if (ret < 0) | |
d824cbba | 111 | die_errno("read error"); |
46284dd1 | 112 | else if (ret < size) { |
03809429 | 113 | if (options & PACKET_READ_GENTLE_ON_EOF) |
46284dd1 HV |
114 | return -1; |
115 | ||
c697ad14 | 116 | die("The remote end hung up unexpectedly"); |
46284dd1 HV |
117 | } |
118 | ||
119 | return ret; | |
f3a3214e LT |
120 | } |
121 | ||
f5615d24 | 122 | static int packet_length(const char *linelen) |
f3a3214e LT |
123 | { |
124 | int n; | |
f5615d24 | 125 | int len = 0; |
f3a3214e | 126 | |
f3a3214e LT |
127 | for (n = 0; n < 4; n++) { |
128 | unsigned char c = linelen[n]; | |
129 | len <<= 4; | |
130 | if (c >= '0' && c <= '9') { | |
131 | len += c - '0'; | |
132 | continue; | |
133 | } | |
134 | if (c >= 'a' && c <= 'f') { | |
135 | len += c - 'a' + 10; | |
136 | continue; | |
137 | } | |
138 | if (c >= 'A' && c <= 'F') { | |
139 | len += c - 'A' + 10; | |
140 | continue; | |
141 | } | |
f5615d24 | 142 | return -1; |
f3a3214e | 143 | } |
f5615d24 SP |
144 | return len; |
145 | } | |
146 | ||
03809429 | 147 | int packet_read(int fd, char *buffer, unsigned size, int options) |
f5615d24 | 148 | { |
46284dd1 | 149 | int len, ret; |
f5615d24 SP |
150 | char linelen[4]; |
151 | ||
03809429 JK |
152 | ret = safe_read(fd, linelen, 4, options); |
153 | if (ret < 0) | |
46284dd1 | 154 | return ret; |
f5615d24 SP |
155 | len = packet_length(linelen); |
156 | if (len < 0) | |
743c4b7b | 157 | die("protocol error: bad line length character: %.4s", linelen); |
bbc30f99 JK |
158 | if (!len) { |
159 | packet_trace("0000", 4, 0); | |
f3a3214e | 160 | return 0; |
bbc30f99 | 161 | } |
f3a3214e LT |
162 | len -= 4; |
163 | if (len >= size) | |
164 | die("protocol error: bad line length %d", len); | |
03809429 JK |
165 | ret = safe_read(fd, buffer, len, options); |
166 | if (ret < 0) | |
46284dd1 | 167 | return ret; |
819b929d JK |
168 | |
169 | if ((options & PACKET_READ_CHOMP_NEWLINE) && | |
170 | len && buffer[len-1] == '\n') | |
171 | len--; | |
172 | ||
f3a3214e | 173 | buffer[len] = 0; |
bbc30f99 | 174 | packet_trace(buffer, len, 0); |
f3a3214e LT |
175 | return len; |
176 | } | |
f5615d24 | 177 | |
74543a04 | 178 | char *packet_read_line(int fd, int *len_p) |
46284dd1 | 179 | { |
74543a04 JK |
180 | int len = packet_read(fd, packet_buffer, sizeof(packet_buffer), |
181 | PACKET_READ_CHOMP_NEWLINE); | |
182 | if (len_p) | |
183 | *len_p = len; | |
184 | return len ? packet_buffer : NULL; | |
46284dd1 HV |
185 | } |
186 | ||
f5615d24 SP |
187 | int packet_get_line(struct strbuf *out, |
188 | char **src_buf, size_t *src_len) | |
189 | { | |
190 | int len; | |
191 | ||
192 | if (*src_len < 4) | |
193 | return -1; | |
194 | len = packet_length(*src_buf); | |
195 | if (len < 0) | |
196 | return -1; | |
197 | if (!len) { | |
198 | *src_buf += 4; | |
199 | *src_len -= 4; | |
bbc30f99 | 200 | packet_trace("0000", 4, 0); |
f5615d24 SP |
201 | return 0; |
202 | } | |
203 | if (*src_len < len) | |
204 | return -2; | |
205 | ||
206 | *src_buf += 4; | |
207 | *src_len -= 4; | |
208 | len -= 4; | |
209 | ||
210 | strbuf_add(out, *src_buf, len); | |
211 | *src_buf += len; | |
212 | *src_len -= len; | |
bbc30f99 | 213 | packet_trace(out->buf, out->len, 0); |
f5615d24 SP |
214 | return len; |
215 | } |