?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
push: avoid showing false negotiation errors
[git/gitster.git] / upload-pack.c
blob2537affa90762228a19d305be749f410d5afb5dc
1 #include "git-compat-util.h"
2 #include "config.h"
3 #include "environment.h"
4 #include "gettext.h"
5 #include "hex.h"
6 #include "refs.h"
7 #include "pkt-line.h"
8 #include "sideband.h"
9 #include "repository.h"
10 #include "object-store-ll.h"
11 #include "oid-array.h"
12 #include "object.h"
13 #include "commit.h"
14 #include "diff.h"
15 #include "revision.h"
16 #include "list-objects-filter-options.h"
17 #include "run-command.h"
18 #include "connect.h"
19 #include "sigchain.h"
20 #include "version.h"
21 #include "string-list.h"
22 #include "strvec.h"
23 #include "trace2.h"
24 #include "protocol.h"
25 #include "upload-pack.h"
26 #include "commit-graph.h"
27 #include "commit-reach.h"
28 #include "shallow.h"
29 #include "write-or-die.h"
30 #include "json-writer.h"
31
32 /* Remember to update object flag allocation in object.h */
33 #define THEY_HAVE (1u << 11)
34 #define OUR_REF (1u << 12)
35 #define WANTED (1u << 13)
36 #define COMMON_KNOWN (1u << 14)
37
38 #define SHALLOW (1u << 16)
39 #define NOT_SHALLOW (1u << 17)
40 #define CLIENT_SHALLOW (1u << 18)
41 #define HIDDEN_REF (1u << 19)
42
43 #define ALL_FLAGS (THEY_HAVE | OUR_REF | WANTED | COMMON_KNOWN | SHALLOW | \
44 NOT_SHALLOW | CLIENT_SHALLOW | HIDDEN_REF)
45
46 /* Enum for allowed unadvertised object request (UOR) */
47 enum allow_uor {
48 /* Allow specifying sha1 if it is a ref tip. */
49 ALLOW_TIP_SHA1 = 0x01,
50 /* Allow request of a sha1 if it is reachable from a ref (possibly hidden ref). */
51 ALLOW_REACHABLE_SHA1 = 0x02,
52 /* Allow request of any sha1. Implies ALLOW_TIP_SHA1 and ALLOW_REACHABLE_SHA1. */
53 ALLOW_ANY_SHA1 = 0x07
54 };
55
56 /*
57 * Please annotate, and if possible group together, fields used only
58 * for protocol v0 or only for protocol v2.
59 */
60 struct upload_pack_data {
61 struct string_list symref; /* v0 only */
62 struct object_array want_obj;
63 struct object_array have_obj;
64 struct oid_array haves; /* v2 only */
65 struct string_list wanted_refs; /* v2 only */
66 struct strvec hidden_refs;
67
68 struct object_array shallows;
69 struct string_list deepen_not;
70 struct object_array extra_edge_obj;
71 int depth;
72 timestamp_t deepen_since;
73 int deepen_rev_list;
74 int deepen_relative;
75 int keepalive;
76 int shallow_nr;
77 timestamp_t oldest_have;
78
79 unsigned int timeout; /* v0 only */
80 enum {
81 NO_MULTI_ACK = 0,
82 MULTI_ACK = 1,
83 MULTI_ACK_DETAILED = 2
84 } multi_ack; /* v0 only */
85
86 /* 0 for no sideband, otherwise DEFAULT_PACKET_MAX or LARGE_PACKET_MAX */
87 int use_sideband;
88
89 struct string_list uri_protocols;
90 enum allow_uor allow_uor;
91
92 struct list_objects_filter_options filter_options;
93 struct string_list allowed_filters;
94
95 struct packet_writer writer;
96
97 const char *pack_objects_hook;
98
99 unsigned stateless_rpc : 1; /* v0 only */
100 unsigned no_done : 1; /* v0 only */
101 unsigned daemon_mode : 1; /* v0 only */
102 unsigned filter_capability_requested : 1; /* v0 only */
103
104 unsigned use_thin_pack : 1;
105 unsigned use_ofs_delta : 1;
106 unsigned no_progress : 1;
107 unsigned use_include_tag : 1;
108 unsigned wait_for_done : 1;
109 unsigned allow_filter : 1;
110 unsigned allow_filter_fallback : 1;
111 unsigned long tree_filter_max_depth;
112
113 unsigned done : 1; /* v2 only */
114 unsigned allow_ref_in_want : 1; /* v2 only */
115 unsigned allow_sideband_all : 1; /* v2 only */
116 unsigned advertise_sid : 1;
117 unsigned sent_capabilities : 1;
118 };
119
120 static void upload_pack_data_init(struct upload_pack_data *data)
121 {
122 struct string_list symref = STRING_LIST_INIT_DUP;
123 struct string_list wanted_refs = STRING_LIST_INIT_DUP;
124 struct strvec hidden_refs = STRVEC_INIT;
125 struct object_array want_obj = OBJECT_ARRAY_INIT;
126 struct object_array have_obj = OBJECT_ARRAY_INIT;
127 struct oid_array haves = OID_ARRAY_INIT;
128 struct object_array shallows = OBJECT_ARRAY_INIT;
129 struct string_list deepen_not = STRING_LIST_INIT_DUP;
130 struct string_list uri_protocols = STRING_LIST_INIT_DUP;
131 struct object_array extra_edge_obj = OBJECT_ARRAY_INIT;
132 struct string_list allowed_filters = STRING_LIST_INIT_DUP;
133
134 memset(data, 0, sizeof(*data));
135 data->symref = symref;
136 data->wanted_refs = wanted_refs;
137 data->hidden_refs = hidden_refs;
138 data->want_obj = want_obj;
139 data->have_obj = have_obj;
140 data->haves = haves;
141 data->shallows = shallows;
142 data->deepen_not = deepen_not;
143 data->uri_protocols = uri_protocols;
144 data->extra_edge_obj = extra_edge_obj;
145 data->allowed_filters = allowed_filters;
146 data->allow_filter_fallback = 1;
147 data->tree_filter_max_depth = ULONG_MAX;
148 packet_writer_init(&data->writer, 1);
149 list_objects_filter_init(&data->filter_options);
150
151 data->keepalive = 5;
152 data->advertise_sid = 0;
153 }
154
155 static void upload_pack_data_clear(struct upload_pack_data *data)
156 {
157 string_list_clear(&data->symref, 1);
158 string_list_clear(&data->wanted_refs, 1);
159 strvec_clear(&data->hidden_refs);
160 object_array_clear(&data->want_obj);
161 object_array_clear(&data->have_obj);
162 oid_array_clear(&data->haves);
163 object_array_clear(&data->shallows);
164 string_list_clear(&data->deepen_not, 0);
165 object_array_clear(&data->extra_edge_obj);
166 list_objects_filter_release(&data->filter_options);
167 string_list_clear(&data->allowed_filters, 0);
168
169 free((char *)data->pack_objects_hook);
170 }
171
172 static void reset_timeout(unsigned int timeout)
173 {
174 alarm(timeout);
175 }
176
177 static void send_client_data(int fd, const char *data, ssize_t sz,
178 int use_sideband)
179 {
180 if (use_sideband) {
181 send_sideband(1, fd, data, sz, use_sideband);
182 return;
183 }
184 if (fd == 3)
185 /* emergency quit */
186 fd = 2;
187 if (fd == 2) {
188 /* XXX: are we happy to lose stuff here? */
189 xwrite(fd, data, sz);
190 return;
191 }
192 write_or_die(fd, data, sz);
193 }
194
195 static int write_one_shallow(const struct commit_graft *graft, void *cb_data)
196 {
197 FILE *fp = cb_data;
198 if (graft->nr_parent == -1)
199 fprintf(fp, "--shallow %s\n", oid_to_hex(&graft->oid));
200 return 0;
201 }
202
203 struct output_state {
204 /*
205 * We do writes no bigger than LARGE_PACKET_DATA_MAX - 1, because with
206 * sideband-64k the band designator takes up 1 byte of space. Because
207 * relay_pack_data keeps the last byte to itself, we make the buffer 1
208 * byte bigger than the intended maximum write size.
209 */
210 char buffer[(LARGE_PACKET_DATA_MAX - 1) + 1];
211 int used;
212 unsigned packfile_uris_started : 1;
213 unsigned packfile_started : 1;
214 };
215
216 static int relay_pack_data(int pack_objects_out, struct output_state *os,
217 int use_sideband, int write_packfile_line)
218 {
219 /*
220 * We keep the last byte to ourselves
221 * in case we detect broken rev-list, so that we
222 * can leave the stream corrupted. This is
223 * unfortunate -- unpack-objects would happily
224 * accept a valid packdata with trailing garbage,
225 * so appending garbage after we pass all the
226 * pack data is not good enough to signal
227 * breakage to downstream.
228 */
229 ssize_t readsz;
230
231 readsz = xread(pack_objects_out, os->buffer + os->used,
232 sizeof(os->buffer) - os->used);
233 if (readsz < 0) {
234 return readsz;
235 }
236 os->used += readsz;
237
238 while (!os->packfile_started) {
239 char *p;
240 if (os->used >= 4 && !memcmp(os->buffer, "PACK", 4)) {
241 os->packfile_started = 1;
242 if (write_packfile_line) {
243 if (os->packfile_uris_started)
244 packet_delim(1);
245 packet_write_fmt(1, "\1packfile\n");
246 }
247 break;
248 }
249 if ((p = memchr(os->buffer, '\n', os->used))) {
250 if (!os->packfile_uris_started) {
251 os->packfile_uris_started = 1;
252 if (!write_packfile_line)
253 BUG("packfile_uris requires sideband-all");
254 packet_write_fmt(1, "\1packfile-uris\n");
255 }
256 *p = '\0';
257 packet_write_fmt(1, "\1%s\n", os->buffer);
258
259 os->used -= p - os->buffer + 1;
260 memmove(os->buffer, p + 1, os->used);
261 } else {
262 /*
263 * Incomplete line.
264 */
265 return readsz;
266 }
267 }
268
269 if (os->used > 1) {
270 send_client_data(1, os->buffer, os->used - 1, use_sideband);
271 os->buffer[0] = os->buffer[os->used - 1];
272 os->used = 1;
273 } else {
274 send_client_data(1, os->buffer, os->used, use_sideband);
275 os->used = 0;
276 }
277
278 return readsz;
279 }
280
281 static void create_pack_file(struct upload_pack_data *pack_data,
282 const struct string_list *uri_protocols)
283 {
284 struct child_process pack_objects = CHILD_PROCESS_INIT;
285 struct output_state *output_state = xcalloc(1, sizeof(struct output_state));
286 char progress[128];
287 char abort_msg[] = "aborting due to possible repository "
288 "corruption on the remote side.";
289 ssize_t sz;
290 int i;
291 FILE *pipe_fd;
292
293 if (!pack_data->pack_objects_hook)
294 pack_objects.git_cmd = 1;
295 else {
296 strvec_push(&pack_objects.args, pack_data->pack_objects_hook);
297 strvec_push(&pack_objects.args, "git");
298 pack_objects.use_shell = 1;
299 }
300
301 if (pack_data->shallow_nr) {
302 strvec_push(&pack_objects.args, "--shallow-file");
303 strvec_push(&pack_objects.args, "");
304 }
305 strvec_push(&pack_objects.args, "pack-objects");
306 strvec_push(&pack_objects.args, "--revs");
307 if (pack_data->use_thin_pack)
308 strvec_push(&pack_objects.args, "--thin");
309
310 strvec_push(&pack_objects.args, "--stdout");
311 if (pack_data->shallow_nr)
312 strvec_push(&pack_objects.args, "--shallow");
313 if (!pack_data->no_progress)
314 strvec_push(&pack_objects.args, "--progress");
315 if (pack_data->use_ofs_delta)
316 strvec_push(&pack_objects.args, "--delta-base-offset");
317 if (pack_data->use_include_tag)
318 strvec_push(&pack_objects.args, "--include-tag");
319 if (pack_data->filter_options.choice) {
320 const char *spec =
321 expand_list_objects_filter_spec(&pack_data->filter_options);
322 strvec_pushf(&pack_objects.args, "--filter=%s", spec);
323 }
324 if (uri_protocols) {
325 for (i = 0; i < uri_protocols->nr; i++)
326 strvec_pushf(&pack_objects.args, "--uri-protocol=%s",
327 uri_protocols->items[i].string);
328 }
329
330 pack_objects.in = -1;
331 pack_objects.out = -1;
332 pack_objects.err = -1;
333 pack_objects.clean_on_exit = 1;
334
335 if (start_command(&pack_objects))
336 die("git upload-pack: unable to fork git-pack-objects");
337
338 pipe_fd = xfdopen(pack_objects.in, "w");
339
340 if (pack_data->shallow_nr)
341 for_each_commit_graft(write_one_shallow, pipe_fd);
342
343 for (i = 0; i < pack_data->want_obj.nr; i++)
344 fprintf(pipe_fd, "%s\n",
345 oid_to_hex(&pack_data->want_obj.objects[i].item->oid));
346 fprintf(pipe_fd, "--not\n");
347 for (i = 0; i < pack_data->have_obj.nr; i++)
348 fprintf(pipe_fd, "%s\n",
349 oid_to_hex(&pack_data->have_obj.objects[i].item->oid));
350 for (i = 0; i < pack_data->extra_edge_obj.nr; i++)
351 fprintf(pipe_fd, "%s\n",
352 oid_to_hex(&pack_data->extra_edge_obj.objects[i].item->oid));
353 fprintf(pipe_fd, "\n");
354 fflush(pipe_fd);
355 fclose(pipe_fd);
356
357 /* We read from pack_objects.err to capture stderr output for
358 * progress bar, and pack_objects.out to capture the pack data.
359 */
360
361 while (1) {
362 struct pollfd pfd[2];
363 int pe, pu, pollsize, polltimeout;
364 int ret;
365
366 reset_timeout(pack_data->timeout);
367
368 pollsize = 0;
369 pe = pu = -1;
370
371 if (0 <= pack_objects.out) {
372 pfd[pollsize].fd = pack_objects.out;
373 pfd[pollsize].events = POLLIN;
374 pu = pollsize;
375 pollsize++;
376 }
377 if (0 <= pack_objects.err) {
378 pfd[pollsize].fd = pack_objects.err;
379 pfd[pollsize].events = POLLIN;
380 pe = pollsize;
381 pollsize++;
382 }
383
384 if (!pollsize)
385 break;
386
387 polltimeout = pack_data->keepalive < 0
388 ? -1
389 : 1000 * pack_data->keepalive;
390
391 ret = poll(pfd, pollsize, polltimeout);
392
393 if (ret < 0) {
394 if (errno != EINTR) {
395 error_errno("poll failed, resuming");
396 sleep(1);
397 }
398 continue;
399 }
400 if (0 <= pe && (pfd[pe].revents & (POLLIN|POLLHUP))) {
401 /* Status ready; we ship that in the side-band
402 * or dump to the standard error.
403 */
404 sz = xread(pack_objects.err, progress,
405 sizeof(progress));
406 if (0 < sz)
407 send_client_data(2, progress, sz,
408 pack_data->use_sideband);
409 else if (sz == 0) {
410 close(pack_objects.err);
411 pack_objects.err = -1;
412 }
413 else
414 goto fail;
415 /* give priority to status messages */
416 continue;
417 }
418 if (0 <= pu && (pfd[pu].revents & (POLLIN|POLLHUP))) {
419 int result = relay_pack_data(pack_objects.out,
420 output_state,
421 pack_data->use_sideband,
422 !!uri_protocols);
423
424 if (result == 0) {
425 close(pack_objects.out);
426 pack_objects.out = -1;
427 } else if (result < 0) {
428 goto fail;
429 }
430 }
431
432 /*
433 * We hit the keepalive timeout without saying anything; send
434 * an empty message on the data sideband just to let the other
435 * side know we're still working on it, but don't have any data
436 * yet.
437 *
438 * If we don't have a sideband channel, there's no room in the
439 * protocol to say anything, so those clients are just out of
440 * luck.
441 */
442 if (!ret && pack_data->use_sideband) {
443 static const char buf[] = "0005\1";
444 write_or_die(1, buf, 5);
445 }
446 }
447
448 if (finish_command(&pack_objects)) {
449 error("git upload-pack: git-pack-objects died with error.");
450 goto fail;
451 }
452
453 /* flush the data */
454 if (output_state->used > 0) {
455 send_client_data(1, output_state->buffer, output_state->used,
456 pack_data->use_sideband);
457 fprintf(stderr, "flushed.\n");
458 }
459 free(output_state);
460 if (pack_data->use_sideband)
461 packet_flush(1);
462 return;
463
464 fail:
465 free(output_state);
466 send_client_data(3, abort_msg, sizeof(abort_msg),
467 pack_data->use_sideband);
468 die("git upload-pack: %s", abort_msg);
469 }
470
471 static int do_got_oid(struct upload_pack_data *data, const struct object_id *oid)
472 {
473 int we_knew_they_have = 0;
474 struct object *o = parse_object(the_repository, oid);
475
476 if (!o)
477 die("oops (%s)", oid_to_hex(oid));
478 if (o->type == OBJ_COMMIT) {
479 struct commit_list *parents;
480 struct commit *commit = (struct commit *)o;
481 if (o->flags & THEY_HAVE)
482 we_knew_they_have = 1;
483 else
484 o->flags |= THEY_HAVE;
485 if (!data->oldest_have || (commit->date < data->oldest_have))
486 data->oldest_have = commit->date;
487 for (parents = commit->parents;
488 parents;
489 parents = parents->next)
490 parents->item->object.flags |= THEY_HAVE;
491 }
492 if (!we_knew_they_have) {
493 add_object_array(o, NULL, &data->have_obj);
494 return 1;
495 }
496 return 0;
497 }
498
499 static int got_oid(struct upload_pack_data *data,
500 const char *hex, struct object_id *oid)
501 {
502 if (get_oid_hex(hex, oid))
503 die("git upload-pack: expected SHA1 object, got '%s'", hex);
504 if (!repo_has_object_file_with_flags(the_repository, oid,
505 OBJECT_INFO_QUICK | OBJECT_INFO_SKIP_FETCH_OBJECT))
506 return -1;
507 return do_got_oid(data, oid);
508 }
509
510 static int ok_to_give_up(struct upload_pack_data *data)
511 {
512 timestamp_t min_generation = GENERATION_NUMBER_ZERO;
513
514 if (!data->have_obj.nr)
515 return 0;
516
517 return can_all_from_reach_with_flag(&data->want_obj, THEY_HAVE,
518 COMMON_KNOWN, data->oldest_have,
519 min_generation);
520 }
521
522 static int get_common_commits(struct upload_pack_data *data,
523 struct packet_reader *reader)
524 {
525 struct object_id oid;
526 char last_hex[GIT_MAX_HEXSZ + 1];
527 int got_common = 0;
528 int got_other = 0;
529 int sent_ready = 0;
530
531 save_commit_buffer = 0;
532
533 for (;;) {
534 const char *arg;
535
536 reset_timeout(data->timeout);
537
538 if (packet_reader_read(reader) != PACKET_READ_NORMAL) {
539 if (data->multi_ack == MULTI_ACK_DETAILED
540 && got_common
541 && !got_other
542 && ok_to_give_up(data)) {
543 sent_ready = 1;
544 packet_write_fmt(1, "ACK %s ready\n", last_hex);
545 }
546 if (data->have_obj.nr == 0 || data->multi_ack)
547 packet_write_fmt(1, "NAK\n");
548
549 if (data->no_done && sent_ready) {
550 packet_write_fmt(1, "ACK %s\n", last_hex);
551 return 0;
552 }
553 if (data->stateless_rpc)
554 exit(0);
555 got_common = 0;
556 got_other = 0;
557 continue;
558 }
559 if (skip_prefix(reader->line, "have ", &arg)) {
560 switch (got_oid(data, arg, &oid)) {
561 case -1: /* they have what we do not */
562 got_other = 1;
563 if (data->multi_ack
564 && ok_to_give_up(data)) {
565 const char *hex = oid_to_hex(&oid);
566 if (data->multi_ack == MULTI_ACK_DETAILED) {
567 sent_ready = 1;
568 packet_write_fmt(1, "ACK %s ready\n", hex);
569 } else
570 packet_write_fmt(1, "ACK %s continue\n", hex);
571 }
572 break;
573 default:
574 got_common = 1;
575 oid_to_hex_r(last_hex, &oid);
576 if (data->multi_ack == MULTI_ACK_DETAILED)
577 packet_write_fmt(1, "ACK %s common\n", last_hex);
578 else if (data->multi_ack)
579 packet_write_fmt(1, "ACK %s continue\n", last_hex);
580 else if (data->have_obj.nr == 1)
581 packet_write_fmt(1, "ACK %s\n", last_hex);
582 break;
583 }
584 continue;
585 }
586 if (!strcmp(reader->line, "done")) {
587 if (data->have_obj.nr > 0) {
588 if (data->multi_ack)
589 packet_write_fmt(1, "ACK %s\n", last_hex);
590 return 0;
591 }
592 packet_write_fmt(1, "NAK\n");
593 return -1;
594 }
595 die("git upload-pack: expected SHA1 list, got '%s'", reader->line);
596 }
597 }
598
599 static int allow_hidden_refs(enum allow_uor allow_uor)
600 {
601 if ((allow_uor & ALLOW_ANY_SHA1) == ALLOW_ANY_SHA1)
602 return 1;
603 return !(allow_uor & (ALLOW_TIP_SHA1 | ALLOW_REACHABLE_SHA1));
604 }
605
606 static void for_each_namespaced_ref_1(each_ref_fn fn,
607 struct upload_pack_data *data)
608 {
609 const char **excludes = NULL;
610 /*
611 * If `data->allow_uor` allows fetching hidden refs, we need to
612 * mark all references (including hidden ones), to check in
613 * `is_our_ref()` below.
614 *
615 * Otherwise, we only care about whether each reference's object
616 * has the OUR_REF bit set or not, so do not need to visit
617 * hidden references.
618 */
619 if (allow_hidden_refs(data->allow_uor))
620 excludes = hidden_refs_to_excludes(&data->hidden_refs);
621
622 for_each_namespaced_ref(excludes, fn, data);
623 }
624
625
626 static int is_our_ref(struct object *o, enum allow_uor allow_uor)
627 {
628 return o->flags & ((allow_hidden_refs(allow_uor) ? 0 : HIDDEN_REF) | OUR_REF);
629 }
630
631 /*
632 * on successful case, it's up to the caller to close cmd->out
633 */
634 static int do_reachable_revlist(struct child_process *cmd,
635 struct object_array *src,
636 struct object_array *reachable,
637 enum allow_uor allow_uor)
638 {
639 struct object *o;
640 FILE *cmd_in = NULL;
641 int i;
642
643 strvec_pushl(&cmd->args, "rev-list", "--stdin", NULL);
644 cmd->git_cmd = 1;
645 cmd->no_stderr = 1;
646 cmd->in = -1;
647 cmd->out = -1;
648
649 /*
650 * If the next rev-list --stdin encounters an unknown commit,
651 * it terminates, which will cause SIGPIPE in the write loop
652 * below.
653 */
654 sigchain_push(SIGPIPE, SIG_IGN);
655
656 if (start_command(cmd))
657 goto error;
658
659 cmd_in = xfdopen(cmd->in, "w");
660
661 for (i = get_max_object_index(); 0 < i; ) {
662 o = get_indexed_object(--i);
663 if (!o)
664 continue;
665 if (reachable && o->type == OBJ_COMMIT)
666 o->flags &= ~TMP_MARK;
667 if (!is_our_ref(o, allow_uor))
668 continue;
669 if (fprintf(cmd_in, "^%s\n", oid_to_hex(&o->oid)) < 0)
670 goto error;
671 }
672 for (i = 0; i < src->nr; i++) {
673 o = src->objects[i].item;
674 if (is_our_ref(o, allow_uor)) {
675 if (reachable)
676 add_object_array(o, NULL, reachable);
677 continue;
678 }
679 if (reachable && o->type == OBJ_COMMIT)
680 o->flags |= TMP_MARK;
681 if (fprintf(cmd_in, "%s\n", oid_to_hex(&o->oid)) < 0)
682 goto error;
683 }
684 if (ferror(cmd_in) || fflush(cmd_in))
685 goto error;
686 fclose(cmd_in);
687 cmd->in = -1;
688 sigchain_pop(SIGPIPE);
689
690 return 0;
691
692 error:
693 sigchain_pop(SIGPIPE);
694
695 if (cmd_in)
696 fclose(cmd_in);
697 if (cmd->out >= 0)
698 close(cmd->out);
699 return -1;
700 }
701
702 static int get_reachable_list(struct upload_pack_data *data,
703 struct object_array *reachable)
704 {
705 struct child_process cmd = CHILD_PROCESS_INIT;
706 int i;
707 struct object *o;
708 char namebuf[GIT_MAX_HEXSZ + 2]; /* ^ + hash + LF */
709 const unsigned hexsz = the_hash_algo->hexsz;
710
711 if (do_reachable_revlist(&cmd, &data->shallows, reachable,
712 data->allow_uor) < 0)
713 return -1;
714
715 while ((i = read_in_full(cmd.out, namebuf, hexsz + 1)) == hexsz + 1) {
716 struct object_id oid;
717 const char *p;
718
719 if (parse_oid_hex(namebuf, &oid, &p) || *p != '\n')
720 break;
721
722 o = lookup_object(the_repository, &oid);
723 if (o && o->type == OBJ_COMMIT) {
724 o->flags &= ~TMP_MARK;
725 }
726 }
727 for (i = get_max_object_index(); 0 < i; i--) {
728 o = get_indexed_object(i - 1);
729 if (o && o->type == OBJ_COMMIT &&
730 (o->flags & TMP_MARK)) {
731 add_object_array(o, NULL, reachable);
732 o->flags &= ~TMP_MARK;
733 }
734 }
735 close(cmd.out);
736
737 if (finish_command(&cmd))
738 return -1;
739
740 return 0;
741 }
742
743 static int has_unreachable(struct object_array *src, enum allow_uor allow_uor)
744 {
745 struct child_process cmd = CHILD_PROCESS_INIT;
746 char buf[1];
747 int i;
748
749 if (do_reachable_revlist(&cmd, src, NULL, allow_uor) < 0)
750 return 1;
751
752 /*
753 * The commits out of the rev-list are not ancestors of
754 * our ref.
755 */
756 i = read_in_full(cmd.out, buf, 1);
757 if (i)
758 goto error;
759 close(cmd.out);
760 cmd.out = -1;
761
762 /*
763 * rev-list may have died by encountering a bad commit
764 * in the history, in which case we do want to bail out
765 * even when it showed no commit.
766 */
767 if (finish_command(&cmd))
768 goto error;
769
770 /* All the non-tip ones are ancestors of what we advertised */
771 return 0;
772
773 error:
774 if (cmd.out >= 0)
775 close(cmd.out);
776 return 1;
777 }
778
779 static void check_non_tip(struct upload_pack_data *data)
780 {
781 int i;
782
783 /*
784 * In the normal in-process case without
785 * uploadpack.allowReachableSHA1InWant,
786 * non-tip requests can never happen.
787 */
788 if (!data->stateless_rpc && !(data->allow_uor & ALLOW_REACHABLE_SHA1))
789 goto error;
790 if (!has_unreachable(&data->want_obj, data->allow_uor))
791 /* All the non-tip ones are ancestors of what we advertised */
792 return;
793
794 error:
795 /* Pick one of them (we know there at least is one) */
796 for (i = 0; i < data->want_obj.nr; i++) {
797 struct object *o = data->want_obj.objects[i].item;
798 if (!is_our_ref(o, data->allow_uor)) {
799 error("git upload-pack: not our ref %s",
800 oid_to_hex(&o->oid));
801 packet_writer_error(&data->writer,
802 "upload-pack: not our ref %s",
803 oid_to_hex(&o->oid));
804 exit(128);
805 }
806 }
807 }
808
809 static void send_shallow(struct upload_pack_data *data,
810 struct commit_list *result)
811 {
812 while (result) {
813 struct object *object = &result->item->object;
814 if (!(object->flags & (CLIENT_SHALLOW|NOT_SHALLOW))) {
815 packet_writer_write(&data->writer, "shallow %s",
816 oid_to_hex(&object->oid));
817 register_shallow(the_repository, &object->oid);
818 data->shallow_nr++;
819 }
820 result = result->next;
821 }
822 }
823
824 static void send_unshallow(struct upload_pack_data *data)
825 {
826 int i;
827
828 for (i = 0; i < data->shallows.nr; i++) {
829 struct object *object = data->shallows.objects[i].item;
830 if (object->flags & NOT_SHALLOW) {
831 struct commit_list *parents;
832 packet_writer_write(&data->writer, "unshallow %s",
833 oid_to_hex(&object->oid));
834 object->flags &= ~CLIENT_SHALLOW;
835 /*
836 * We want to _register_ "object" as shallow, but we
837 * also need to traverse object's parents to deepen a
838 * shallow clone. Unregister it for now so we can
839 * parse and add the parents to the want list, then
840 * re-register it.
841 */
842 unregister_shallow(&object->oid);
843 object->parsed = 0;
844 parse_commit_or_die((struct commit *)object);
845 parents = ((struct commit *)object)->parents;
846 while (parents) {
847 add_object_array(&parents->item->object,
848 NULL, &data->want_obj);
849 parents = parents->next;
850 }
851 add_object_array(object, NULL, &data->extra_edge_obj);
852 }
853 /* make sure commit traversal conforms to client */
854 register_shallow(the_repository, &object->oid);
855 }
856 }
857
858 static int check_ref(const char *refname_full, const struct object_id *oid,
859 int flag, void *cb_data);
860 static void deepen(struct upload_pack_data *data, int depth)
861 {
862 if (depth == INFINITE_DEPTH && !is_repository_shallow(the_repository)) {
863 int i;
864
865 for (i = 0; i < data->shallows.nr; i++) {
866 struct object *object = data->shallows.objects[i].item;
867 object->flags |= NOT_SHALLOW;
868 }
869 } else if (data->deepen_relative) {
870 struct object_array reachable_shallows = OBJECT_ARRAY_INIT;
871 struct commit_list *result;
872
873 /*
874 * Checking for reachable shallows requires that our refs be
875 * marked with OUR_REF.
876 */
877 head_ref_namespaced(check_ref, data);
878 for_each_namespaced_ref_1(check_ref, data);
879
880 get_reachable_list(data, &reachable_shallows);
881 result = get_shallow_commits(&reachable_shallows,
882 depth + 1,
883 SHALLOW, NOT_SHALLOW);
884 send_shallow(data, result);
885 free_commit_list(result);
886 object_array_clear(&reachable_shallows);
887 } else {
888 struct commit_list *result;
889
890 result = get_shallow_commits(&data->want_obj, depth,
891 SHALLOW, NOT_SHALLOW);
892 send_shallow(data, result);
893 free_commit_list(result);
894 }
895
896 send_unshallow(data);
897 }
898
899 static void deepen_by_rev_list(struct upload_pack_data *data,
900 int ac,
901 const char **av)
902 {
903 struct commit_list *result;
904
905 disable_commit_graph(the_repository);
906 result = get_shallow_commits_by_rev_list(ac, av, SHALLOW, NOT_SHALLOW);
907 send_shallow(data, result);
908 free_commit_list(result);
909 send_unshallow(data);
910 }
911
912 /* Returns 1 if a shallow list is sent or 0 otherwise */
913 static int send_shallow_list(struct upload_pack_data *data)
914 {
915 int ret = 0;
916
917 if (data->depth > 0 && data->deepen_rev_list)
918 die("git upload-pack: deepen and deepen-since (or deepen-not) cannot be used together");
919 if (data->depth > 0) {
920 deepen(data, data->depth);
921 ret = 1;
922 } else if (data->deepen_rev_list) {
923 struct strvec av = STRVEC_INIT;
924 int i;
925
926 strvec_push(&av, "rev-list");
927 if (data->deepen_since)
928 strvec_pushf(&av, "--max-age=%"PRItime, data->deepen_since);
929 if (data->deepen_not.nr) {
930 strvec_push(&av, "--not");
931 for (i = 0; i < data->deepen_not.nr; i++) {
932 struct string_list_item *s = data->deepen_not.items + i;
933 strvec_push(&av, s->string);
934 }
935 strvec_push(&av, "--not");
936 }
937 for (i = 0; i < data->want_obj.nr; i++) {
938 struct object *o = data->want_obj.objects[i].item;
939 strvec_push(&av, oid_to_hex(&o->oid));
940 }
941 deepen_by_rev_list(data, av.nr, av.v);
942 strvec_clear(&av);
943 ret = 1;
944 } else {
945 if (data->shallows.nr > 0) {
946 int i;
947 for (i = 0; i < data->shallows.nr; i++)
948 register_shallow(the_repository,
949 &data->shallows.objects[i].item->oid);
950 }
951 }
952
953 data->shallow_nr += data->shallows.nr;
954 return ret;
955 }
956
957 static int process_shallow(const char *line, struct object_array *shallows)
958 {
959 const char *arg;
960 if (skip_prefix(line, "shallow ", &arg)) {
961 struct object_id oid;
962 struct object *object;
963 if (get_oid_hex(arg, &oid))
964 die("invalid shallow line: %s", line);
965 object = parse_object(the_repository, &oid);
966 if (!object)
967 return 1;
968 if (object->type != OBJ_COMMIT)
969 die("invalid shallow object %s", oid_to_hex(&oid));
970 if (!(object->flags & CLIENT_SHALLOW)) {
971 object->flags |= CLIENT_SHALLOW;
972 add_object_array(object, NULL, shallows);
973 }
974 return 1;
975 }
976
977 return 0;
978 }
979
980 static int process_deepen(const char *line, int *depth)
981 {
982 const char *arg;
983 if (skip_prefix(line, "deepen ", &arg)) {
984 char *end = NULL;
985 *depth = (int)strtol(arg, &end, 0);
986 if (!end || *end || *depth <= 0)
987 die("Invalid deepen: %s", line);
988 return 1;
989 }
990
991 return 0;
992 }
993
994 static int process_deepen_since(const char *line, timestamp_t *deepen_since, int *deepen_rev_list)
995 {
996 const char *arg;
997 if (skip_prefix(line, "deepen-since ", &arg)) {
998 char *end = NULL;
999 *deepen_since = parse_timestamp(arg, &end, 0);
1000 if (!end || *end || !deepen_since ||
1001 /* revisions.c's max_age -1 is special */
1002 *deepen_since == -1)
1003 die("Invalid deepen-since: %s", line);
1004 *deepen_rev_list = 1;
1005 return 1;
1006 }
1007 return 0;
1008 }
1009
1010 static int process_deepen_not(const char *line, struct string_list *deepen_not, int *deepen_rev_list)
1011 {
1012 const char *arg;
1013 if (skip_prefix(line, "deepen-not ", &arg)) {
1014 char *ref = NULL;
1015 struct object_id oid;
1016 if (expand_ref(the_repository, arg, strlen(arg), &oid, &ref) != 1)
1017 die("git upload-pack: ambiguous deepen-not: %s", line);
1018 string_list_append(deepen_not, ref);
1019 free(ref);
1020 *deepen_rev_list = 1;
1021 return 1;
1022 }
1023 return 0;
1024 }
1025
1026 NORETURN __attribute__((format(printf,2,3)))
1027 static void send_err_and_die(struct upload_pack_data *data,
1028 const char *fmt, ...)
1029 {
1030 struct strbuf buf = STRBUF_INIT;
1031 va_list ap;
1032
1033 va_start(ap, fmt);
1034 strbuf_vaddf(&buf, fmt, ap);
1035 va_end(ap);
1036
1037 packet_writer_error(&data->writer, "%s", buf.buf);
1038 die("%s", buf.buf);
1039 }
1040
1041 static void check_one_filter(struct upload_pack_data *data,
1042 struct list_objects_filter_options *opts)
1043 {
1044 const char *key = list_object_filter_config_name(opts->choice);
1045 struct string_list_item *item = string_list_lookup(&data->allowed_filters,
1046 key);
1047 int allowed;
1048
1049 if (item)
1050 allowed = (intptr_t)item->util;
1051 else
1052 allowed = data->allow_filter_fallback;
1053
1054 if (!allowed)
1055 send_err_and_die(data, "filter '%s' not supported", key);
1056
1057 if (opts->choice == LOFC_TREE_DEPTH &&
1058 opts->tree_exclude_depth > data->tree_filter_max_depth)
1059 send_err_and_die(data,
1060 "tree filter allows max depth %lu, but got %lu",
1061 data->tree_filter_max_depth,
1062 opts->tree_exclude_depth);
1063 }
1064
1065 static void check_filter_recurse(struct upload_pack_data *data,
1066 struct list_objects_filter_options *opts)
1067 {
1068 size_t i;
1069
1070 check_one_filter(data, opts);
1071 if (opts->choice != LOFC_COMBINE)
1072 return;
1073
1074 for (i = 0; i < opts->sub_nr; i++)
1075 check_filter_recurse(data, &opts->sub[i]);
1076 }
1077
1078 static void die_if_using_banned_filter(struct upload_pack_data *data)
1079 {
1080 check_filter_recurse(data, &data->filter_options);
1081 }
1082
1083 static void receive_needs(struct upload_pack_data *data,
1084 struct packet_reader *reader)
1085 {
1086 int has_non_tip = 0;
1087
1088 data->shallow_nr = 0;
1089 for (;;) {
1090 struct object *o;
1091 const char *features;
1092 struct object_id oid_buf;
1093 const char *arg;
1094 size_t feature_len;
1095
1096 reset_timeout(data->timeout);
1097 if (packet_reader_read(reader) != PACKET_READ_NORMAL)
1098 break;
1099
1100 if (process_shallow(reader->line, &data->shallows))
1101 continue;
1102 if (process_deepen(reader->line, &data->depth))
1103 continue;
1104 if (process_deepen_since(reader->line, &data->deepen_since, &data->deepen_rev_list))
1105 continue;
1106 if (process_deepen_not(reader->line, &data->deepen_not, &data->deepen_rev_list))
1107 continue;
1108
1109 if (skip_prefix(reader->line, "filter ", &arg)) {
1110 if (!data->filter_capability_requested)
1111 die("git upload-pack: filtering capability not negotiated");
1112 list_objects_filter_die_if_populated(&data->filter_options);
1113 parse_list_objects_filter(&data->filter_options, arg);
1114 die_if_using_banned_filter(data);
1115 continue;
1116 }
1117
1118 if (!skip_prefix(reader->line, "want ", &arg) ||
1119 parse_oid_hex(arg, &oid_buf, &features))
1120 die("git upload-pack: protocol error, "
1121 "expected to get object ID, not '%s'", reader->line);
1122
1123 if (parse_feature_request(features, "deepen-relative"))
1124 data->deepen_relative = 1;
1125 if (parse_feature_request(features, "multi_ack_detailed"))
1126 data->multi_ack = MULTI_ACK_DETAILED;
1127 else if (parse_feature_request(features, "multi_ack"))
1128 data->multi_ack = MULTI_ACK;
1129 if (parse_feature_request(features, "no-done"))
1130 data->no_done = 1;
1131 if (parse_feature_request(features, "thin-pack"))
1132 data->use_thin_pack = 1;
1133 if (parse_feature_request(features, "ofs-delta"))
1134 data->use_ofs_delta = 1;
1135 if (parse_feature_request(features, "side-band-64k"))
1136 data->use_sideband = LARGE_PACKET_MAX;
1137 else if (parse_feature_request(features, "side-band"))
1138 data->use_sideband = DEFAULT_PACKET_MAX;
1139 if (parse_feature_request(features, "no-progress"))
1140 data->no_progress = 1;
1141 if (parse_feature_request(features, "include-tag"))
1142 data->use_include_tag = 1;
1143 if (data->allow_filter &&
1144 parse_feature_request(features, "filter"))
1145 data->filter_capability_requested = 1;
1146
1147 arg = parse_feature_value(features, "session-id", &feature_len, NULL);
1148 if (arg) {
1149 char *client_sid = xstrndup(arg, feature_len);
1150 trace2_data_string("transfer", NULL, "client-sid", client_sid);
1151 free(client_sid);
1152 }
1153
1154 o = parse_object(the_repository, &oid_buf);
1155 if (!o) {
1156 packet_writer_error(&data->writer,
1157 "upload-pack: not our ref %s",
1158 oid_to_hex(&oid_buf));
1159 die("git upload-pack: not our ref %s",
1160 oid_to_hex(&oid_buf));
1161 }
1162 if (!(o->flags & WANTED)) {
1163 o->flags |= WANTED;
1164 if (!((data->allow_uor & ALLOW_ANY_SHA1) == ALLOW_ANY_SHA1
1165 || is_our_ref(o, data->allow_uor)))
1166 has_non_tip = 1;
1167 add_object_array(o, NULL, &data->want_obj);
1168 }
1169 }
1170
1171 /*
1172 * We have sent all our refs already, and the other end
1173 * should have chosen out of them. When we are operating
1174 * in the stateless RPC mode, however, their choice may
1175 * have been based on the set of older refs advertised
1176 * by another process that handled the initial request.
1177 */
1178 if (has_non_tip)
1179 check_non_tip(data);
1180
1181 if (!data->use_sideband && data->daemon_mode)
1182 data->no_progress = 1;
1183
1184 if (data->depth == 0 && !data->deepen_rev_list && data->shallows.nr == 0)
1185 return;
1186
1187 if (send_shallow_list(data))
1188 packet_flush(1);
1189 }
1190
1191 /* return non-zero if the ref is hidden, otherwise 0 */
1192 static int mark_our_ref(const char *refname, const char *refname_full,
1193 const struct object_id *oid, const struct strvec *hidden_refs)
1194 {
1195 struct object *o = lookup_unknown_object(the_repository, oid);
1196
1197 if (ref_is_hidden(refname, refname_full, hidden_refs)) {
1198 o->flags |= HIDDEN_REF;
1199 return 1;
1200 }
1201 o->flags |= OUR_REF;
1202 return 0;
1203 }
1204
1205 static int check_ref(const char *refname_full, const struct object_id *oid,
1206 int flag UNUSED, void *cb_data)
1207 {
1208 const char *refname = strip_namespace(refname_full);
1209 struct upload_pack_data *data = cb_data;
1210
1211 mark_our_ref(refname, refname_full, oid, &data->hidden_refs);
1212 return 0;
1213 }
1214
1215 static void format_symref_info(struct strbuf *buf, struct string_list *symref)
1216 {
1217 struct string_list_item *item;
1218
1219 if (!symref->nr)
1220 return;
1221 for_each_string_list_item(item, symref)
1222 strbuf_addf(buf, " symref=%s:%s", item->string, (char *)item->util);
1223 }
1224
1225 static void format_session_id(struct strbuf *buf, struct upload_pack_data *d) {
1226 if (d->advertise_sid)
1227 strbuf_addf(buf, " session-id=%s", trace2_session_id());
1228 }
1229
1230 static void write_v0_ref(struct upload_pack_data *data,
1231 const char *refname, const char *refname_nons,
1232 const struct object_id *oid)
1233 {
1234 static const char *capabilities = "multi_ack thin-pack side-band"
1235 " side-band-64k ofs-delta shallow deepen-since deepen-not"
1236 " deepen-relative no-progress include-tag multi_ack_detailed";
1237 struct object_id peeled;
1238
1239 if (mark_our_ref(refname_nons, refname, oid, &data->hidden_refs))
1240 return;
1241
1242 if (capabilities) {
1243 struct strbuf symref_info = STRBUF_INIT;
1244 struct strbuf session_id = STRBUF_INIT;
1245
1246 format_symref_info(&symref_info, &data->symref);
1247 format_session_id(&session_id, data);
1248 packet_fwrite_fmt(stdout, "%s %s%c%s%s%s%s%s%s%s object-format=%s agent=%s\n",
1249 oid_to_hex(oid), refname_nons,
1250 0, capabilities,
1251 (data->allow_uor & ALLOW_TIP_SHA1) ?
1252 " allow-tip-sha1-in-want" : "",
1253 (data->allow_uor & ALLOW_REACHABLE_SHA1) ?
1254 " allow-reachable-sha1-in-want" : "",
1255 data->no_done ? " no-done" : "",
1256 symref_info.buf,
1257 data->allow_filter ? " filter" : "",
1258 session_id.buf,
1259 the_hash_algo->name,
1260 git_user_agent_sanitized());
1261 strbuf_release(&symref_info);
1262 strbuf_release(&session_id);
1263 data->sent_capabilities = 1;
1264 } else {
1265 packet_fwrite_fmt(stdout, "%s %s\n", oid_to_hex(oid), refname_nons);
1266 }
1267 capabilities = NULL;
1268 if (!peel_iterated_oid(oid, &peeled))
1269 packet_fwrite_fmt(stdout, "%s %s^{}\n", oid_to_hex(&peeled), refname_nons);
1270 return;
1271 }
1272
1273 static int send_ref(const char *refname, const struct object_id *oid,
1274 int flag UNUSED, void *cb_data)
1275 {
1276 write_v0_ref(cb_data, refname, strip_namespace(refname), oid);
1277 return 0;
1278 }
1279
1280 static int find_symref(const char *refname,
1281 const struct object_id *oid UNUSED,
1282 int flag, void *cb_data)
1283 {
1284 const char *symref_target;
1285 struct string_list_item *item;
1286
1287 if ((flag & REF_ISSYMREF) == 0)
1288 return 0;
1289 symref_target = resolve_ref_unsafe(refname, 0, NULL, &flag);
1290 if (!symref_target || (flag & REF_ISSYMREF) == 0)
1291 die("'%s' is a symref but it is not?", refname);
1292 item = string_list_append(cb_data, strip_namespace(refname));
1293 item->util = xstrdup(strip_namespace(symref_target));
1294 return 0;
1295 }
1296
1297 static int parse_object_filter_config(const char *var, const char *value,
1298 const struct key_value_info *kvi,
1299 struct upload_pack_data *data)
1300 {
1301 struct strbuf buf = STRBUF_INIT;
1302 const char *sub, *key;
1303 size_t sub_len;
1304
1305 if (parse_config_key(var, "uploadpackfilter", &sub, &sub_len, &key))
1306 return 0;
1307
1308 if (!sub) {
1309 if (!strcmp(key, "allow"))
1310 data->allow_filter_fallback = git_config_bool(var, value);
1311 return 0;
1312 }
1313
1314 strbuf_add(&buf, sub, sub_len);
1315
1316 if (!strcmp(key, "allow"))
1317 string_list_insert(&data->allowed_filters, buf.buf)->util =
1318 (void *)(intptr_t)git_config_bool(var, value);
1319 else if (!strcmp(buf.buf, "tree") && !strcmp(key, "maxdepth")) {
1320 if (!value) {
1321 strbuf_release(&buf);
1322 return config_error_nonbool(var);
1323 }
1324 string_list_insert(&data->allowed_filters, buf.buf)->util =
1325 (void *)(intptr_t)1;
1326 data->tree_filter_max_depth = git_config_ulong(var, value,
1327 kvi);
1328 }
1329
1330 strbuf_release(&buf);
1331 return 0;
1332 }
1333
1334 static int upload_pack_config(const char *var, const char *value,
1335 const struct config_context *ctx,
1336 void *cb_data)
1337 {
1338 struct upload_pack_data *data = cb_data;
1339
1340 if (!strcmp("uploadpack.allowtipsha1inwant", var)) {
1341 if (git_config_bool(var, value))
1342 data->allow_uor |= ALLOW_TIP_SHA1;
1343 else
1344 data->allow_uor &= ~ALLOW_TIP_SHA1;
1345 } else if (!strcmp("uploadpack.allowreachablesha1inwant", var)) {
1346 if (git_config_bool(var, value))
1347 data->allow_uor |= ALLOW_REACHABLE_SHA1;
1348 else
1349 data->allow_uor &= ~ALLOW_REACHABLE_SHA1;
1350 } else if (!strcmp("uploadpack.allowanysha1inwant", var)) {
1351 if (git_config_bool(var, value))
1352 data->allow_uor |= ALLOW_ANY_SHA1;
1353 else
1354 data->allow_uor &= ~ALLOW_ANY_SHA1;
1355 } else if (!strcmp("uploadpack.keepalive", var)) {
1356 data->keepalive = git_config_int(var, value, ctx->kvi);
1357 if (!data->keepalive)
1358 data->keepalive = -1;
1359 } else if (!strcmp("uploadpack.allowfilter", var)) {
1360 data->allow_filter = git_config_bool(var, value);
1361 } else if (!strcmp("uploadpack.allowrefinwant", var)) {
1362 data->allow_ref_in_want = git_config_bool(var, value);
1363 } else if (!strcmp("uploadpack.allowsidebandall", var)) {
1364 data->allow_sideband_all = git_config_bool(var, value);
1365 } else if (!strcmp("core.precomposeunicode", var)) {
1366 precomposed_unicode = git_config_bool(var, value);
1367 } else if (!strcmp("transfer.advertisesid", var)) {
1368 data->advertise_sid = git_config_bool(var, value);
1369 }
1370
1371 if (parse_object_filter_config(var, value, ctx->kvi, data) < 0)
1372 return -1;
1373
1374 return parse_hide_refs_config(var, value, "uploadpack", &data->hidden_refs);
1375 }
1376
1377 static int upload_pack_protected_config(const char *var, const char *value,
1378 const struct config_context *ctx UNUSED,
1379 void *cb_data)
1380 {
1381 struct upload_pack_data *data = cb_data;
1382
1383 if (!strcmp("uploadpack.packobjectshook", var))
1384 return git_config_string(&data->pack_objects_hook, var, value);
1385 return 0;
1386 }
1387
1388 static void get_upload_pack_config(struct upload_pack_data *data)
1389 {
1390 git_config(upload_pack_config, data);
1391 git_protected_config(upload_pack_protected_config, data);
1392 }
1393
1394 void upload_pack(const int advertise_refs, const int stateless_rpc,
1395 const int timeout)
1396 {
1397 struct packet_reader reader;
1398 struct upload_pack_data data;
1399
1400 upload_pack_data_init(&data);
1401 get_upload_pack_config(&data);
1402
1403 data.stateless_rpc = stateless_rpc;
1404 data.timeout = timeout;
1405 if (data.timeout)
1406 data.daemon_mode = 1;
1407
1408 head_ref_namespaced(find_symref, &data.symref);
1409
1410 if (advertise_refs || !data.stateless_rpc) {
1411 reset_timeout(data.timeout);
1412 if (advertise_refs)
1413 data.no_done = 1;
1414 head_ref_namespaced(send_ref, &data);
1415 for_each_namespaced_ref_1(send_ref, &data);
1416 if (!data.sent_capabilities) {
1417 const char *refname = "capabilities^{}";
1418 write_v0_ref(&data, refname, refname, null_oid());
1419 }
1420 /*
1421 * fflush stdout before calling advertise_shallow_grafts because send_ref
1422 * uses stdio.
1423 */
1424 fflush_or_die(stdout);
1425 advertise_shallow_grafts(1);
1426 packet_flush(1);
1427 } else {
1428 head_ref_namespaced(check_ref, &data);
1429 for_each_namespaced_ref_1(check_ref, &data);
1430 }
1431
1432 if (!advertise_refs) {
1433 packet_reader_init(&reader, 0, NULL, 0,
1434 PACKET_READ_CHOMP_NEWLINE |
1435 PACKET_READ_DIE_ON_ERR_PACKET);
1436
1437 receive_needs(&data, &reader);
1438
1439 /*
1440 * An EOF at this exact point in negotiation should be
1441 * acceptable from stateless clients as they will consume the
1442 * shallow list before doing subsequent rpc with haves/etc.
1443 */
1444 if (data.stateless_rpc)
1445 reader.options |= PACKET_READ_GENTLE_ON_EOF;
1446
1447 if (data.want_obj.nr &&
1448 packet_reader_peek(&reader) != PACKET_READ_EOF) {
1449 reader.options &= ~PACKET_READ_GENTLE_ON_EOF;
1450 get_common_commits(&data, &reader);
1451 create_pack_file(&data, NULL);
1452 }
1453 }
1454
1455 upload_pack_data_clear(&data);
1456 }
1457
1458 static int parse_want(struct packet_writer *writer, const char *line,
1459 struct object_array *want_obj)
1460 {
1461 const char *arg;
1462 if (skip_prefix(line, "want ", &arg)) {
1463 struct object_id oid;
1464 struct object *o;
1465
1466 if (get_oid_hex(arg, &oid))
1467 die("git upload-pack: protocol error, "
1468 "expected to get oid, not '%s'", line);
1469
1470 o = parse_object_with_flags(the_repository, &oid,
1471 PARSE_OBJECT_SKIP_HASH_CHECK);
1472
1473 if (!o) {
1474 packet_writer_error(writer,
1475 "upload-pack: not our ref %s",
1476 oid_to_hex(&oid));
1477 die("git upload-pack: not our ref %s",
1478 oid_to_hex(&oid));
1479 }
1480
1481 if (!(o->flags & WANTED)) {
1482 o->flags |= WANTED;
1483 add_object_array(o, NULL, want_obj);
1484 }
1485
1486 return 1;
1487 }
1488
1489 return 0;
1490 }
1491
1492 static int parse_want_ref(struct packet_writer *writer, const char *line,
1493 struct string_list *wanted_refs,
1494 struct strvec *hidden_refs,
1495 struct object_array *want_obj)
1496 {
1497 const char *refname_nons;
1498 if (skip_prefix(line, "want-ref ", &refname_nons)) {
1499 struct object_id oid;
1500 struct string_list_item *item;
1501 struct object *o = NULL;
1502 struct strbuf refname = STRBUF_INIT;
1503
1504 strbuf_addf(&refname, "%s%s", get_git_namespace(), refname_nons);
1505 if (ref_is_hidden(refname_nons, refname.buf, hidden_refs) ||
1506 read_ref(refname.buf, &oid)) {
1507 packet_writer_error(writer, "unknown ref %s", refname_nons);
1508 die("unknown ref %s", refname_nons);
1509 }
1510 strbuf_release(&refname);
1511
1512 item = string_list_append(wanted_refs, refname_nons);
1513 item->util = oiddup(&oid);
1514
1515 if (!starts_with(refname_nons, "refs/tags/")) {
1516 struct commit *commit = lookup_commit_in_graph(the_repository, &oid);
1517 if (commit)
1518 o = &commit->object;
1519 }
1520
1521 if (!o)
1522 o = parse_object_or_die(&oid, refname_nons);
1523
1524 if (!(o->flags & WANTED)) {
1525 o->flags |= WANTED;
1526 add_object_array(o, NULL, want_obj);
1527 }
1528
1529 return 1;
1530 }
1531
1532 return 0;
1533 }
1534
1535 static int parse_have(const char *line, struct oid_array *haves)
1536 {
1537 const char *arg;
1538 if (skip_prefix(line, "have ", &arg)) {
1539 struct object_id oid;
1540
1541 if (get_oid_hex(arg, &oid))
1542 die("git upload-pack: expected SHA1 object, got '%s'", arg);
1543 oid_array_append(haves, &oid);
1544 return 1;
1545 }
1546
1547 return 0;
1548 }
1549
1550 static void trace2_fetch_info(struct upload_pack_data *data)
1551 {
1552 struct json_writer jw = JSON_WRITER_INIT;
1553
1554 jw_object_begin(&jw, 0);
1555 jw_object_intmax(&jw, "haves", data->haves.nr);
1556 jw_object_intmax(&jw, "wants", data->want_obj.nr);
1557 jw_object_intmax(&jw, "want-refs", data->wanted_refs.nr);
1558 jw_object_intmax(&jw, "depth", data->depth);
1559 jw_object_intmax(&jw, "shallows", data->shallows.nr);
1560 jw_object_bool(&jw, "deepen-since", data->deepen_since);
1561 jw_object_intmax(&jw, "deepen-not", data->deepen_not.nr);
1562 jw_object_bool(&jw, "deepen-relative", data->deepen_relative);
1563 if (data->filter_options.choice)
1564 jw_object_string(&jw, "filter", list_object_filter_config_name(data->filter_options.choice));
1565 else
1566 jw_object_null(&jw, "filter");
1567 jw_end(&jw);
1568
1569 trace2_data_json("upload-pack", the_repository, "fetch-info", &jw);
1570
1571 jw_release(&jw);
1572 }
1573
1574 static void process_args(struct packet_reader *request,
1575 struct upload_pack_data *data)
1576 {
1577 while (packet_reader_read(request) == PACKET_READ_NORMAL) {
1578 const char *arg = request->line;
1579 const char *p;
1580
1581 /* process want */
1582 if (parse_want(&data->writer, arg, &data->want_obj))
1583 continue;
1584 if (data->allow_ref_in_want &&
1585 parse_want_ref(&data->writer, arg, &data->wanted_refs,
1586 &data->hidden_refs, &data->want_obj))
1587 continue;
1588 /* process have line */
1589 if (parse_have(arg, &data->haves))
1590 continue;
1591
1592 /* process args like thin-pack */
1593 if (!strcmp(arg, "thin-pack")) {
1594 data->use_thin_pack = 1;
1595 continue;
1596 }
1597 if (!strcmp(arg, "ofs-delta")) {
1598 data->use_ofs_delta = 1;
1599 continue;
1600 }
1601 if (!strcmp(arg, "no-progress")) {
1602 data->no_progress = 1;
1603 continue;
1604 }
1605 if (!strcmp(arg, "include-tag")) {
1606 data->use_include_tag = 1;
1607 continue;
1608 }
1609 if (!strcmp(arg, "done")) {
1610 data->done = 1;
1611 continue;
1612 }
1613 if (!strcmp(arg, "wait-for-done")) {
1614 data->wait_for_done = 1;
1615 continue;
1616 }
1617
1618 /* Shallow related arguments */
1619 if (process_shallow(arg, &data->shallows))
1620 continue;
1621 if (process_deepen(arg, &data->depth))
1622 continue;
1623 if (process_deepen_since(arg, &data->deepen_since,
1624 &data->deepen_rev_list))
1625 continue;
1626 if (process_deepen_not(arg, &data->deepen_not,
1627 &data->deepen_rev_list))
1628 continue;
1629 if (!strcmp(arg, "deepen-relative")) {
1630 data->deepen_relative = 1;
1631 continue;
1632 }
1633
1634 if (data->allow_filter && skip_prefix(arg, "filter ", &p)) {
1635 list_objects_filter_die_if_populated(&data->filter_options);
1636 parse_list_objects_filter(&data->filter_options, p);
1637 die_if_using_banned_filter(data);
1638 continue;
1639 }
1640
1641 if ((git_env_bool("GIT_TEST_SIDEBAND_ALL", 0) ||
1642 data->allow_sideband_all) &&
1643 !strcmp(arg, "sideband-all")) {
1644 data->writer.use_sideband = 1;
1645 continue;
1646 }
1647
1648 if (skip_prefix(arg, "packfile-uris ", &p)) {
1649 string_list_split(&data->uri_protocols, p, ',', -1);
1650 continue;
1651 }
1652
1653 /* ignore unknown lines maybe? */
1654 die("unexpected line: '%s'", arg);
1655 }
1656
1657 if (data->uri_protocols.nr && !data->writer.use_sideband)
1658 string_list_clear(&data->uri_protocols, 0);
1659
1660 if (request->status != PACKET_READ_FLUSH)
1661 die(_("expected flush after fetch arguments"));
1662
1663 if (trace2_is_enabled())
1664 trace2_fetch_info(data);
1665 }
1666
1667 static int process_haves(struct upload_pack_data *data, struct oid_array *common)
1668 {
1669 int i;
1670
1671 /* Process haves */
1672 for (i = 0; i < data->haves.nr; i++) {
1673 const struct object_id *oid = &data->haves.oid[i];
1674
1675 if (!repo_has_object_file_with_flags(the_repository, oid,
1676 OBJECT_INFO_QUICK | OBJECT_INFO_SKIP_FETCH_OBJECT))
1677 continue;
1678
1679 oid_array_append(common, oid);
1680
1681 do_got_oid(data, oid);
1682 }
1683
1684 return 0;
1685 }
1686
1687 static int send_acks(struct upload_pack_data *data, struct oid_array *acks)
1688 {
1689 int i;
1690
1691 packet_writer_write(&data->writer, "acknowledgments\n");
1692
1693 /* Send Acks */
1694 if (!acks->nr)
1695 packet_writer_write(&data->writer, "NAK\n");
1696
1697 for (i = 0; i < acks->nr; i++) {
1698 packet_writer_write(&data->writer, "ACK %s\n",
1699 oid_to_hex(&acks->oid[i]));
1700 }
1701
1702 if (!data->wait_for_done && ok_to_give_up(data)) {
1703 /* Send Ready */
1704 packet_writer_write(&data->writer, "ready\n");
1705 return 1;
1706 }
1707
1708 return 0;
1709 }
1710
1711 static int process_haves_and_send_acks(struct upload_pack_data *data)
1712 {
1713 struct oid_array common = OID_ARRAY_INIT;
1714 int ret = 0;
1715
1716 process_haves(data, &common);
1717 if (data->done) {
1718 ret = 1;
1719 } else if (send_acks(data, &common)) {
1720 packet_writer_delim(&data->writer);
1721 ret = 1;
1722 } else {
1723 /* Add Flush */
1724 packet_writer_flush(&data->writer);
1725 ret = 0;
1726 }
1727
1728 oid_array_clear(&data->haves);
1729 oid_array_clear(&common);
1730 return ret;
1731 }
1732
1733 static void send_wanted_ref_info(struct upload_pack_data *data)
1734 {
1735 const struct string_list_item *item;
1736
1737 if (!data->wanted_refs.nr)
1738 return;
1739
1740 packet_writer_write(&data->writer, "wanted-refs\n");
1741
1742 for_each_string_list_item(item, &data->wanted_refs) {
1743 packet_writer_write(&data->writer, "%s %s\n",
1744 oid_to_hex(item->util),
1745 item->string);
1746 }
1747
1748 packet_writer_delim(&data->writer);
1749 }
1750
1751 static void send_shallow_info(struct upload_pack_data *data)
1752 {
1753 /* No shallow info needs to be sent */
1754 if (!data->depth && !data->deepen_rev_list && !data->shallows.nr &&
1755 !is_repository_shallow(the_repository))
1756 return;
1757
1758 packet_writer_write(&data->writer, "shallow-info\n");
1759
1760 if (!send_shallow_list(data) &&
1761 is_repository_shallow(the_repository))
1762 deepen(data, INFINITE_DEPTH);
1763
1764 packet_delim(1);
1765 }
1766
1767 enum fetch_state {
1768 FETCH_PROCESS_ARGS = 0,
1769 FETCH_SEND_ACKS,
1770 FETCH_SEND_PACK,
1771 FETCH_DONE,
1772 };
1773
1774 int upload_pack_v2(struct repository *r UNUSED, struct packet_reader *request)
1775 {
1776 enum fetch_state state = FETCH_PROCESS_ARGS;
1777 struct upload_pack_data data;
1778
1779 clear_object_flags(ALL_FLAGS);
1780
1781 upload_pack_data_init(&data);
1782 data.use_sideband = LARGE_PACKET_MAX;
1783 get_upload_pack_config(&data);
1784
1785 while (state != FETCH_DONE) {
1786 switch (state) {
1787 case FETCH_PROCESS_ARGS:
1788 process_args(request, &data);
1789
1790 if (!data.want_obj.nr && !data.wait_for_done) {
1791 /*
1792 * Request didn't contain any 'want' lines (and
1793 * the request does not contain
1794 * "wait-for-done", in which it is reasonable
1795 * to just send 'have's without 'want's); guess
1796 * they didn't want anything.
1797 */
1798 state = FETCH_DONE;
1799 } else if (data.haves.nr) {
1800 /*
1801 * Request had 'have' lines, so lets ACK them.
1802 */
1803 state = FETCH_SEND_ACKS;
1804 } else {
1805 /*
1806 * Request had 'want's but no 'have's so we can
1807 * immedietly go to construct and send a pack.
1808 */
1809 state = FETCH_SEND_PACK;
1810 }
1811 break;
1812 case FETCH_SEND_ACKS:
1813 if (process_haves_and_send_acks(&data))
1814 state = FETCH_SEND_PACK;
1815 else
1816 state = FETCH_DONE;
1817 break;
1818 case FETCH_SEND_PACK:
1819 send_wanted_ref_info(&data);
1820 send_shallow_info(&data);
1821
1822 if (data.uri_protocols.nr) {
1823 create_pack_file(&data, &data.uri_protocols);
1824 } else {
1825 packet_writer_write(&data.writer, "packfile\n");
1826 create_pack_file(&data, NULL);
1827 }
1828 state = FETCH_DONE;
1829 break;
1830 case FETCH_DONE:
1831 continue;
1832 }
1833 }
1834
1835 upload_pack_data_clear(&data);
1836 return 0;
1837 }
1838
1839 int upload_pack_advertise(struct repository *r,
1840 struct strbuf *value)
1841 {
1842 if (value) {
1843 int allow_filter_value;
1844 int allow_ref_in_want;
1845 int allow_sideband_all_value;
1846 char *str = NULL;
1847
1848 strbuf_addstr(value, "shallow wait-for-done");
1849
1850 if (!repo_config_get_bool(r,
1851 "uploadpack.allowfilter",
1852 &allow_filter_value) &&
1853 allow_filter_value)
1854 strbuf_addstr(value, " filter");
1855
1856 if (!repo_config_get_bool(r,
1857 "uploadpack.allowrefinwant",
1858 &allow_ref_in_want) &&
1859 allow_ref_in_want)
1860 strbuf_addstr(value, " ref-in-want");
1861
1862 if (git_env_bool("GIT_TEST_SIDEBAND_ALL", 0) ||
1863 (!repo_config_get_bool(r,
1864 "uploadpack.allowsidebandall",
1865 &allow_sideband_all_value) &&
1866 allow_sideband_all_value))
1867 strbuf_addstr(value, " sideband-all");
1868
1869 if (!repo_config_get_string(r,
1870 "uploadpack.blobpackfileuri",
1871 &str) &&
1872 str) {
1873 strbuf_addstr(value, " packfile-uris");
1874 free(str);
1875 }
1876 }
1877
1878 return 1;
1879 }
Mirror of Junio's Git repository with all the branches