]>
Commit | Line | Data |
---|---|---|
ed10cb95 BW |
1 | #include "cache.h" |
2 | #include "repository.h" | |
3 | #include "config.h" | |
4 | #include "pkt-line.h" | |
5 | #include "version.h" | |
dbbcd44f | 6 | #include "strvec.h" |
72d0ea00 | 7 | #include "ls-refs.h" |
a2ba162c | 8 | #include "protocol-caps.h" |
ed10cb95 | 9 | #include "serve.h" |
3145ea95 | 10 | #include "upload-pack.h" |
ed10cb95 | 11 | |
6b5b6e42 JS |
12 | static int advertise_sid; |
13 | ||
72d0ea00 BW |
14 | static int always_advertise(struct repository *r, |
15 | struct strbuf *value) | |
16 | { | |
17 | return 1; | |
18 | } | |
19 | ||
ed10cb95 BW |
20 | static int agent_advertise(struct repository *r, |
21 | struct strbuf *value) | |
22 | { | |
23 | if (value) | |
24 | strbuf_addstr(value, git_user_agent_sanitized()); | |
25 | return 1; | |
26 | } | |
27 | ||
9de0dd36 | 28 | static int object_format_advertise(struct repository *r, |
29 | struct strbuf *value) | |
30 | { | |
31 | if (value) | |
32 | strbuf_addstr(value, r->hash_algo->name); | |
33 | return 1; | |
34 | } | |
35 | ||
6b5b6e42 JS |
36 | static int session_id_advertise(struct repository *r, struct strbuf *value) |
37 | { | |
38 | if (!advertise_sid) | |
39 | return 0; | |
40 | if (value) | |
41 | strbuf_addstr(value, trace2_session_id()); | |
42 | return 1; | |
43 | } | |
44 | ||
ed10cb95 BW |
45 | struct protocol_capability { |
46 | /* | |
47 | * The name of the capability. The server uses this name when | |
48 | * advertising this capability, and the client uses this name to | |
49 | * specify this capability. | |
50 | */ | |
51 | const char *name; | |
52 | ||
53 | /* | |
54 | * Function queried to see if a capability should be advertised. | |
55 | * Optionally a value can be specified by adding it to 'value'. | |
56 | * If a value is added to 'value', the server will advertise this | |
57 | * capability as "<name>=<value>" instead of "<name>". | |
58 | */ | |
59 | int (*advertise)(struct repository *r, struct strbuf *value); | |
60 | ||
61 | /* | |
62 | * Function called when a client requests the capability as a command. | |
63 | * The function will be provided the capabilities requested via 'keys' | |
64 | * as well as a struct packet_reader 'request' which the command should | |
65 | * use to read the command specific part of the request. Every command | |
66 | * MUST read until a flush packet is seen before sending a response. | |
67 | * | |
68 | * This field should be NULL for capabilities which are not commands. | |
69 | */ | |
70 | int (*command)(struct repository *r, | |
c972bf4c | 71 | struct strvec *keys, |
ed10cb95 BW |
72 | struct packet_reader *request); |
73 | }; | |
74 | ||
75 | static struct protocol_capability capabilities[] = { | |
76 | { "agent", agent_advertise, NULL }, | |
59e1205d | 77 | { "ls-refs", ls_refs_advertise, ls_refs }, |
685fbd32 | 78 | { "fetch", upload_pack_advertise, upload_pack_v2 }, |
ecc3e534 | 79 | { "server-option", always_advertise, NULL }, |
9de0dd36 | 80 | { "object-format", object_format_advertise, NULL }, |
6b5b6e42 | 81 | { "session-id", session_id_advertise, NULL }, |
a2ba162c | 82 | { "object-info", always_advertise, cap_object_info }, |
ed10cb95 BW |
83 | }; |
84 | ||
85 | static void advertise_capabilities(void) | |
86 | { | |
87 | struct strbuf capability = STRBUF_INIT; | |
88 | struct strbuf value = STRBUF_INIT; | |
89 | int i; | |
90 | ||
91 | for (i = 0; i < ARRAY_SIZE(capabilities); i++) { | |
92 | struct protocol_capability *c = &capabilities[i]; | |
93 | ||
94 | if (c->advertise(the_repository, &value)) { | |
95 | strbuf_addstr(&capability, c->name); | |
96 | ||
97 | if (value.len) { | |
98 | strbuf_addch(&capability, '='); | |
99 | strbuf_addbuf(&capability, &value); | |
100 | } | |
101 | ||
102 | strbuf_addch(&capability, '\n'); | |
103 | packet_write(1, capability.buf, capability.len); | |
104 | } | |
105 | ||
106 | strbuf_reset(&capability); | |
107 | strbuf_reset(&value); | |
108 | } | |
109 | ||
110 | packet_flush(1); | |
111 | strbuf_release(&capability); | |
112 | strbuf_release(&value); | |
113 | } | |
114 | ||
115 | static struct protocol_capability *get_capability(const char *key) | |
116 | { | |
117 | int i; | |
118 | ||
119 | if (!key) | |
120 | return NULL; | |
121 | ||
122 | for (i = 0; i < ARRAY_SIZE(capabilities); i++) { | |
123 | struct protocol_capability *c = &capabilities[i]; | |
124 | const char *out; | |
125 | if (skip_prefix(key, c->name, &out) && (!*out || *out == '=')) | |
126 | return c; | |
127 | } | |
128 | ||
129 | return NULL; | |
130 | } | |
131 | ||
132 | static int is_valid_capability(const char *key) | |
133 | { | |
134 | const struct protocol_capability *c = get_capability(key); | |
135 | ||
136 | return c && c->advertise(the_repository, NULL); | |
137 | } | |
138 | ||
139 | static int is_command(const char *key, struct protocol_capability **command) | |
140 | { | |
141 | const char *out; | |
142 | ||
143 | if (skip_prefix(key, "command=", &out)) { | |
144 | struct protocol_capability *cmd = get_capability(out); | |
145 | ||
146 | if (*command) | |
147 | die("command '%s' requested after already requesting command '%s'", | |
148 | out, (*command)->name); | |
149 | if (!cmd || !cmd->advertise(the_repository, NULL) || !cmd->command) | |
150 | die("invalid command '%s'", out); | |
151 | ||
152 | *command = cmd; | |
153 | return 1; | |
154 | } | |
155 | ||
156 | return 0; | |
157 | } | |
158 | ||
c972bf4c | 159 | int has_capability(const struct strvec *keys, const char *capability, |
ed10cb95 BW |
160 | const char **value) |
161 | { | |
162 | int i; | |
d70a9eb6 | 163 | for (i = 0; i < keys->nr; i++) { |
ed10cb95 | 164 | const char *out; |
d70a9eb6 | 165 | if (skip_prefix(keys->v[i], capability, &out) && |
ed10cb95 BW |
166 | (!*out || *out == '=')) { |
167 | if (value) { | |
168 | if (*out == '=') | |
169 | out++; | |
170 | *value = out; | |
171 | } | |
172 | return 1; | |
173 | } | |
174 | } | |
175 | ||
176 | return 0; | |
177 | } | |
178 | ||
c972bf4c | 179 | static void check_algorithm(struct repository *r, struct strvec *keys) |
9de0dd36 | 180 | { |
181 | int client = GIT_HASH_SHA1, server = hash_algo_by_ptr(r->hash_algo); | |
182 | const char *algo_name; | |
183 | ||
184 | if (has_capability(keys, "object-format", &algo_name)) { | |
185 | client = hash_algo_by_name(algo_name); | |
186 | if (client == GIT_HASH_UNKNOWN) | |
187 | die("unknown object format '%s'", algo_name); | |
188 | } | |
189 | ||
190 | if (client != server) | |
191 | die("mismatched object format: server %s; client %s\n", | |
192 | r->hash_algo->name, hash_algos[client].name); | |
193 | } | |
194 | ||
ed10cb95 BW |
195 | enum request_state { |
196 | PROCESS_REQUEST_KEYS, | |
197 | PROCESS_REQUEST_DONE, | |
198 | }; | |
199 | ||
200 | static int process_request(void) | |
201 | { | |
202 | enum request_state state = PROCESS_REQUEST_KEYS; | |
203 | struct packet_reader reader; | |
c972bf4c | 204 | struct strvec keys = STRVEC_INIT; |
ed10cb95 | 205 | struct protocol_capability *command = NULL; |
82959467 | 206 | const char *client_sid; |
ed10cb95 BW |
207 | |
208 | packet_reader_init(&reader, 0, NULL, 0, | |
209 | PACKET_READ_CHOMP_NEWLINE | | |
2d103c31 MS |
210 | PACKET_READ_GENTLE_ON_EOF | |
211 | PACKET_READ_DIE_ON_ERR_PACKET); | |
ed10cb95 BW |
212 | |
213 | /* | |
214 | * Check to see if the client closed their end before sending another | |
215 | * request. If so we can terminate the connection. | |
216 | */ | |
217 | if (packet_reader_peek(&reader) == PACKET_READ_EOF) | |
218 | return 1; | |
2d103c31 | 219 | reader.options &= ~PACKET_READ_GENTLE_ON_EOF; |
ed10cb95 BW |
220 | |
221 | while (state != PROCESS_REQUEST_DONE) { | |
222 | switch (packet_reader_peek(&reader)) { | |
223 | case PACKET_READ_EOF: | |
224 | BUG("Should have already died when seeing EOF"); | |
225 | case PACKET_READ_NORMAL: | |
226 | /* collect request; a sequence of keys and values */ | |
227 | if (is_command(reader.line, &command) || | |
228 | is_valid_capability(reader.line)) | |
c972bf4c | 229 | strvec_push(&keys, reader.line); |
ed10cb95 BW |
230 | else |
231 | die("unknown capability '%s'", reader.line); | |
232 | ||
233 | /* Consume the peeked line */ | |
234 | packet_reader_read(&reader); | |
235 | break; | |
236 | case PACKET_READ_FLUSH: | |
237 | /* | |
238 | * If no command and no keys were given then the client | |
239 | * wanted to terminate the connection. | |
240 | */ | |
d70a9eb6 | 241 | if (!keys.nr) |
ed10cb95 BW |
242 | return 1; |
243 | ||
244 | /* | |
245 | * The flush packet isn't consume here like it is in | |
246 | * the other parts of this switch statement. This is | |
247 | * so that the command can read the flush packet and | |
248 | * see the end of the request in the same way it would | |
249 | * if command specific arguments were provided after a | |
250 | * delim packet. | |
251 | */ | |
252 | state = PROCESS_REQUEST_DONE; | |
253 | break; | |
254 | case PACKET_READ_DELIM: | |
255 | /* Consume the peeked line */ | |
256 | packet_reader_read(&reader); | |
257 | ||
258 | state = PROCESS_REQUEST_DONE; | |
259 | break; | |
0181b600 DL |
260 | case PACKET_READ_RESPONSE_END: |
261 | BUG("unexpected stateless separator packet"); | |
ed10cb95 BW |
262 | } |
263 | } | |
264 | ||
265 | if (!command) | |
266 | die("no command requested"); | |
267 | ||
9de0dd36 | 268 | check_algorithm(the_repository, &keys); |
269 | ||
82959467 JS |
270 | if (has_capability(&keys, "session-id", &client_sid)) |
271 | trace2_data_string("transfer", NULL, "client-sid", client_sid); | |
272 | ||
ed10cb95 BW |
273 | command->command(the_repository, &keys, &reader); |
274 | ||
c972bf4c | 275 | strvec_clear(&keys); |
ed10cb95 BW |
276 | return 0; |
277 | } | |
278 | ||
279 | /* Main serve loop for protocol version 2 */ | |
280 | void serve(struct serve_options *options) | |
281 | { | |
6b5b6e42 JS |
282 | git_config_get_bool("transfer.advertisesid", &advertise_sid); |
283 | ||
ed10cb95 BW |
284 | if (options->advertise_capabilities || !options->stateless_rpc) { |
285 | /* serve by default supports v2 */ | |
286 | packet_write_fmt(1, "version 2\n"); | |
287 | ||
288 | advertise_capabilities(); | |
289 | /* | |
290 | * If only the list of capabilities was requested exit | |
291 | * immediately after advertising capabilities | |
292 | */ | |
293 | if (options->advertise_capabilities) | |
294 | return; | |
295 | } | |
296 | ||
297 | /* | |
298 | * If stateless-rpc was requested then exit after | |
299 | * a single request/response exchange | |
300 | */ | |
301 | if (options->stateless_rpc) { | |
302 | process_request(); | |
303 | } else { | |
304 | for (;;) | |
305 | if (process_request()) | |
306 | break; | |
307 | } | |
308 | } |