upload-pack: split check_unreachable() in two, prep for get_reachable_list()
[git/git.git] / upload-pack.c
CommitLineData
def88e9a
LT
1#include "cache.h"
2#include "refs.h"
3#include "pkt-line.h"
958c24b1 4#include "sideband.h"
f6b42a81
JH
5#include "tag.h"
6#include "object.h"
f0243f26 7#include "commit.h"
77cb17e9 8#include "exec_cmd.h"
9b8dc263
JS
9#include "diff.h"
10#include "revision.h"
11#include "list-objects.h"
cc41fa8d 12#include "run-command.h"
47a59185 13#include "connect.h"
051e4005 14#include "sigchain.h"
ff5effdf 15#include "version.h"
daebaa78 16#include "string-list.h"
569e554b 17#include "argv-array.h"
def88e9a 18
62b4698e 19static const char upload_pack_usage[] = "git upload-pack [--strict] [--timeout=<n>] <dir>";
def88e9a 20
208acbfb 21/* Remember to update object flag allocation in object.h */
937a515a
JH
22#define THEY_HAVE (1u << 11)
23#define OUR_REF (1u << 12)
24#define WANTED (1u << 13)
25#define COMMON_KNOWN (1u << 14)
26#define REACHABLE (1u << 15)
27
f53514bc
JS
28#define SHALLOW (1u << 16)
29#define NOT_SHALLOW (1u << 17)
30#define CLIENT_SHALLOW (1u << 18)
390eb36b 31#define HIDDEN_REF (1u << 19)
f53514bc 32
3fbe2d54 33static unsigned long oldest_have;
937a515a 34
3f1da57f 35static int multi_ack;
4e10cf9a 36static int no_done;
348e390b 37static int use_thin_pack, use_ofs_delta, use_include_tag;
9462e3f5 38static int no_progress, daemon_mode;
7199c093
FM
39/* Allow specifying sha1 if it is a ref tip. */
40#define ALLOW_TIP_SHA1 01
68ee6289
FM
41/* Allow request of a sha1 if it is reachable from a ref (possibly hidden ref). */
42#define ALLOW_REACHABLE_SHA1 02
7199c093 43static unsigned int allow_unadvertised_object_request;
f0cea83f 44static int shallow_nr;
b1e9fff7
JH
45static struct object_array have_obj;
46static struct object_array want_obj;
6523078b 47static struct object_array extra_edge_obj;
96f1e58f 48static unsigned int timeout;
115dedd7 49static int keepalive = 5;
d47f3db7
JH
50/* 0 for no sideband,
51 * otherwise maximum packet size (up to 65520 bytes).
52 */
96f1e58f 53static int use_sideband;
42526b47
SP
54static int advertise_refs;
55static int stateless_rpc;
960deccb
PA
56
57static void reset_timeout(void)
58{
59 alarm(timeout);
60}
fb9040cc 61
583b7ea3
JH
62static ssize_t send_client_data(int fd, const char *data, ssize_t sz)
63{
958c24b1 64 if (use_sideband)
d47f3db7 65 return send_sideband(1, fd, data, sz, use_sideband);
958c24b1
JH
66 if (fd == 3)
67 /* emergency quit */
68 fd = 2;
69 if (fd == 2) {
93822c22 70 /* XXX: are we happy to lose stuff here? */
958c24b1
JH
71 xwrite(fd, data, sz);
72 return sz;
583b7ea3 73 }
cdf4fb8e
JK
74 write_or_die(fd, data, sz);
75 return sz;
583b7ea3
JH
76}
77
b790e0f6
NTND
78static int write_one_shallow(const struct commit_graft *graft, void *cb_data)
79{
80 FILE *fp = cb_data;
81 if (graft->nr_parent == -1)
7683e2e6 82 fprintf(fp, "--shallow %s\n", oid_to_hex(&graft->oid));
b790e0f6
NTND
83 return 0;
84}
85
fb9040cc
LT
86static void create_pack_file(void)
87{
d3180279 88 struct child_process pack_objects = CHILD_PROCESS_INIT;
363b7817 89 char data[8193], progress[128];
583b7ea3
JH
90 char abort_msg[] = "aborting due to possible repository "
91 "corruption on the remote side.";
b1c71b72 92 int buffered = -1;
1456b043 93 ssize_t sz;
2dacf26d 94 const char *argv[13];
cdab4858
NTND
95 int i, arg = 0;
96 FILE *pipe_fd;
75bfc6c2 97
cdab4858 98 if (shallow_nr) {
cdab4858 99 argv[arg++] = "--shallow-file";
b790e0f6 100 argv[arg++] = "";
f0cea83f 101 }
cdab4858
NTND
102 argv[arg++] = "pack-objects";
103 argv[arg++] = "--revs";
104 if (use_thin_pack)
105 argv[arg++] = "--thin";
75bfc6c2 106
cc41fa8d 107 argv[arg++] = "--stdout";
2dacf26d 108 if (shallow_nr)
109 argv[arg++] = "--shallow";
cc41fa8d
JS
110 if (!no_progress)
111 argv[arg++] = "--progress";
112 if (use_ofs_delta)
113 argv[arg++] = "--delta-base-offset";
348e390b
SP
114 if (use_include_tag)
115 argv[arg++] = "--include-tag";
cc41fa8d
JS
116 argv[arg++] = NULL;
117
b9612197 118 pack_objects.in = -1;
cc41fa8d
JS
119 pack_objects.out = -1;
120 pack_objects.err = -1;
121 pack_objects.git_cmd = 1;
122 pack_objects.argv = argv;
21edd3f1 123
4c324c00 124 if (start_command(&pack_objects))
7e44c935 125 die("git upload-pack: unable to fork git-pack-objects");
b1c71b72 126
cdab4858
NTND
127 pipe_fd = xfdopen(pack_objects.in, "w");
128
b790e0f6
NTND
129 if (shallow_nr)
130 for_each_commit_graft(write_one_shallow, pipe_fd);
131
cdab4858
NTND
132 for (i = 0; i < want_obj.nr; i++)
133 fprintf(pipe_fd, "%s\n",
f2fd0760 134 oid_to_hex(&want_obj.objects[i].item->oid));
cdab4858
NTND
135 fprintf(pipe_fd, "--not\n");
136 for (i = 0; i < have_obj.nr; i++)
137 fprintf(pipe_fd, "%s\n",
f2fd0760 138 oid_to_hex(&have_obj.objects[i].item->oid));
cdab4858
NTND
139 for (i = 0; i < extra_edge_obj.nr; i++)
140 fprintf(pipe_fd, "%s\n",
f2fd0760 141 oid_to_hex(&extra_edge_obj.objects[i].item->oid));
cdab4858
NTND
142 fprintf(pipe_fd, "\n");
143 fflush(pipe_fd);
144 fclose(pipe_fd);
f0cea83f 145
cc41fa8d
JS
146 /* We read from pack_objects.err to capture stderr output for
147 * progress bar, and pack_objects.out to capture the pack data.
b1c71b72 148 */
b1c71b72
JH
149
150 while (1) {
b1c71b72 151 struct pollfd pfd[2];
363b7817 152 int pe, pu, pollsize;
05e95155 153 int ret;
b1c71b72 154
0d516ada
ML
155 reset_timeout();
156
b1c71b72 157 pollsize = 0;
363b7817 158 pe = pu = -1;
b1c71b72 159
cc41fa8d
JS
160 if (0 <= pack_objects.out) {
161 pfd[pollsize].fd = pack_objects.out;
b1c71b72
JH
162 pfd[pollsize].events = POLLIN;
163 pu = pollsize;
164 pollsize++;
165 }
cc41fa8d
JS
166 if (0 <= pack_objects.err) {
167 pfd[pollsize].fd = pack_objects.err;
363b7817
JH
168 pfd[pollsize].events = POLLIN;
169 pe = pollsize;
170 pollsize++;
171 }
b1c71b72 172
4c324c00
JS
173 if (!pollsize)
174 break;
175
6c71f8b0
ET
176 ret = poll(pfd, pollsize,
177 keepalive < 0 ? -1 : 1000 * keepalive);
178
05e95155 179 if (ret < 0) {
4c324c00
JS
180 if (errno != EINTR) {
181 error("poll failed, resuming: %s",
182 strerror(errno));
183 sleep(1);
b1c71b72 184 }
4c324c00
JS
185 continue;
186 }
6b59f51b
NP
187 if (0 <= pe && (pfd[pe].revents & (POLLIN|POLLHUP))) {
188 /* Status ready; we ship that in the side-band
189 * or dump to the standard error.
190 */
191 sz = xread(pack_objects.err, progress,
192 sizeof(progress));
193 if (0 < sz)
194 send_client_data(2, progress, sz);
195 else if (sz == 0) {
196 close(pack_objects.err);
197 pack_objects.err = -1;
198 }
199 else
200 goto fail;
201 /* give priority to status messages */
202 continue;
203 }
4c324c00
JS
204 if (0 <= pu && (pfd[pu].revents & (POLLIN|POLLHUP))) {
205 /* Data ready; we keep the last byte to ourselves
206 * in case we detect broken rev-list, so that we
207 * can leave the stream corrupted. This is
208 * unfortunate -- unpack-objects would happily
209 * accept a valid packdata with trailing garbage,
210 * so appending garbage after we pass all the
211 * pack data is not good enough to signal
212 * breakage to downstream.
213 */
214 char *cp = data;
215 ssize_t outsz = 0;
216 if (0 <= buffered) {
217 *cp++ = buffered;
218 outsz++;
b1c71b72 219 }
4c324c00
JS
220 sz = xread(pack_objects.out, cp,
221 sizeof(data) - outsz);
222 if (0 < sz)
1456b043 223 ;
4c324c00
JS
224 else if (sz == 0) {
225 close(pack_objects.out);
226 pack_objects.out = -1;
363b7817 227 }
4c324c00
JS
228 else
229 goto fail;
230 sz += outsz;
231 if (1 < sz) {
232 buffered = data[sz-1] & 0xFF;
233 sz--;
b1c71b72 234 }
4c324c00
JS
235 else
236 buffered = -1;
237 sz = send_client_data(1, data, sz);
238 if (sz < 0)
b1c71b72 239 goto fail;
4c324c00 240 }
05e95155
JK
241
242 /*
243 * We hit the keepalive timeout without saying anything; send
244 * an empty message on the data sideband just to let the other
245 * side know we're still working on it, but don't have any data
246 * yet.
247 *
248 * If we don't have a sideband channel, there's no room in the
249 * protocol to say anything, so those clients are just out of
250 * luck.
251 */
252 if (!ret && use_sideband) {
253 static const char buf[] = "0005\1";
254 write_or_die(1, buf, 5);
255 }
4c324c00 256 }
b1c71b72 257
4c324c00 258 if (finish_command(&pack_objects)) {
7e44c935 259 error("git upload-pack: git-pack-objects died with error.");
4c324c00
JS
260 goto fail;
261 }
b1c71b72 262
4c324c00
JS
263 /* flush the data */
264 if (0 <= buffered) {
265 data[0] = buffered;
266 sz = send_client_data(1, data, 1);
267 if (sz < 0)
268 goto fail;
269 fprintf(stderr, "flushed.\n");
b1c71b72 270 }
4c324c00
JS
271 if (use_sideband)
272 packet_flush(1);
273 return;
274
b1c71b72 275 fail:
583b7ea3 276 send_client_data(3, abort_msg, sizeof(abort_msg));
7e44c935 277 die("git upload-pack: %s", abort_msg);
fb9040cc
LT
278}
279
8bf3b758 280static int got_sha1(const char *hex, unsigned char *sha1)
def88e9a 281{
b1e9fff7 282 struct object *o;
937a515a 283 int we_knew_they_have = 0;
b1e9fff7 284
def88e9a 285 if (get_sha1_hex(hex, sha1))
7e44c935 286 die("git upload-pack: expected SHA1 object, got '%s'", hex);
fb9040cc 287 if (!has_sha1_file(sha1))
937a515a 288 return -1;
b1e9fff7 289
a6eec126 290 o = parse_object(sha1);
b1e9fff7
JH
291 if (!o)
292 die("oops (%s)", sha1_to_hex(sha1));
182a8dab 293 if (o->type == OBJ_COMMIT) {
b1e9fff7 294 struct commit_list *parents;
937a515a 295 struct commit *commit = (struct commit *)o;
b1e9fff7 296 if (o->flags & THEY_HAVE)
937a515a
JH
297 we_knew_they_have = 1;
298 else
299 o->flags |= THEY_HAVE;
300 if (!oldest_have || (commit->date < oldest_have))
301 oldest_have = commit->date;
302 for (parents = commit->parents;
b1e9fff7
JH
303 parents;
304 parents = parents->next)
305 parents->item->object.flags |= THEY_HAVE;
fb9040cc 306 }
937a515a
JH
307 if (!we_knew_they_have) {
308 add_object_array(o, NULL, &have_obj);
309 return 1;
310 }
311 return 0;
312}
313
314static int reachable(struct commit *want)
315{
316 struct commit_list *work = NULL;
317
47e44ed1 318 commit_list_insert_by_date(want, &work);
937a515a 319 while (work) {
e510ab89
RS
320 struct commit_list *list;
321 struct commit *commit = pop_commit(&work);
937a515a
JH
322
323 if (commit->object.flags & THEY_HAVE) {
324 want->object.flags |= COMMON_KNOWN;
325 break;
326 }
327 if (!commit->object.parsed)
ed1c9977 328 parse_object(commit->object.oid.hash);
937a515a
JH
329 if (commit->object.flags & REACHABLE)
330 continue;
331 commit->object.flags |= REACHABLE;
332 if (commit->date < oldest_have)
333 continue;
334 for (list = commit->parents; list; list = list->next) {
335 struct commit *parent = list->item;
336 if (!(parent->object.flags & REACHABLE))
47e44ed1 337 commit_list_insert_by_date(parent, &work);
937a515a
JH
338 }
339 }
340 want->object.flags |= REACHABLE;
341 clear_commit_marks(want, REACHABLE);
342 free_commit_list(work);
343 return (want->object.flags & COMMON_KNOWN);
344}
345
346static int ok_to_give_up(void)
347{
348 int i;
349
350 if (!have_obj.nr)
351 return 0;
352
353 for (i = 0; i < want_obj.nr; i++) {
354 struct object *want = want_obj.objects[i].item;
355
356 if (want->flags & COMMON_KNOWN)
357 continue;
358 want = deref_tag(want, "a want line", 0);
359 if (!want || want->type != OBJ_COMMIT) {
360 /* no way to tell if this is reachable by
361 * looking at the ancestry chain alone, so
362 * leave a note to ourselves not to worry about
363 * this object anymore.
364 */
365 want_obj.objects[i].item->flags |= COMMON_KNOWN;
366 continue;
367 }
368 if (!reachable((struct commit *)want))
369 return 0;
370 }
fb9040cc 371 return 1;
def88e9a
LT
372}
373
374static int get_common_commits(void)
375{
c04c4e57 376 unsigned char sha1[20];
78affc49 377 char last_hex[41];
49bee717
SP
378 int got_common = 0;
379 int got_other = 0;
4e10cf9a 380 int sent_ready = 0;
def88e9a 381
f0243f26
JS
382 save_commit_buffer = 0;
383
eeefa7c9 384 for (;;) {
74543a04 385 char *line = packet_read_line(0, NULL);
8bf3b758
NTND
386 const char *arg;
387
960deccb 388 reset_timeout();
def88e9a 389
74543a04 390 if (!line) {
49bee717 391 if (multi_ack == 2 && got_common
4e10cf9a
JH
392 && !got_other && ok_to_give_up()) {
393 sent_ready = 1;
49bee717 394 packet_write(1, "ACK %s ready\n", last_hex);
4e10cf9a 395 }
b1e9fff7 396 if (have_obj.nr == 0 || multi_ack)
1bd8c8f0 397 packet_write(1, "NAK\n");
4e10cf9a
JH
398
399 if (no_done && sent_ready) {
400 packet_write(1, "ACK %s\n", last_hex);
401 return 0;
402 }
42526b47
SP
403 if (stateless_rpc)
404 exit(0);
49bee717
SP
405 got_common = 0;
406 got_other = 0;
def88e9a
LT
407 continue;
408 }
8bf3b758
NTND
409 if (skip_prefix(line, "have ", &arg)) {
410 switch (got_sha1(arg, sha1)) {
937a515a 411 case -1: /* they have what we do not */
49bee717 412 got_other = 1;
78affc49
SP
413 if (multi_ack && ok_to_give_up()) {
414 const char *hex = sha1_to_hex(sha1);
4e10cf9a
JH
415 if (multi_ack == 2) {
416 sent_ready = 1;
78affc49 417 packet_write(1, "ACK %s ready\n", hex);
4e10cf9a 418 } else
78affc49
SP
419 packet_write(1, "ACK %s continue\n", hex);
420 }
937a515a
JH
421 break;
422 default:
49bee717 423 got_common = 1;
78affc49
SP
424 memcpy(last_hex, sha1_to_hex(sha1), 41);
425 if (multi_ack == 2)
426 packet_write(1, "ACK %s common\n", last_hex);
427 else if (multi_ack)
428 packet_write(1, "ACK %s continue\n", last_hex);
c04c4e57 429 else if (have_obj.nr == 1)
78affc49 430 packet_write(1, "ACK %s\n", last_hex);
937a515a 431 break;
af2d3aa4 432 }
def88e9a
LT
433 continue;
434 }
435 if (!strcmp(line, "done")) {
b1e9fff7 436 if (have_obj.nr > 0) {
1bd8c8f0 437 if (multi_ack)
c04c4e57 438 packet_write(1, "ACK %s\n", last_hex);
1bd8c8f0
JS
439 return 0;
440 }
def88e9a
LT
441 packet_write(1, "NAK\n");
442 return -1;
443 }
7e44c935 444 die("git upload-pack: expected SHA1 list, got '%s'", line);
def88e9a 445 }
def88e9a
LT
446}
447
390eb36b
JH
448static int is_our_ref(struct object *o)
449{
68ee6289
FM
450 int allow_hidden_ref = (allow_unadvertised_object_request &
451 (ALLOW_TIP_SHA1 | ALLOW_REACHABLE_SHA1));
7199c093 452 return o->flags & ((allow_hidden_ref ? HIDDEN_REF : 0) | OUR_REF);
390eb36b
JH
453}
454
2997178e
NTND
455/*
456 * on successful case, it's up to the caller to close cmd->out
457 */
458static int do_reachable_revlist(struct child_process *cmd,
459 struct object_array *src)
051e4005
JH
460{
461 static const char *argv[] = {
462 "rev-list", "--stdin", NULL,
463 };
051e4005
JH
464 struct object *o;
465 char namebuf[42]; /* ^ + SHA-1 + LF */
466 int i;
467
2997178e
NTND
468 cmd->argv = argv;
469 cmd->git_cmd = 1;
470 cmd->no_stderr = 1;
471 cmd->in = -1;
472 cmd->out = -1;
051e4005 473
051e4005 474 /*
7fcbd37f
NTND
475 * If the next rev-list --stdin encounters an unknown commit,
476 * it terminates, which will cause SIGPIPE in the write loop
051e4005
JH
477 * below.
478 */
479 sigchain_push(SIGPIPE, SIG_IGN);
480
2997178e 481 if (start_command(cmd))
7fcbd37f
NTND
482 goto error;
483
051e4005
JH
484 namebuf[0] = '^';
485 namebuf[41] = '\n';
486 for (i = get_max_object_index(); 0 < i; ) {
487 o = get_indexed_object(--i);
2a745324
BH
488 if (!o)
489 continue;
390eb36b 490 if (!is_our_ref(o))
051e4005 491 continue;
f2fd0760 492 memcpy(namebuf + 1, oid_to_hex(&o->oid), GIT_SHA1_HEXSZ);
2997178e 493 if (write_in_full(cmd->in, namebuf, 42) < 0)
051e4005
JH
494 goto error;
495 }
496 namebuf[40] = '\n';
3f0f6624
NTND
497 for (i = 0; i < src->nr; i++) {
498 o = src->objects[i].item;
390eb36b 499 if (is_our_ref(o))
051e4005 500 continue;
f2fd0760 501 memcpy(namebuf, oid_to_hex(&o->oid), GIT_SHA1_HEXSZ);
2997178e 502 if (write_in_full(cmd->in, namebuf, 41) < 0)
051e4005
JH
503 goto error;
504 }
2997178e
NTND
505 close(cmd->in);
506 cmd->in = -1;
507 sigchain_pop(SIGPIPE);
508
509 return 0;
510
511error:
512 sigchain_pop(SIGPIPE);
513
514 if (cmd->in >= 0)
515 close(cmd->in);
516 if (cmd->out >= 0)
517 close(cmd->out);
518 return -1;
519}
520
521static int has_unreachable(struct object_array *src)
522{
523 struct child_process cmd = CHILD_PROCESS_INIT;
524 char buf[1];
525 int i;
526
527 if (do_reachable_revlist(&cmd, src) < 0)
528 return 1;
051e4005
JH
529
530 /*
531 * The commits out of the rev-list are not ancestors of
532 * our ref.
533 */
2997178e 534 i = read_in_full(cmd.out, buf, 1);
051e4005
JH
535 if (i)
536 goto error;
537 close(cmd.out);
7fcbd37f 538 cmd.out = -1;
051e4005
JH
539
540 /*
541 * rev-list may have died by encountering a bad commit
542 * in the history, in which case we do want to bail out
543 * even when it showed no commit.
544 */
545 if (finish_command(&cmd))
546 goto error;
547
548 /* All the non-tip ones are ancestors of what we advertised */
3f0f6624 549 return 0;
051e4005
JH
550
551error:
7fcbd37f 552 sigchain_pop(SIGPIPE);
7fcbd37f
NTND
553 if (cmd.out >= 0)
554 close(cmd.out);
3f0f6624
NTND
555 return 1;
556}
7fcbd37f 557
3f0f6624
NTND
558static void check_non_tip(void)
559{
560 int i;
561
562 /*
563 * In the normal in-process case without
564 * uploadpack.allowReachableSHA1InWant,
565 * non-tip requests can never happen.
566 */
567 if (!stateless_rpc && !(allow_unadvertised_object_request & ALLOW_REACHABLE_SHA1))
568 goto error;
569 if (!has_unreachable(&want_obj))
570 /* All the non-tip ones are ancestors of what we advertised */
571 return;
572
573error:
051e4005
JH
574 /* Pick one of them (we know there at least is one) */
575 for (i = 0; i < want_obj.nr; i++) {
3f0f6624 576 struct object *o = want_obj.objects[i].item;
390eb36b 577 if (!is_our_ref(o))
051e4005 578 die("git upload-pack: not our ref %s",
f2fd0760 579 oid_to_hex(&o->oid));
051e4005
JH
580 }
581}
582
5c24cdea
NTND
583static void send_shallow(struct commit_list *result)
584{
585 while (result) {
586 struct object *object = &result->item->object;
587 if (!(object->flags & (CLIENT_SHALLOW|NOT_SHALLOW))) {
588 packet_write(1, "shallow %s",
589 oid_to_hex(&object->oid));
590 register_shallow(object->oid.hash);
591 shallow_nr++;
592 }
593 result = result->next;
594 }
595}
596
873700c9 597static void send_unshallow(const struct object_array *shallows)
e8e44de7 598{
e8e44de7 599 int i;
873700c9 600
e8e44de7
NTND
601 for (i = 0; i < shallows->nr; i++) {
602 struct object *object = shallows->objects[i].item;
603 if (object->flags & NOT_SHALLOW) {
604 struct commit_list *parents;
605 packet_write(1, "unshallow %s",
606 oid_to_hex(&object->oid));
607 object->flags &= ~CLIENT_SHALLOW;
873700c9
NTND
608 /*
609 * We want to _register_ "object" as shallow, but we
610 * also need to traverse object's parents to deepen a
611 * shallow clone. Unregister it for now so we can
612 * parse and add the parents to the want list, then
613 * re-register it.
614 */
e8e44de7
NTND
615 unregister_shallow(object->oid.hash);
616 object->parsed = 0;
617 parse_commit_or_die((struct commit *)object);
618 parents = ((struct commit *)object)->parents;
619 while (parents) {
620 add_object_array(&parents->item->object,
621 NULL, &want_obj);
622 parents = parents->next;
623 }
624 add_object_array(object, NULL, &extra_edge_obj);
625 }
626 /* make sure commit traversal conforms to client */
627 register_shallow(object->oid.hash);
628 }
873700c9
NTND
629}
630
631static void deepen(int depth, const struct object_array *shallows)
632{
633 if (depth == INFINITE_DEPTH && !is_repository_shallow()) {
634 int i;
635
636 for (i = 0; i < shallows->nr; i++) {
637 struct object *object = shallows->objects[i].item;
638 object->flags |= NOT_SHALLOW;
639 }
640 } else {
641 struct commit_list *result;
642
643 result = get_shallow_commits(&want_obj, depth,
644 SHALLOW, NOT_SHALLOW);
645 send_shallow(result);
646 free_commit_list(result);
647 }
648
649 send_unshallow(shallows);
e8e44de7
NTND
650 packet_flush(1);
651}
652
569e554b
NTND
653static void deepen_by_rev_list(int ac, const char **av,
654 struct object_array *shallows)
655{
656 struct commit_list *result;
657
658 result = get_shallow_commits_by_rev_list(ac, av, SHALLOW, NOT_SHALLOW);
659 send_shallow(result);
660 free_commit_list(result);
661 send_unshallow(shallows);
662 packet_flush(1);
663}
664
b1e9fff7 665static void receive_needs(void)
fb9040cc 666{
3cd47459 667 struct object_array shallows = OBJECT_ARRAY_INIT;
269a7a83 668 struct string_list deepen_not = STRING_LIST_INIT_DUP;
74543a04 669 int depth = 0;
051e4005 670 int has_non_tip = 0;
569e554b
NTND
671 unsigned long deepen_since = 0;
672 int deepen_rev_list = 0;
fb9040cc 673
f0cea83f 674 shallow_nr = 0;
fb9040cc 675 for (;;) {
565ebbf7 676 struct object *o;
f47182c8 677 const char *features;
6ece0d30 678 unsigned char sha1_buf[20];
74543a04 679 char *line = packet_read_line(0, NULL);
8bf3b758
NTND
680 const char *arg;
681
960deccb 682 reset_timeout();
74543a04 683 if (!line)
ed09aef0 684 break;
e091eb93 685
8bf3b758 686 if (skip_prefix(line, "shallow ", &arg)) {
ed09aef0
JS
687 unsigned char sha1[20];
688 struct object *object;
8bf3b758 689 if (get_sha1_hex(arg, sha1))
ed09aef0
JS
690 die("invalid shallow line: %s", line);
691 object = parse_object(sha1);
692 if (!object)
af04fa2a 693 continue;
6293ded3
NTND
694 if (object->type != OBJ_COMMIT)
695 die("invalid shallow object %s", sha1_to_hex(sha1));
e58e57e4
JK
696 if (!(object->flags & CLIENT_SHALLOW)) {
697 object->flags |= CLIENT_SHALLOW;
698 add_object_array(object, NULL, &shallows);
699 }
ed09aef0
JS
700 continue;
701 }
8bf3b758 702 if (skip_prefix(line, "deepen ", &arg)) {
6e414e30 703 char *end = NULL;
8bf3b758 704 depth = strtol(arg, &end, 0);
6e414e30 705 if (!end || *end || depth <= 0)
016e6ccb
JS
706 die("Invalid deepen: %s", line);
707 continue;
708 }
569e554b
NTND
709 if (skip_prefix(line, "deepen-since ", &arg)) {
710 char *end = NULL;
711 deepen_since = strtoul(arg, &end, 0);
712 if (!end || *end || !deepen_since ||
713 /* revisions.c's max_age -1 is special */
714 deepen_since == -1)
715 die("Invalid deepen-since: %s", line);
716 deepen_rev_list = 1;
717 continue;
718 }
269a7a83
NTND
719 if (skip_prefix(line, "deepen-not ", &arg)) {
720 char *ref = NULL;
721 unsigned char sha1[20];
722 if (expand_ref(arg, strlen(arg), sha1, &ref) != 1)
723 die("git upload-pack: ambiguous deepen-not: %s", line);
724 string_list_append(&deepen_not, ref);
725 free(ref);
726 deepen_rev_list = 1;
727 continue;
728 }
8bf3b758
NTND
729 if (!skip_prefix(line, "want ", &arg) ||
730 get_sha1_hex(arg, sha1_buf))
7e44c935 731 die("git upload-pack: protocol error, "
e091eb93 732 "expected to get sha, not '%s'", line);
f47182c8 733
8bf3b758 734 features = arg + 40;
f47182c8
JH
735
736 if (parse_feature_request(features, "multi_ack_detailed"))
78affc49 737 multi_ack = 2;
f47182c8 738 else if (parse_feature_request(features, "multi_ack"))
1bd8c8f0 739 multi_ack = 1;
f47182c8 740 if (parse_feature_request(features, "no-done"))
4e10cf9a 741 no_done = 1;
f47182c8 742 if (parse_feature_request(features, "thin-pack"))
b19696c2 743 use_thin_pack = 1;
f47182c8 744 if (parse_feature_request(features, "ofs-delta"))
e4fe4b8e 745 use_ofs_delta = 1;
f47182c8 746 if (parse_feature_request(features, "side-band-64k"))
d47f3db7 747 use_sideband = LARGE_PACKET_MAX;
f47182c8 748 else if (parse_feature_request(features, "side-band"))
d47f3db7 749 use_sideband = DEFAULT_PACKET_MAX;
f47182c8 750 if (parse_feature_request(features, "no-progress"))
b0e90897 751 no_progress = 1;
f47182c8 752 if (parse_feature_request(features, "include-tag"))
348e390b 753 use_include_tag = 1;
565ebbf7 754
f59de5d1 755 o = parse_object(sha1_buf);
051e4005 756 if (!o)
9f9aa761
EN
757 die("git upload-pack: not our ref %s",
758 sha1_to_hex(sha1_buf));
565ebbf7
JH
759 if (!(o->flags & WANTED)) {
760 o->flags |= WANTED;
390eb36b 761 if (!is_our_ref(o))
051e4005 762 has_non_tip = 1;
b1e9fff7 763 add_object_array(o, NULL, &want_obj);
565ebbf7 764 }
fb9040cc 765 }
9462e3f5 766
051e4005
JH
767 /*
768 * We have sent all our refs already, and the other end
769 * should have chosen out of them. When we are operating
770 * in the stateless RPC mode, however, their choice may
771 * have been based on the set of older refs advertised
772 * by another process that handled the initial request.
773 */
774 if (has_non_tip)
775 check_non_tip();
776
9462e3f5
JS
777 if (!use_sideband && daemon_mode)
778 no_progress = 1;
779
569e554b 780 if (depth == 0 && !deepen_rev_list && shallows.nr == 0)
f53514bc 781 return;
569e554b 782 if (depth > 0 && deepen_rev_list)
269a7a83 783 die("git upload-pack: deepen and deepen-since (or deepen-not) cannot be used together");
e8e44de7
NTND
784 if (depth > 0)
785 deepen(depth, &shallows);
569e554b
NTND
786 else if (deepen_rev_list) {
787 struct argv_array av = ARGV_ARRAY_INIT;
788 int i;
789
790 argv_array_push(&av, "rev-list");
791 if (deepen_since)
792 argv_array_pushf(&av, "--max-age=%lu", deepen_since);
269a7a83
NTND
793 if (deepen_not.nr) {
794 argv_array_push(&av, "--not");
795 for (i = 0; i < deepen_not.nr; i++) {
796 struct string_list_item *s = deepen_not.items + i;
797 argv_array_push(&av, s->string);
798 }
799 argv_array_push(&av, "--not");
800 }
569e554b
NTND
801 for (i = 0; i < want_obj.nr; i++) {
802 struct object *o = want_obj.objects[i].item;
803 argv_array_push(&av, oid_to_hex(&o->oid));
804 }
805 deepen_by_rev_list(av.argc, av.argv, &shallows);
806 argv_array_clear(&av);
807 }
e8e44de7 808 else
f53514bc
JS
809 if (shallows.nr > 0) {
810 int i;
811 for (i = 0; i < shallows.nr; i++)
ed1c9977 812 register_shallow(shallows.objects[i].item->oid.hash);
f53514bc 813 }
f0cea83f
NE
814
815 shallow_nr += shallows.nr;
f53514bc 816 free(shallows.objects);
fb9040cc
LT
817}
818
daebaa78 819/* return non-zero if the ref is hidden, otherwise 0 */
78a766ab
LF
820static int mark_our_ref(const char *refname, const char *refname_full,
821 const struct object_id *oid)
cbbe50db 822{
363e98bf 823 struct object *o = lookup_unknown_object(oid->hash);
daebaa78 824
78a766ab 825 if (ref_is_hidden(refname, refname_full)) {
390eb36b 826 o->flags |= HIDDEN_REF;
daebaa78 827 return 1;
390eb36b 828 }
3f1da57f 829 o->flags |= OUR_REF;
cbbe50db
JH
830 return 0;
831}
832
78a766ab 833static int check_ref(const char *refname_full, const struct object_id *oid,
363e98bf 834 int flag, void *cb_data)
e172755b 835{
78a766ab
LF
836 const char *refname = strip_namespace(refname_full);
837
838 mark_our_ref(refname, refname_full, oid);
e172755b
JK
839 return 0;
840}
841
7171d8c1
JH
842static void format_symref_info(struct strbuf *buf, struct string_list *symref)
843{
844 struct string_list_item *item;
845
846 if (!symref->nr)
847 return;
848 for_each_string_list_item(item, symref)
849 strbuf_addf(buf, " symref=%s:%s", item->string, (char *)item->util);
850}
851
363e98bf
MH
852static int send_ref(const char *refname, const struct object_id *oid,
853 int flag, void *cb_data)
def88e9a 854{
ed09aef0 855 static const char *capabilities = "multi_ack thin-pack side-band"
269a7a83 856 " side-band-64k ofs-delta shallow deepen-since deepen-not no-progress"
78affc49 857 " include-tag multi_ack_detailed";
6b01ecfe 858 const char *refname_nons = strip_namespace(refname);
21758aff 859 struct object_id peeled;
b5b16990 860
78a766ab 861 if (mark_our_ref(refname_nons, refname, oid))
daebaa78 862 return 0;
cbbe50db 863
7171d8c1
JH
864 if (capabilities) {
865 struct strbuf symref_info = STRBUF_INIT;
866
867 format_symref_info(&symref_info, cb_data);
68ee6289 868 packet_write(1, "%s %s%c%s%s%s%s%s agent=%s\n",
363e98bf 869 oid_to_hex(oid), refname_nons,
cf2ad8e6 870 0, capabilities,
7199c093
FM
871 (allow_unadvertised_object_request & ALLOW_TIP_SHA1) ?
872 " allow-tip-sha1-in-want" : "",
68ee6289
FM
873 (allow_unadvertised_object_request & ALLOW_REACHABLE_SHA1) ?
874 " allow-reachable-sha1-in-want" : "",
ff5effdf 875 stateless_rpc ? " no-done" : "",
7171d8c1 876 symref_info.buf,
ff5effdf 877 git_user_agent_sanitized());
7171d8c1
JH
878 strbuf_release(&symref_info);
879 } else {
363e98bf 880 packet_write(1, "%s %s\n", oid_to_hex(oid), refname_nons);
7171d8c1 881 }
1f5881bb 882 capabilities = NULL;
21758aff
MH
883 if (!peel_ref(refname, peeled.hash))
884 packet_write(1, "%s %s^{}\n", oid_to_hex(&peeled), refname_nons);
def88e9a
LT
885 return 0;
886}
887
7dabd056
MH
888static int find_symref(const char *refname, const struct object_id *oid,
889 int flag, void *cb_data)
7171d8c1
JH
890{
891 const char *symref_target;
892 struct string_list_item *item;
e45a4949 893 struct object_id unused;
7171d8c1
JH
894
895 if ((flag & REF_ISSYMREF) == 0)
896 return 0;
e45a4949 897 symref_target = resolve_ref_unsafe(refname, 0, unused.hash, &flag);
7171d8c1
JH
898 if (!symref_target || (flag & REF_ISSYMREF) == 0)
899 die("'%s' is a symref but it is not?", refname);
900 item = string_list_append(cb_data, refname);
901 item->util = xstrdup(symref_target);
902 return 0;
903}
904
59076eba 905static void upload_pack(void)
def88e9a 906{
7171d8c1
JH
907 struct string_list symref = STRING_LIST_INIT_DUP;
908
909 head_ref_namespaced(find_symref, &symref);
910
42526b47
SP
911 if (advertise_refs || !stateless_rpc) {
912 reset_timeout();
7171d8c1
JH
913 head_ref_namespaced(send_ref, &symref);
914 for_each_namespaced_ref(send_ref, &symref);
ad491366 915 advertise_shallow_grafts(1);
42526b47
SP
916 packet_flush(1);
917 } else {
e172755b
JK
918 head_ref_namespaced(check_ref, NULL);
919 for_each_namespaced_ref(check_ref, NULL);
42526b47 920 }
7171d8c1 921 string_list_clear(&symref, 1);
42526b47
SP
922 if (advertise_refs)
923 return;
924
b1e9fff7 925 receive_needs();
59076eba
DR
926 if (want_obj.nr) {
927 get_common_commits();
928 create_pack_file();
929 }
def88e9a
LT
930}
931
daebaa78
JH
932static int upload_pack_config(const char *var, const char *value, void *unused)
933{
7199c093
FM
934 if (!strcmp("uploadpack.allowtipsha1inwant", var)) {
935 if (git_config_bool(var, value))
936 allow_unadvertised_object_request |= ALLOW_TIP_SHA1;
937 else
938 allow_unadvertised_object_request &= ~ALLOW_TIP_SHA1;
68ee6289
FM
939 } else if (!strcmp("uploadpack.allowreachablesha1inwant", var)) {
940 if (git_config_bool(var, value))
941 allow_unadvertised_object_request |= ALLOW_REACHABLE_SHA1;
942 else
943 allow_unadvertised_object_request &= ~ALLOW_REACHABLE_SHA1;
7199c093 944 } else if (!strcmp("uploadpack.keepalive", var)) {
05e95155
JK
945 keepalive = git_config_int(var, value);
946 if (!keepalive)
947 keepalive = -1;
948 }
daebaa78
JH
949 return parse_hide_refs_config(var, value, "uploadpack");
950}
951
def88e9a
LT
952int main(int argc, char **argv)
953{
8d630132 954 char *dir;
960deccb
PA
955 int i;
956 int strict = 0;
957
5e9637c6
ÆAB
958 git_setup_gettext();
959
bbc30f99 960 packet_trace_identity("upload-pack");
2fb3f6db 961 git_extract_argv0_path(argv[0]);
afc711b8 962 check_replace_refs = 0;
2fb3f6db 963
960deccb 964 for (i = 1; i < argc; i++) {
8bf3b758 965 const char *arg = argv[i];
960deccb
PA
966
967 if (arg[0] != '-')
968 break;
42526b47
SP
969 if (!strcmp(arg, "--advertise-refs")) {
970 advertise_refs = 1;
971 continue;
972 }
973 if (!strcmp(arg, "--stateless-rpc")) {
974 stateless_rpc = 1;
975 continue;
976 }
960deccb
PA
977 if (!strcmp(arg, "--strict")) {
978 strict = 1;
979 continue;
980 }
8bf3b758
NTND
981 if (skip_prefix(arg, "--timeout=", &arg)) {
982 timeout = atoi(arg);
9462e3f5 983 daemon_mode = 1;
960deccb
PA
984 continue;
985 }
986 if (!strcmp(arg, "--")) {
987 i++;
988 break;
989 }
990 }
a6080a0a 991
960deccb 992 if (i != argc-1)
def88e9a 993 usage(upload_pack_usage);
04b33055 994
e1464ca7 995 setup_path();
04b33055 996
960deccb 997 dir = argv[i];
113b9475 998
8d630132 999 if (!enter_repo(dir, strict))
05ac6b34 1000 die("'%s' does not appear to be a git repository", dir);
ad491366 1001
daebaa78 1002 git_config(upload_pack_config, NULL);
def88e9a
LT
1003 upload_pack();
1004 return 0;
1005}