tag: add repository argument to deref_tag
[git] / upload-pack.c
1 #include "cache.h"
2 #include "config.h"
3 #include "refs.h"
4 #include "pkt-line.h"
5 #include "sideband.h"
6 #include "repository.h"
7 #include "object-store.h"
8 #include "tag.h"
9 #include "object.h"
10 #include "commit.h"
11 #include "diff.h"
12 #include "revision.h"
13 #include "list-objects.h"
14 #include "list-objects-filter.h"
15 #include "list-objects-filter-options.h"
16 #include "run-command.h"
17 #include "connect.h"
18 #include "sigchain.h"
19 #include "version.h"
20 #include "string-list.h"
21 #include "argv-array.h"
22 #include "prio-queue.h"
23 #include "protocol.h"
24 #include "quote.h"
25 #include "upload-pack.h"
26 #include "serve.h"
27
28 /* Remember to update object flag allocation in object.h */
29 #define THEY_HAVE       (1u << 11)
30 #define OUR_REF         (1u << 12)
31 #define WANTED          (1u << 13)
32 #define COMMON_KNOWN    (1u << 14)
33 #define REACHABLE       (1u << 15)
34
35 #define SHALLOW         (1u << 16)
36 #define NOT_SHALLOW     (1u << 17)
37 #define CLIENT_SHALLOW  (1u << 18)
38 #define HIDDEN_REF      (1u << 19)
39
40 static timestamp_t oldest_have;
41
42 static int deepen_relative;
43 static int multi_ack;
44 static int no_done;
45 static int use_thin_pack, use_ofs_delta, use_include_tag;
46 static int no_progress, daemon_mode;
47 /* Allow specifying sha1 if it is a ref tip. */
48 #define ALLOW_TIP_SHA1  01
49 /* Allow request of a sha1 if it is reachable from a ref (possibly hidden ref). */
50 #define ALLOW_REACHABLE_SHA1    02
51 /* Allow request of any sha1. Implies ALLOW_TIP_SHA1 and ALLOW_REACHABLE_SHA1. */
52 #define ALLOW_ANY_SHA1  07
53 static unsigned int allow_unadvertised_object_request;
54 static int shallow_nr;
55 static struct object_array have_obj;
56 static struct object_array want_obj;
57 static struct object_array extra_edge_obj;
58 static unsigned int timeout;
59 static int keepalive = 5;
60 /* 0 for no sideband,
61  * otherwise maximum packet size (up to 65520 bytes).
62  */
63 static int use_sideband;
64 static int stateless_rpc;
65 static const char *pack_objects_hook;
66
67 static int filter_capability_requested;
68 static int allow_filter;
69 static struct list_objects_filter_options filter_options;
70
71 static void reset_timeout(void)
72 {
73         alarm(timeout);
74 }
75
76 static void send_client_data(int fd, const char *data, ssize_t sz)
77 {
78         if (use_sideband) {
79                 send_sideband(1, fd, data, sz, use_sideband);
80                 return;
81         }
82         if (fd == 3)
83                 /* emergency quit */
84                 fd = 2;
85         if (fd == 2) {
86                 /* XXX: are we happy to lose stuff here? */
87                 xwrite(fd, data, sz);
88                 return;
89         }
90         write_or_die(fd, data, sz);
91 }
92
93 static int write_one_shallow(const struct commit_graft *graft, void *cb_data)
94 {
95         FILE *fp = cb_data;
96         if (graft->nr_parent == -1)
97                 fprintf(fp, "--shallow %s\n", oid_to_hex(&graft->oid));
98         return 0;
99 }
100
101 static void create_pack_file(void)
102 {
103         struct child_process pack_objects = CHILD_PROCESS_INIT;
104         char data[8193], progress[128];
105         char abort_msg[] = "aborting due to possible repository "
106                 "corruption on the remote side.";
107         int buffered = -1;
108         ssize_t sz;
109         int i;
110         FILE *pipe_fd;
111
112         if (!pack_objects_hook)
113                 pack_objects.git_cmd = 1;
114         else {
115                 argv_array_push(&pack_objects.args, pack_objects_hook);
116                 argv_array_push(&pack_objects.args, "git");
117                 pack_objects.use_shell = 1;
118         }
119
120         if (shallow_nr) {
121                 argv_array_push(&pack_objects.args, "--shallow-file");
122                 argv_array_push(&pack_objects.args, "");
123         }
124         argv_array_push(&pack_objects.args, "pack-objects");
125         argv_array_push(&pack_objects.args, "--revs");
126         if (use_thin_pack)
127                 argv_array_push(&pack_objects.args, "--thin");
128
129         argv_array_push(&pack_objects.args, "--stdout");
130         if (shallow_nr)
131                 argv_array_push(&pack_objects.args, "--shallow");
132         if (!no_progress)
133                 argv_array_push(&pack_objects.args, "--progress");
134         if (use_ofs_delta)
135                 argv_array_push(&pack_objects.args, "--delta-base-offset");
136         if (use_include_tag)
137                 argv_array_push(&pack_objects.args, "--include-tag");
138         if (filter_options.filter_spec) {
139                 if (pack_objects.use_shell) {
140                         struct strbuf buf = STRBUF_INIT;
141                         sq_quote_buf(&buf, filter_options.filter_spec);
142                         argv_array_pushf(&pack_objects.args, "--filter=%s", buf.buf);
143                         strbuf_release(&buf);
144                 } else {
145                         argv_array_pushf(&pack_objects.args, "--filter=%s",
146                                          filter_options.filter_spec);
147                 }
148         }
149
150         pack_objects.in = -1;
151         pack_objects.out = -1;
152         pack_objects.err = -1;
153
154         if (start_command(&pack_objects))
155                 die("git upload-pack: unable to fork git-pack-objects");
156
157         pipe_fd = xfdopen(pack_objects.in, "w");
158
159         if (shallow_nr)
160                 for_each_commit_graft(write_one_shallow, pipe_fd);
161
162         for (i = 0; i < want_obj.nr; i++)
163                 fprintf(pipe_fd, "%s\n",
164                         oid_to_hex(&want_obj.objects[i].item->oid));
165         fprintf(pipe_fd, "--not\n");
166         for (i = 0; i < have_obj.nr; i++)
167                 fprintf(pipe_fd, "%s\n",
168                         oid_to_hex(&have_obj.objects[i].item->oid));
169         for (i = 0; i < extra_edge_obj.nr; i++)
170                 fprintf(pipe_fd, "%s\n",
171                         oid_to_hex(&extra_edge_obj.objects[i].item->oid));
172         fprintf(pipe_fd, "\n");
173         fflush(pipe_fd);
174         fclose(pipe_fd);
175
176         /* We read from pack_objects.err to capture stderr output for
177          * progress bar, and pack_objects.out to capture the pack data.
178          */
179
180         while (1) {
181                 struct pollfd pfd[2];
182                 int pe, pu, pollsize;
183                 int ret;
184
185                 reset_timeout();
186
187                 pollsize = 0;
188                 pe = pu = -1;
189
190                 if (0 <= pack_objects.out) {
191                         pfd[pollsize].fd = pack_objects.out;
192                         pfd[pollsize].events = POLLIN;
193                         pu = pollsize;
194                         pollsize++;
195                 }
196                 if (0 <= pack_objects.err) {
197                         pfd[pollsize].fd = pack_objects.err;
198                         pfd[pollsize].events = POLLIN;
199                         pe = pollsize;
200                         pollsize++;
201                 }
202
203                 if (!pollsize)
204                         break;
205
206                 ret = poll(pfd, pollsize,
207                         keepalive < 0 ? -1 : 1000 * keepalive);
208
209                 if (ret < 0) {
210                         if (errno != EINTR) {
211                                 error_errno("poll failed, resuming");
212                                 sleep(1);
213                         }
214                         continue;
215                 }
216                 if (0 <= pe && (pfd[pe].revents & (POLLIN|POLLHUP))) {
217                         /* Status ready; we ship that in the side-band
218                          * or dump to the standard error.
219                          */
220                         sz = xread(pack_objects.err, progress,
221                                   sizeof(progress));
222                         if (0 < sz)
223                                 send_client_data(2, progress, sz);
224                         else if (sz == 0) {
225                                 close(pack_objects.err);
226                                 pack_objects.err = -1;
227                         }
228                         else
229                                 goto fail;
230                         /* give priority to status messages */
231                         continue;
232                 }
233                 if (0 <= pu && (pfd[pu].revents & (POLLIN|POLLHUP))) {
234                         /* Data ready; we keep the last byte to ourselves
235                          * in case we detect broken rev-list, so that we
236                          * can leave the stream corrupted.  This is
237                          * unfortunate -- unpack-objects would happily
238                          * accept a valid packdata with trailing garbage,
239                          * so appending garbage after we pass all the
240                          * pack data is not good enough to signal
241                          * breakage to downstream.
242                          */
243                         char *cp = data;
244                         ssize_t outsz = 0;
245                         if (0 <= buffered) {
246                                 *cp++ = buffered;
247                                 outsz++;
248                         }
249                         sz = xread(pack_objects.out, cp,
250                                   sizeof(data) - outsz);
251                         if (0 < sz)
252                                 ;
253                         else if (sz == 0) {
254                                 close(pack_objects.out);
255                                 pack_objects.out = -1;
256                         }
257                         else
258                                 goto fail;
259                         sz += outsz;
260                         if (1 < sz) {
261                                 buffered = data[sz-1] & 0xFF;
262                                 sz--;
263                         }
264                         else
265                                 buffered = -1;
266                         send_client_data(1, data, sz);
267                 }
268
269                 /*
270                  * We hit the keepalive timeout without saying anything; send
271                  * an empty message on the data sideband just to let the other
272                  * side know we're still working on it, but don't have any data
273                  * yet.
274                  *
275                  * If we don't have a sideband channel, there's no room in the
276                  * protocol to say anything, so those clients are just out of
277                  * luck.
278                  */
279                 if (!ret && use_sideband) {
280                         static const char buf[] = "0005\1";
281                         write_or_die(1, buf, 5);
282                 }
283         }
284
285         if (finish_command(&pack_objects)) {
286                 error("git upload-pack: git-pack-objects died with error.");
287                 goto fail;
288         }
289
290         /* flush the data */
291         if (0 <= buffered) {
292                 data[0] = buffered;
293                 send_client_data(1, data, 1);
294                 fprintf(stderr, "flushed.\n");
295         }
296         if (use_sideband)
297                 packet_flush(1);
298         return;
299
300  fail:
301         send_client_data(3, abort_msg, sizeof(abort_msg));
302         die("git upload-pack: %s", abort_msg);
303 }
304
305 static int got_oid(const char *hex, struct object_id *oid)
306 {
307         struct object *o;
308         int we_knew_they_have = 0;
309
310         if (get_oid_hex(hex, oid))
311                 die("git upload-pack: expected SHA1 object, got '%s'", hex);
312         if (!has_object_file(oid))
313                 return -1;
314
315         o = parse_object(the_repository, oid);
316         if (!o)
317                 die("oops (%s)", oid_to_hex(oid));
318         if (o->type == OBJ_COMMIT) {
319                 struct commit_list *parents;
320                 struct commit *commit = (struct commit *)o;
321                 if (o->flags & THEY_HAVE)
322                         we_knew_they_have = 1;
323                 else
324                         o->flags |= THEY_HAVE;
325                 if (!oldest_have || (commit->date < oldest_have))
326                         oldest_have = commit->date;
327                 for (parents = commit->parents;
328                      parents;
329                      parents = parents->next)
330                         parents->item->object.flags |= THEY_HAVE;
331         }
332         if (!we_knew_they_have) {
333                 add_object_array(o, NULL, &have_obj);
334                 return 1;
335         }
336         return 0;
337 }
338
339 static int reachable(struct commit *want)
340 {
341         struct prio_queue work = { compare_commits_by_commit_date };
342
343         prio_queue_put(&work, want);
344         while (work.nr) {
345                 struct commit_list *list;
346                 struct commit *commit = prio_queue_get(&work);
347
348                 if (commit->object.flags & THEY_HAVE) {
349                         want->object.flags |= COMMON_KNOWN;
350                         break;
351                 }
352                 if (!commit->object.parsed)
353                         parse_object(the_repository, &commit->object.oid);
354                 if (commit->object.flags & REACHABLE)
355                         continue;
356                 commit->object.flags |= REACHABLE;
357                 if (commit->date < oldest_have)
358                         continue;
359                 for (list = commit->parents; list; list = list->next) {
360                         struct commit *parent = list->item;
361                         if (!(parent->object.flags & REACHABLE))
362                                 prio_queue_put(&work, parent);
363                 }
364         }
365         want->object.flags |= REACHABLE;
366         clear_commit_marks(want, REACHABLE);
367         clear_prio_queue(&work);
368         return (want->object.flags & COMMON_KNOWN);
369 }
370
371 static int ok_to_give_up(void)
372 {
373         int i;
374
375         if (!have_obj.nr)
376                 return 0;
377
378         for (i = 0; i < want_obj.nr; i++) {
379                 struct object *want = want_obj.objects[i].item;
380
381                 if (want->flags & COMMON_KNOWN)
382                         continue;
383                 want = deref_tag(the_repository, want, "a want line", 0);
384                 if (!want || want->type != OBJ_COMMIT) {
385                         /* no way to tell if this is reachable by
386                          * looking at the ancestry chain alone, so
387                          * leave a note to ourselves not to worry about
388                          * this object anymore.
389                          */
390                         want_obj.objects[i].item->flags |= COMMON_KNOWN;
391                         continue;
392                 }
393                 if (!reachable((struct commit *)want))
394                         return 0;
395         }
396         return 1;
397 }
398
399 static int get_common_commits(void)
400 {
401         struct object_id oid;
402         char last_hex[GIT_MAX_HEXSZ + 1];
403         int got_common = 0;
404         int got_other = 0;
405         int sent_ready = 0;
406
407         save_commit_buffer = 0;
408
409         for (;;) {
410                 char *line = packet_read_line(0, NULL);
411                 const char *arg;
412
413                 reset_timeout();
414
415                 if (!line) {
416                         if (multi_ack == 2 && got_common
417                             && !got_other && ok_to_give_up()) {
418                                 sent_ready = 1;
419                                 packet_write_fmt(1, "ACK %s ready\n", last_hex);
420                         }
421                         if (have_obj.nr == 0 || multi_ack)
422                                 packet_write_fmt(1, "NAK\n");
423
424                         if (no_done && sent_ready) {
425                                 packet_write_fmt(1, "ACK %s\n", last_hex);
426                                 return 0;
427                         }
428                         if (stateless_rpc)
429                                 exit(0);
430                         got_common = 0;
431                         got_other = 0;
432                         continue;
433                 }
434                 if (skip_prefix(line, "have ", &arg)) {
435                         switch (got_oid(arg, &oid)) {
436                         case -1: /* they have what we do not */
437                                 got_other = 1;
438                                 if (multi_ack && ok_to_give_up()) {
439                                         const char *hex = oid_to_hex(&oid);
440                                         if (multi_ack == 2) {
441                                                 sent_ready = 1;
442                                                 packet_write_fmt(1, "ACK %s ready\n", hex);
443                                         } else
444                                                 packet_write_fmt(1, "ACK %s continue\n", hex);
445                                 }
446                                 break;
447                         default:
448                                 got_common = 1;
449                                 oid_to_hex_r(last_hex, &oid);
450                                 if (multi_ack == 2)
451                                         packet_write_fmt(1, "ACK %s common\n", last_hex);
452                                 else if (multi_ack)
453                                         packet_write_fmt(1, "ACK %s continue\n", last_hex);
454                                 else if (have_obj.nr == 1)
455                                         packet_write_fmt(1, "ACK %s\n", last_hex);
456                                 break;
457                         }
458                         continue;
459                 }
460                 if (!strcmp(line, "done")) {
461                         if (have_obj.nr > 0) {
462                                 if (multi_ack)
463                                         packet_write_fmt(1, "ACK %s\n", last_hex);
464                                 return 0;
465                         }
466                         packet_write_fmt(1, "NAK\n");
467                         return -1;
468                 }
469                 die("git upload-pack: expected SHA1 list, got '%s'", line);
470         }
471 }
472
473 static int is_our_ref(struct object *o)
474 {
475         int allow_hidden_ref = (allow_unadvertised_object_request &
476                         (ALLOW_TIP_SHA1 | ALLOW_REACHABLE_SHA1));
477         return o->flags & ((allow_hidden_ref ? HIDDEN_REF : 0) | OUR_REF);
478 }
479
480 /*
481  * on successful case, it's up to the caller to close cmd->out
482  */
483 static int do_reachable_revlist(struct child_process *cmd,
484                                 struct object_array *src,
485                                 struct object_array *reachable)
486 {
487         static const char *argv[] = {
488                 "rev-list", "--stdin", NULL,
489         };
490         struct object *o;
491         char namebuf[GIT_MAX_HEXSZ + 2]; /* ^ + hash + LF */
492         int i;
493
494         cmd->argv = argv;
495         cmd->git_cmd = 1;
496         cmd->no_stderr = 1;
497         cmd->in = -1;
498         cmd->out = -1;
499
500         /*
501          * If the next rev-list --stdin encounters an unknown commit,
502          * it terminates, which will cause SIGPIPE in the write loop
503          * below.
504          */
505         sigchain_push(SIGPIPE, SIG_IGN);
506
507         if (start_command(cmd))
508                 goto error;
509
510         namebuf[0] = '^';
511         namebuf[GIT_SHA1_HEXSZ + 1] = '\n';
512         for (i = get_max_object_index(); 0 < i; ) {
513                 o = get_indexed_object(--i);
514                 if (!o)
515                         continue;
516                 if (reachable && o->type == OBJ_COMMIT)
517                         o->flags &= ~TMP_MARK;
518                 if (!is_our_ref(o))
519                         continue;
520                 memcpy(namebuf + 1, oid_to_hex(&o->oid), GIT_SHA1_HEXSZ);
521                 if (write_in_full(cmd->in, namebuf, GIT_SHA1_HEXSZ + 2) < 0)
522                         goto error;
523         }
524         namebuf[GIT_SHA1_HEXSZ] = '\n';
525         for (i = 0; i < src->nr; i++) {
526                 o = src->objects[i].item;
527                 if (is_our_ref(o)) {
528                         if (reachable)
529                                 add_object_array(o, NULL, reachable);
530                         continue;
531                 }
532                 if (reachable && o->type == OBJ_COMMIT)
533                         o->flags |= TMP_MARK;
534                 memcpy(namebuf, oid_to_hex(&o->oid), GIT_SHA1_HEXSZ);
535                 if (write_in_full(cmd->in, namebuf, GIT_SHA1_HEXSZ + 1) < 0)
536                         goto error;
537         }
538         close(cmd->in);
539         cmd->in = -1;
540         sigchain_pop(SIGPIPE);
541
542         return 0;
543
544 error:
545         sigchain_pop(SIGPIPE);
546
547         if (cmd->in >= 0)
548                 close(cmd->in);
549         if (cmd->out >= 0)
550                 close(cmd->out);
551         return -1;
552 }
553
554 static int get_reachable_list(struct object_array *src,
555                               struct object_array *reachable)
556 {
557         struct child_process cmd = CHILD_PROCESS_INIT;
558         int i;
559         struct object *o;
560         char namebuf[GIT_MAX_HEXSZ + 2]; /* ^ + hash + LF */
561         const unsigned hexsz = the_hash_algo->hexsz;
562
563         if (do_reachable_revlist(&cmd, src, reachable) < 0)
564                 return -1;
565
566         while ((i = read_in_full(cmd.out, namebuf, hexsz + 1)) == hexsz + 1) {
567                 struct object_id sha1;
568                 const char *p;
569
570                 if (parse_oid_hex(namebuf, &sha1, &p) || *p != '\n')
571                         break;
572
573                 o = lookup_object(the_repository, sha1.hash);
574                 if (o && o->type == OBJ_COMMIT) {
575                         o->flags &= ~TMP_MARK;
576                 }
577         }
578         for (i = get_max_object_index(); 0 < i; i--) {
579                 o = get_indexed_object(i - 1);
580                 if (o && o->type == OBJ_COMMIT &&
581                     (o->flags & TMP_MARK)) {
582                         add_object_array(o, NULL, reachable);
583                                 o->flags &= ~TMP_MARK;
584                 }
585         }
586         close(cmd.out);
587
588         if (finish_command(&cmd))
589                 return -1;
590
591         return 0;
592 }
593
594 static int has_unreachable(struct object_array *src)
595 {
596         struct child_process cmd = CHILD_PROCESS_INIT;
597         char buf[1];
598         int i;
599
600         if (do_reachable_revlist(&cmd, src, NULL) < 0)
601                 return 1;
602
603         /*
604          * The commits out of the rev-list are not ancestors of
605          * our ref.
606          */
607         i = read_in_full(cmd.out, buf, 1);
608         if (i)
609                 goto error;
610         close(cmd.out);
611         cmd.out = -1;
612
613         /*
614          * rev-list may have died by encountering a bad commit
615          * in the history, in which case we do want to bail out
616          * even when it showed no commit.
617          */
618         if (finish_command(&cmd))
619                 goto error;
620
621         /* All the non-tip ones are ancestors of what we advertised */
622         return 0;
623
624 error:
625         sigchain_pop(SIGPIPE);
626         if (cmd.out >= 0)
627                 close(cmd.out);
628         return 1;
629 }
630
631 static void check_non_tip(void)
632 {
633         int i;
634
635         /*
636          * In the normal in-process case without
637          * uploadpack.allowReachableSHA1InWant,
638          * non-tip requests can never happen.
639          */
640         if (!stateless_rpc && !(allow_unadvertised_object_request & ALLOW_REACHABLE_SHA1))
641                 goto error;
642         if (!has_unreachable(&want_obj))
643                 /* All the non-tip ones are ancestors of what we advertised */
644                 return;
645
646 error:
647         /* Pick one of them (we know there at least is one) */
648         for (i = 0; i < want_obj.nr; i++) {
649                 struct object *o = want_obj.objects[i].item;
650                 if (!is_our_ref(o))
651                         die("git upload-pack: not our ref %s",
652                             oid_to_hex(&o->oid));
653         }
654 }
655
656 static void send_shallow(struct commit_list *result)
657 {
658         while (result) {
659                 struct object *object = &result->item->object;
660                 if (!(object->flags & (CLIENT_SHALLOW|NOT_SHALLOW))) {
661                         packet_write_fmt(1, "shallow %s",
662                                          oid_to_hex(&object->oid));
663                         register_shallow(the_repository, &object->oid);
664                         shallow_nr++;
665                 }
666                 result = result->next;
667         }
668 }
669
670 static void send_unshallow(const struct object_array *shallows)
671 {
672         int i;
673
674         for (i = 0; i < shallows->nr; i++) {
675                 struct object *object = shallows->objects[i].item;
676                 if (object->flags & NOT_SHALLOW) {
677                         struct commit_list *parents;
678                         packet_write_fmt(1, "unshallow %s",
679                                          oid_to_hex(&object->oid));
680                         object->flags &= ~CLIENT_SHALLOW;
681                         /*
682                          * We want to _register_ "object" as shallow, but we
683                          * also need to traverse object's parents to deepen a
684                          * shallow clone. Unregister it for now so we can
685                          * parse and add the parents to the want list, then
686                          * re-register it.
687                          */
688                         unregister_shallow(&object->oid);
689                         object->parsed = 0;
690                         parse_commit_or_die((struct commit *)object);
691                         parents = ((struct commit *)object)->parents;
692                         while (parents) {
693                                 add_object_array(&parents->item->object,
694                                                  NULL, &want_obj);
695                                 parents = parents->next;
696                         }
697                         add_object_array(object, NULL, &extra_edge_obj);
698                 }
699                 /* make sure commit traversal conforms to client */
700                 register_shallow(the_repository, &object->oid);
701         }
702 }
703
704 static void deepen(int depth, int deepen_relative,
705                    struct object_array *shallows)
706 {
707         if (depth == INFINITE_DEPTH && !is_repository_shallow(the_repository)) {
708                 int i;
709
710                 for (i = 0; i < shallows->nr; i++) {
711                         struct object *object = shallows->objects[i].item;
712                         object->flags |= NOT_SHALLOW;
713                 }
714         } else if (deepen_relative) {
715                 struct object_array reachable_shallows = OBJECT_ARRAY_INIT;
716                 struct commit_list *result;
717
718                 get_reachable_list(shallows, &reachable_shallows);
719                 result = get_shallow_commits(&reachable_shallows,
720                                              depth + 1,
721                                              SHALLOW, NOT_SHALLOW);
722                 send_shallow(result);
723                 free_commit_list(result);
724                 object_array_clear(&reachable_shallows);
725         } else {
726                 struct commit_list *result;
727
728                 result = get_shallow_commits(&want_obj, depth,
729                                              SHALLOW, NOT_SHALLOW);
730                 send_shallow(result);
731                 free_commit_list(result);
732         }
733
734         send_unshallow(shallows);
735 }
736
737 static void deepen_by_rev_list(int ac, const char **av,
738                                struct object_array *shallows)
739 {
740         struct commit_list *result;
741
742         result = get_shallow_commits_by_rev_list(ac, av, SHALLOW, NOT_SHALLOW);
743         send_shallow(result);
744         free_commit_list(result);
745         send_unshallow(shallows);
746 }
747
748 /* Returns 1 if a shallow list is sent or 0 otherwise */
749 static int send_shallow_list(int depth, int deepen_rev_list,
750                              timestamp_t deepen_since,
751                              struct string_list *deepen_not,
752                              struct object_array *shallows)
753 {
754         int ret = 0;
755
756         if (depth > 0 && deepen_rev_list)
757                 die("git upload-pack: deepen and deepen-since (or deepen-not) cannot be used together");
758         if (depth > 0) {
759                 deepen(depth, deepen_relative, shallows);
760                 ret = 1;
761         } else if (deepen_rev_list) {
762                 struct argv_array av = ARGV_ARRAY_INIT;
763                 int i;
764
765                 argv_array_push(&av, "rev-list");
766                 if (deepen_since)
767                         argv_array_pushf(&av, "--max-age=%"PRItime, deepen_since);
768                 if (deepen_not->nr) {
769                         argv_array_push(&av, "--not");
770                         for (i = 0; i < deepen_not->nr; i++) {
771                                 struct string_list_item *s = deepen_not->items + i;
772                                 argv_array_push(&av, s->string);
773                         }
774                         argv_array_push(&av, "--not");
775                 }
776                 for (i = 0; i < want_obj.nr; i++) {
777                         struct object *o = want_obj.objects[i].item;
778                         argv_array_push(&av, oid_to_hex(&o->oid));
779                 }
780                 deepen_by_rev_list(av.argc, av.argv, shallows);
781                 argv_array_clear(&av);
782                 ret = 1;
783         } else {
784                 if (shallows->nr > 0) {
785                         int i;
786                         for (i = 0; i < shallows->nr; i++)
787                                 register_shallow(the_repository,
788                                                  &shallows->objects[i].item->oid);
789                 }
790         }
791
792         shallow_nr += shallows->nr;
793         return ret;
794 }
795
796 static int process_shallow(const char *line, struct object_array *shallows)
797 {
798         const char *arg;
799         if (skip_prefix(line, "shallow ", &arg)) {
800                 struct object_id oid;
801                 struct object *object;
802                 if (get_oid_hex(arg, &oid))
803                         die("invalid shallow line: %s", line);
804                 object = parse_object(the_repository, &oid);
805                 if (!object)
806                         return 1;
807                 if (object->type != OBJ_COMMIT)
808                         die("invalid shallow object %s", oid_to_hex(&oid));
809                 if (!(object->flags & CLIENT_SHALLOW)) {
810                         object->flags |= CLIENT_SHALLOW;
811                         add_object_array(object, NULL, shallows);
812                 }
813                 return 1;
814         }
815
816         return 0;
817 }
818
819 static int process_deepen(const char *line, int *depth)
820 {
821         const char *arg;
822         if (skip_prefix(line, "deepen ", &arg)) {
823                 char *end = NULL;
824                 *depth = (int)strtol(arg, &end, 0);
825                 if (!end || *end || *depth <= 0)
826                         die("Invalid deepen: %s", line);
827                 return 1;
828         }
829
830         return 0;
831 }
832
833 static int process_deepen_since(const char *line, timestamp_t *deepen_since, int *deepen_rev_list)
834 {
835         const char *arg;
836         if (skip_prefix(line, "deepen-since ", &arg)) {
837                 char *end = NULL;
838                 *deepen_since = parse_timestamp(arg, &end, 0);
839                 if (!end || *end || !deepen_since ||
840                     /* revisions.c's max_age -1 is special */
841                     *deepen_since == -1)
842                         die("Invalid deepen-since: %s", line);
843                 *deepen_rev_list = 1;
844                 return 1;
845         }
846         return 0;
847 }
848
849 static int process_deepen_not(const char *line, struct string_list *deepen_not, int *deepen_rev_list)
850 {
851         const char *arg;
852         if (skip_prefix(line, "deepen-not ", &arg)) {
853                 char *ref = NULL;
854                 struct object_id oid;
855                 if (expand_ref(arg, strlen(arg), &oid, &ref) != 1)
856                         die("git upload-pack: ambiguous deepen-not: %s", line);
857                 string_list_append(deepen_not, ref);
858                 free(ref);
859                 *deepen_rev_list = 1;
860                 return 1;
861         }
862         return 0;
863 }
864
865 static void receive_needs(void)
866 {
867         struct object_array shallows = OBJECT_ARRAY_INIT;
868         struct string_list deepen_not = STRING_LIST_INIT_DUP;
869         int depth = 0;
870         int has_non_tip = 0;
871         timestamp_t deepen_since = 0;
872         int deepen_rev_list = 0;
873
874         shallow_nr = 0;
875         for (;;) {
876                 struct object *o;
877                 const char *features;
878                 struct object_id oid_buf;
879                 char *line = packet_read_line(0, NULL);
880                 const char *arg;
881
882                 reset_timeout();
883                 if (!line)
884                         break;
885
886                 if (process_shallow(line, &shallows))
887                         continue;
888                 if (process_deepen(line, &depth))
889                         continue;
890                 if (process_deepen_since(line, &deepen_since, &deepen_rev_list))
891                         continue;
892                 if (process_deepen_not(line, &deepen_not, &deepen_rev_list))
893                         continue;
894
895                 if (skip_prefix(line, "filter ", &arg)) {
896                         if (!filter_capability_requested)
897                                 die("git upload-pack: filtering capability not negotiated");
898                         parse_list_objects_filter(&filter_options, arg);
899                         continue;
900                 }
901
902                 if (!skip_prefix(line, "want ", &arg) ||
903                     parse_oid_hex(arg, &oid_buf, &features))
904                         die("git upload-pack: protocol error, "
905                             "expected to get object ID, not '%s'", line);
906
907                 if (parse_feature_request(features, "deepen-relative"))
908                         deepen_relative = 1;
909                 if (parse_feature_request(features, "multi_ack_detailed"))
910                         multi_ack = 2;
911                 else if (parse_feature_request(features, "multi_ack"))
912                         multi_ack = 1;
913                 if (parse_feature_request(features, "no-done"))
914                         no_done = 1;
915                 if (parse_feature_request(features, "thin-pack"))
916                         use_thin_pack = 1;
917                 if (parse_feature_request(features, "ofs-delta"))
918                         use_ofs_delta = 1;
919                 if (parse_feature_request(features, "side-band-64k"))
920                         use_sideband = LARGE_PACKET_MAX;
921                 else if (parse_feature_request(features, "side-band"))
922                         use_sideband = DEFAULT_PACKET_MAX;
923                 if (parse_feature_request(features, "no-progress"))
924                         no_progress = 1;
925                 if (parse_feature_request(features, "include-tag"))
926                         use_include_tag = 1;
927                 if (allow_filter && parse_feature_request(features, "filter"))
928                         filter_capability_requested = 1;
929
930                 o = parse_object(the_repository, &oid_buf);
931                 if (!o) {
932                         packet_write_fmt(1,
933                                          "ERR upload-pack: not our ref %s",
934                                          oid_to_hex(&oid_buf));
935                         die("git upload-pack: not our ref %s",
936                             oid_to_hex(&oid_buf));
937                 }
938                 if (!(o->flags & WANTED)) {
939                         o->flags |= WANTED;
940                         if (!((allow_unadvertised_object_request & ALLOW_ANY_SHA1) == ALLOW_ANY_SHA1
941                               || is_our_ref(o)))
942                                 has_non_tip = 1;
943                         add_object_array(o, NULL, &want_obj);
944                 }
945         }
946
947         /*
948          * We have sent all our refs already, and the other end
949          * should have chosen out of them. When we are operating
950          * in the stateless RPC mode, however, their choice may
951          * have been based on the set of older refs advertised
952          * by another process that handled the initial request.
953          */
954         if (has_non_tip)
955                 check_non_tip();
956
957         if (!use_sideband && daemon_mode)
958                 no_progress = 1;
959
960         if (depth == 0 && !deepen_rev_list && shallows.nr == 0)
961                 return;
962
963         if (send_shallow_list(depth, deepen_rev_list, deepen_since,
964                               &deepen_not, &shallows))
965                 packet_flush(1);
966         object_array_clear(&shallows);
967 }
968
969 /* return non-zero if the ref is hidden, otherwise 0 */
970 static int mark_our_ref(const char *refname, const char *refname_full,
971                         const struct object_id *oid)
972 {
973         struct object *o = lookup_unknown_object(oid->hash);
974
975         if (ref_is_hidden(refname, refname_full)) {
976                 o->flags |= HIDDEN_REF;
977                 return 1;
978         }
979         o->flags |= OUR_REF;
980         return 0;
981 }
982
983 static int check_ref(const char *refname_full, const struct object_id *oid,
984                      int flag, void *cb_data)
985 {
986         const char *refname = strip_namespace(refname_full);
987
988         mark_our_ref(refname, refname_full, oid);
989         return 0;
990 }
991
992 static void format_symref_info(struct strbuf *buf, struct string_list *symref)
993 {
994         struct string_list_item *item;
995
996         if (!symref->nr)
997                 return;
998         for_each_string_list_item(item, symref)
999                 strbuf_addf(buf, " symref=%s:%s", item->string, (char *)item->util);
1000 }
1001
1002 static int send_ref(const char *refname, const struct object_id *oid,
1003                     int flag, void *cb_data)
1004 {
1005         static const char *capabilities = "multi_ack thin-pack side-band"
1006                 " side-band-64k ofs-delta shallow deepen-since deepen-not"
1007                 " deepen-relative no-progress include-tag multi_ack_detailed";
1008         const char *refname_nons = strip_namespace(refname);
1009         struct object_id peeled;
1010
1011         if (mark_our_ref(refname_nons, refname, oid))
1012                 return 0;
1013
1014         if (capabilities) {
1015                 struct strbuf symref_info = STRBUF_INIT;
1016
1017                 format_symref_info(&symref_info, cb_data);
1018                 packet_write_fmt(1, "%s %s%c%s%s%s%s%s%s agent=%s\n",
1019                              oid_to_hex(oid), refname_nons,
1020                              0, capabilities,
1021                              (allow_unadvertised_object_request & ALLOW_TIP_SHA1) ?
1022                                      " allow-tip-sha1-in-want" : "",
1023                              (allow_unadvertised_object_request & ALLOW_REACHABLE_SHA1) ?
1024                                      " allow-reachable-sha1-in-want" : "",
1025                              stateless_rpc ? " no-done" : "",
1026                              symref_info.buf,
1027                              allow_filter ? " filter" : "",
1028                              git_user_agent_sanitized());
1029                 strbuf_release(&symref_info);
1030         } else {
1031                 packet_write_fmt(1, "%s %s\n", oid_to_hex(oid), refname_nons);
1032         }
1033         capabilities = NULL;
1034         if (!peel_ref(refname, &peeled))
1035                 packet_write_fmt(1, "%s %s^{}\n", oid_to_hex(&peeled), refname_nons);
1036         return 0;
1037 }
1038
1039 static int find_symref(const char *refname, const struct object_id *oid,
1040                        int flag, void *cb_data)
1041 {
1042         const char *symref_target;
1043         struct string_list_item *item;
1044
1045         if ((flag & REF_ISSYMREF) == 0)
1046                 return 0;
1047         symref_target = resolve_ref_unsafe(refname, 0, NULL, &flag);
1048         if (!symref_target || (flag & REF_ISSYMREF) == 0)
1049                 die("'%s' is a symref but it is not?", refname);
1050         item = string_list_append(cb_data, refname);
1051         item->util = xstrdup(symref_target);
1052         return 0;
1053 }
1054
1055 static int upload_pack_config(const char *var, const char *value, void *unused)
1056 {
1057         if (!strcmp("uploadpack.allowtipsha1inwant", var)) {
1058                 if (git_config_bool(var, value))
1059                         allow_unadvertised_object_request |= ALLOW_TIP_SHA1;
1060                 else
1061                         allow_unadvertised_object_request &= ~ALLOW_TIP_SHA1;
1062         } else if (!strcmp("uploadpack.allowreachablesha1inwant", var)) {
1063                 if (git_config_bool(var, value))
1064                         allow_unadvertised_object_request |= ALLOW_REACHABLE_SHA1;
1065                 else
1066                         allow_unadvertised_object_request &= ~ALLOW_REACHABLE_SHA1;
1067         } else if (!strcmp("uploadpack.allowanysha1inwant", var)) {
1068                 if (git_config_bool(var, value))
1069                         allow_unadvertised_object_request |= ALLOW_ANY_SHA1;
1070                 else
1071                         allow_unadvertised_object_request &= ~ALLOW_ANY_SHA1;
1072         } else if (!strcmp("uploadpack.keepalive", var)) {
1073                 keepalive = git_config_int(var, value);
1074                 if (!keepalive)
1075                         keepalive = -1;
1076         } else if (current_config_scope() != CONFIG_SCOPE_REPO) {
1077                 if (!strcmp("uploadpack.packobjectshook", var))
1078                         return git_config_string(&pack_objects_hook, var, value);
1079         } else if (!strcmp("uploadpack.allowfilter", var)) {
1080                 allow_filter = git_config_bool(var, value);
1081         }
1082         return parse_hide_refs_config(var, value, "uploadpack");
1083 }
1084
1085 void upload_pack(struct upload_pack_options *options)
1086 {
1087         struct string_list symref = STRING_LIST_INIT_DUP;
1088
1089         stateless_rpc = options->stateless_rpc;
1090         timeout = options->timeout;
1091         daemon_mode = options->daemon_mode;
1092
1093         git_config(upload_pack_config, NULL);
1094
1095         head_ref_namespaced(find_symref, &symref);
1096
1097         if (options->advertise_refs || !stateless_rpc) {
1098                 reset_timeout();
1099                 head_ref_namespaced(send_ref, &symref);
1100                 for_each_namespaced_ref(send_ref, &symref);
1101                 advertise_shallow_grafts(1);
1102                 packet_flush(1);
1103         } else {
1104                 head_ref_namespaced(check_ref, NULL);
1105                 for_each_namespaced_ref(check_ref, NULL);
1106         }
1107         string_list_clear(&symref, 1);
1108         if (options->advertise_refs)
1109                 return;
1110
1111         receive_needs();
1112         if (want_obj.nr) {
1113                 get_common_commits();
1114                 create_pack_file();
1115         }
1116 }
1117
1118 struct upload_pack_data {
1119         struct object_array wants;
1120         struct oid_array haves;
1121
1122         struct object_array shallows;
1123         struct string_list deepen_not;
1124         int depth;
1125         timestamp_t deepen_since;
1126         int deepen_rev_list;
1127         int deepen_relative;
1128
1129         unsigned stateless_rpc : 1;
1130
1131         unsigned use_thin_pack : 1;
1132         unsigned use_ofs_delta : 1;
1133         unsigned no_progress : 1;
1134         unsigned use_include_tag : 1;
1135         unsigned done : 1;
1136 };
1137
1138 static void upload_pack_data_init(struct upload_pack_data *data)
1139 {
1140         struct object_array wants = OBJECT_ARRAY_INIT;
1141         struct oid_array haves = OID_ARRAY_INIT;
1142         struct object_array shallows = OBJECT_ARRAY_INIT;
1143         struct string_list deepen_not = STRING_LIST_INIT_DUP;
1144
1145         memset(data, 0, sizeof(*data));
1146         data->wants = wants;
1147         data->haves = haves;
1148         data->shallows = shallows;
1149         data->deepen_not = deepen_not;
1150 }
1151
1152 static void upload_pack_data_clear(struct upload_pack_data *data)
1153 {
1154         object_array_clear(&data->wants);
1155         oid_array_clear(&data->haves);
1156         object_array_clear(&data->shallows);
1157         string_list_clear(&data->deepen_not, 0);
1158 }
1159
1160 static int parse_want(const char *line)
1161 {
1162         const char *arg;
1163         if (skip_prefix(line, "want ", &arg)) {
1164                 struct object_id oid;
1165                 struct object *o;
1166
1167                 if (get_oid_hex(arg, &oid))
1168                         die("git upload-pack: protocol error, "
1169                             "expected to get oid, not '%s'", line);
1170
1171                 o = parse_object(the_repository, &oid);
1172                 if (!o) {
1173                         packet_write_fmt(1,
1174                                          "ERR upload-pack: not our ref %s",
1175                                          oid_to_hex(&oid));
1176                         die("git upload-pack: not our ref %s",
1177                             oid_to_hex(&oid));
1178                 }
1179
1180                 if (!(o->flags & WANTED)) {
1181                         o->flags |= WANTED;
1182                         add_object_array(o, NULL, &want_obj);
1183                 }
1184
1185                 return 1;
1186         }
1187
1188         return 0;
1189 }
1190
1191 static int parse_have(const char *line, struct oid_array *haves)
1192 {
1193         const char *arg;
1194         if (skip_prefix(line, "have ", &arg)) {
1195                 struct object_id oid;
1196
1197                 if (get_oid_hex(arg, &oid))
1198                         die("git upload-pack: expected SHA1 object, got '%s'", arg);
1199                 oid_array_append(haves, &oid);
1200                 return 1;
1201         }
1202
1203         return 0;
1204 }
1205
1206 static void process_args(struct packet_reader *request,
1207                          struct upload_pack_data *data)
1208 {
1209         while (packet_reader_read(request) != PACKET_READ_FLUSH) {
1210                 const char *arg = request->line;
1211                 const char *p;
1212
1213                 /* process want */
1214                 if (parse_want(arg))
1215                         continue;
1216                 /* process have line */
1217                 if (parse_have(arg, &data->haves))
1218                         continue;
1219
1220                 /* process args like thin-pack */
1221                 if (!strcmp(arg, "thin-pack")) {
1222                         use_thin_pack = 1;
1223                         continue;
1224                 }
1225                 if (!strcmp(arg, "ofs-delta")) {
1226                         use_ofs_delta = 1;
1227                         continue;
1228                 }
1229                 if (!strcmp(arg, "no-progress")) {
1230                         no_progress = 1;
1231                         continue;
1232                 }
1233                 if (!strcmp(arg, "include-tag")) {
1234                         use_include_tag = 1;
1235                         continue;
1236                 }
1237                 if (!strcmp(arg, "done")) {
1238                         data->done = 1;
1239                         continue;
1240                 }
1241
1242                 /* Shallow related arguments */
1243                 if (process_shallow(arg, &data->shallows))
1244                         continue;
1245                 if (process_deepen(arg, &data->depth))
1246                         continue;
1247                 if (process_deepen_since(arg, &data->deepen_since,
1248                                          &data->deepen_rev_list))
1249                         continue;
1250                 if (process_deepen_not(arg, &data->deepen_not,
1251                                        &data->deepen_rev_list))
1252                         continue;
1253                 if (!strcmp(arg, "deepen-relative")) {
1254                         data->deepen_relative = 1;
1255                         continue;
1256                 }
1257
1258                 if (allow_filter && skip_prefix(arg, "filter ", &p)) {
1259                         parse_list_objects_filter(&filter_options, p);
1260                         continue;
1261                 }
1262
1263                 /* ignore unknown lines maybe? */
1264                 die("unexpected line: '%s'", arg);
1265         }
1266 }
1267
1268 static int process_haves(struct oid_array *haves, struct oid_array *common)
1269 {
1270         int i;
1271
1272         /* Process haves */
1273         for (i = 0; i < haves->nr; i++) {
1274                 const struct object_id *oid = &haves->oid[i];
1275                 struct object *o;
1276                 int we_knew_they_have = 0;
1277
1278                 if (!has_object_file(oid))
1279                         continue;
1280
1281                 oid_array_append(common, oid);
1282
1283                 o = parse_object(the_repository, oid);
1284                 if (!o)
1285                         die("oops (%s)", oid_to_hex(oid));
1286                 if (o->type == OBJ_COMMIT) {
1287                         struct commit_list *parents;
1288                         struct commit *commit = (struct commit *)o;
1289                         if (o->flags & THEY_HAVE)
1290                                 we_knew_they_have = 1;
1291                         else
1292                                 o->flags |= THEY_HAVE;
1293                         if (!oldest_have || (commit->date < oldest_have))
1294                                 oldest_have = commit->date;
1295                         for (parents = commit->parents;
1296                              parents;
1297                              parents = parents->next)
1298                                 parents->item->object.flags |= THEY_HAVE;
1299                 }
1300                 if (!we_knew_they_have)
1301                         add_object_array(o, NULL, &have_obj);
1302         }
1303
1304         return 0;
1305 }
1306
1307 static int send_acks(struct oid_array *acks, struct strbuf *response)
1308 {
1309         int i;
1310
1311         packet_buf_write(response, "acknowledgments\n");
1312
1313         /* Send Acks */
1314         if (!acks->nr)
1315                 packet_buf_write(response, "NAK\n");
1316
1317         for (i = 0; i < acks->nr; i++) {
1318                 packet_buf_write(response, "ACK %s\n",
1319                                  oid_to_hex(&acks->oid[i]));
1320         }
1321
1322         if (ok_to_give_up()) {
1323                 /* Send Ready */
1324                 packet_buf_write(response, "ready\n");
1325                 return 1;
1326         }
1327
1328         return 0;
1329 }
1330
1331 static int process_haves_and_send_acks(struct upload_pack_data *data)
1332 {
1333         struct oid_array common = OID_ARRAY_INIT;
1334         struct strbuf response = STRBUF_INIT;
1335         int ret = 0;
1336
1337         process_haves(&data->haves, &common);
1338         if (data->done) {
1339                 ret = 1;
1340         } else if (send_acks(&common, &response)) {
1341                 packet_buf_delim(&response);
1342                 ret = 1;
1343         } else {
1344                 /* Add Flush */
1345                 packet_buf_flush(&response);
1346                 ret = 0;
1347         }
1348
1349         /* Send response */
1350         write_or_die(1, response.buf, response.len);
1351         strbuf_release(&response);
1352
1353         oid_array_clear(&data->haves);
1354         oid_array_clear(&common);
1355         return ret;
1356 }
1357
1358 static void send_shallow_info(struct upload_pack_data *data)
1359 {
1360         /* No shallow info needs to be sent */
1361         if (!data->depth && !data->deepen_rev_list && !data->shallows.nr &&
1362             !is_repository_shallow(the_repository))
1363                 return;
1364
1365         packet_write_fmt(1, "shallow-info\n");
1366
1367         if (!send_shallow_list(data->depth, data->deepen_rev_list,
1368                                data->deepen_since, &data->deepen_not,
1369                                &data->shallows) &&
1370             is_repository_shallow(the_repository))
1371                 deepen(INFINITE_DEPTH, data->deepen_relative, &data->shallows);
1372
1373         packet_delim(1);
1374 }
1375
1376 enum fetch_state {
1377         FETCH_PROCESS_ARGS = 0,
1378         FETCH_SEND_ACKS,
1379         FETCH_SEND_PACK,
1380         FETCH_DONE,
1381 };
1382
1383 int upload_pack_v2(struct repository *r, struct argv_array *keys,
1384                    struct packet_reader *request)
1385 {
1386         enum fetch_state state = FETCH_PROCESS_ARGS;
1387         struct upload_pack_data data;
1388
1389         git_config(upload_pack_config, NULL);
1390
1391         upload_pack_data_init(&data);
1392         use_sideband = LARGE_PACKET_MAX;
1393
1394         while (state != FETCH_DONE) {
1395                 switch (state) {
1396                 case FETCH_PROCESS_ARGS:
1397                         process_args(request, &data);
1398
1399                         if (!want_obj.nr) {
1400                                 /*
1401                                  * Request didn't contain any 'want' lines,
1402                                  * guess they didn't want anything.
1403                                  */
1404                                 state = FETCH_DONE;
1405                         } else if (data.haves.nr) {
1406                                 /*
1407                                  * Request had 'have' lines, so lets ACK them.
1408                                  */
1409                                 state = FETCH_SEND_ACKS;
1410                         } else {
1411                                 /*
1412                                  * Request had 'want's but no 'have's so we can
1413                                  * immedietly go to construct and send a pack.
1414                                  */
1415                                 state = FETCH_SEND_PACK;
1416                         }
1417                         break;
1418                 case FETCH_SEND_ACKS:
1419                         if (process_haves_and_send_acks(&data))
1420                                 state = FETCH_SEND_PACK;
1421                         else
1422                                 state = FETCH_DONE;
1423                         break;
1424                 case FETCH_SEND_PACK:
1425                         send_shallow_info(&data);
1426
1427                         packet_write_fmt(1, "packfile\n");
1428                         create_pack_file();
1429                         state = FETCH_DONE;
1430                         break;
1431                 case FETCH_DONE:
1432                         continue;
1433                 }
1434         }
1435
1436         upload_pack_data_clear(&data);
1437         return 0;
1438 }
1439
1440 int upload_pack_advertise(struct repository *r,
1441                           struct strbuf *value)
1442 {
1443         if (value) {
1444                 int allow_filter_value;
1445                 strbuf_addstr(value, "shallow");
1446                 if (!repo_config_get_bool(the_repository,
1447                                          "uploadpack.allowfilter",
1448                                          &allow_filter_value) &&
1449                     allow_filter_value)
1450                         strbuf_addstr(value, " filter");
1451         }
1452         return 1;
1453 }