upload-pack: add deepen-since to cut shallow repos based on time
[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
3f0f6624 455static int has_unreachable(struct object_array *src)
051e4005
JH
456{
457 static const char *argv[] = {
458 "rev-list", "--stdin", NULL,
459 };
d3180279 460 static struct child_process cmd = CHILD_PROCESS_INIT;
051e4005
JH
461 struct object *o;
462 char namebuf[42]; /* ^ + SHA-1 + LF */
463 int i;
464
051e4005
JH
465 cmd.argv = argv;
466 cmd.git_cmd = 1;
467 cmd.no_stderr = 1;
468 cmd.in = -1;
469 cmd.out = -1;
470
051e4005 471 /*
7fcbd37f
NTND
472 * If the next rev-list --stdin encounters an unknown commit,
473 * it terminates, which will cause SIGPIPE in the write loop
051e4005
JH
474 * below.
475 */
476 sigchain_push(SIGPIPE, SIG_IGN);
477
7fcbd37f
NTND
478 if (start_command(&cmd))
479 goto error;
480
051e4005
JH
481 namebuf[0] = '^';
482 namebuf[41] = '\n';
483 for (i = get_max_object_index(); 0 < i; ) {
484 o = get_indexed_object(--i);
2a745324
BH
485 if (!o)
486 continue;
390eb36b 487 if (!is_our_ref(o))
051e4005 488 continue;
f2fd0760 489 memcpy(namebuf + 1, oid_to_hex(&o->oid), GIT_SHA1_HEXSZ);
051e4005
JH
490 if (write_in_full(cmd.in, namebuf, 42) < 0)
491 goto error;
492 }
493 namebuf[40] = '\n';
3f0f6624
NTND
494 for (i = 0; i < src->nr; i++) {
495 o = src->objects[i].item;
390eb36b 496 if (is_our_ref(o))
051e4005 497 continue;
f2fd0760 498 memcpy(namebuf, oid_to_hex(&o->oid), GIT_SHA1_HEXSZ);
051e4005
JH
499 if (write_in_full(cmd.in, namebuf, 41) < 0)
500 goto error;
501 }
502 close(cmd.in);
7fcbd37f 503 cmd.in = -1;
051e4005
JH
504
505 /*
506 * The commits out of the rev-list are not ancestors of
507 * our ref.
508 */
509 i = read_in_full(cmd.out, namebuf, 1);
510 if (i)
511 goto error;
512 close(cmd.out);
7fcbd37f 513 cmd.out = -1;
051e4005
JH
514
515 /*
516 * rev-list may have died by encountering a bad commit
517 * in the history, in which case we do want to bail out
518 * even when it showed no commit.
519 */
520 if (finish_command(&cmd))
521 goto error;
522
7fcbd37f
NTND
523 sigchain_pop(SIGPIPE);
524
051e4005 525 /* All the non-tip ones are ancestors of what we advertised */
3f0f6624 526 return 0;
051e4005
JH
527
528error:
7fcbd37f
NTND
529 sigchain_pop(SIGPIPE);
530
531 if (cmd.in >= 0)
532 close(cmd.in);
533 if (cmd.out >= 0)
534 close(cmd.out);
3f0f6624
NTND
535 return 1;
536}
7fcbd37f 537
3f0f6624
NTND
538static void check_non_tip(void)
539{
540 int i;
541
542 /*
543 * In the normal in-process case without
544 * uploadpack.allowReachableSHA1InWant,
545 * non-tip requests can never happen.
546 */
547 if (!stateless_rpc && !(allow_unadvertised_object_request & ALLOW_REACHABLE_SHA1))
548 goto error;
549 if (!has_unreachable(&want_obj))
550 /* All the non-tip ones are ancestors of what we advertised */
551 return;
552
553error:
051e4005
JH
554 /* Pick one of them (we know there at least is one) */
555 for (i = 0; i < want_obj.nr; i++) {
3f0f6624 556 struct object *o = want_obj.objects[i].item;
390eb36b 557 if (!is_our_ref(o))
051e4005 558 die("git upload-pack: not our ref %s",
f2fd0760 559 oid_to_hex(&o->oid));
051e4005
JH
560 }
561}
562
5c24cdea
NTND
563static void send_shallow(struct commit_list *result)
564{
565 while (result) {
566 struct object *object = &result->item->object;
567 if (!(object->flags & (CLIENT_SHALLOW|NOT_SHALLOW))) {
568 packet_write(1, "shallow %s",
569 oid_to_hex(&object->oid));
570 register_shallow(object->oid.hash);
571 shallow_nr++;
572 }
573 result = result->next;
574 }
575}
576
873700c9 577static void send_unshallow(const struct object_array *shallows)
e8e44de7 578{
e8e44de7 579 int i;
873700c9 580
e8e44de7
NTND
581 for (i = 0; i < shallows->nr; i++) {
582 struct object *object = shallows->objects[i].item;
583 if (object->flags & NOT_SHALLOW) {
584 struct commit_list *parents;
585 packet_write(1, "unshallow %s",
586 oid_to_hex(&object->oid));
587 object->flags &= ~CLIENT_SHALLOW;
873700c9
NTND
588 /*
589 * We want to _register_ "object" as shallow, but we
590 * also need to traverse object's parents to deepen a
591 * shallow clone. Unregister it for now so we can
592 * parse and add the parents to the want list, then
593 * re-register it.
594 */
e8e44de7
NTND
595 unregister_shallow(object->oid.hash);
596 object->parsed = 0;
597 parse_commit_or_die((struct commit *)object);
598 parents = ((struct commit *)object)->parents;
599 while (parents) {
600 add_object_array(&parents->item->object,
601 NULL, &want_obj);
602 parents = parents->next;
603 }
604 add_object_array(object, NULL, &extra_edge_obj);
605 }
606 /* make sure commit traversal conforms to client */
607 register_shallow(object->oid.hash);
608 }
873700c9
NTND
609}
610
611static void deepen(int depth, const struct object_array *shallows)
612{
613 if (depth == INFINITE_DEPTH && !is_repository_shallow()) {
614 int i;
615
616 for (i = 0; i < shallows->nr; i++) {
617 struct object *object = shallows->objects[i].item;
618 object->flags |= NOT_SHALLOW;
619 }
620 } else {
621 struct commit_list *result;
622
623 result = get_shallow_commits(&want_obj, depth,
624 SHALLOW, NOT_SHALLOW);
625 send_shallow(result);
626 free_commit_list(result);
627 }
628
629 send_unshallow(shallows);
e8e44de7
NTND
630 packet_flush(1);
631}
632
569e554b
NTND
633static void deepen_by_rev_list(int ac, const char **av,
634 struct object_array *shallows)
635{
636 struct commit_list *result;
637
638 result = get_shallow_commits_by_rev_list(ac, av, SHALLOW, NOT_SHALLOW);
639 send_shallow(result);
640 free_commit_list(result);
641 send_unshallow(shallows);
642 packet_flush(1);
643}
644
b1e9fff7 645static void receive_needs(void)
fb9040cc 646{
3cd47459 647 struct object_array shallows = OBJECT_ARRAY_INIT;
74543a04 648 int depth = 0;
051e4005 649 int has_non_tip = 0;
569e554b
NTND
650 unsigned long deepen_since = 0;
651 int deepen_rev_list = 0;
fb9040cc 652
f0cea83f 653 shallow_nr = 0;
fb9040cc 654 for (;;) {
565ebbf7 655 struct object *o;
f47182c8 656 const char *features;
6ece0d30 657 unsigned char sha1_buf[20];
74543a04 658 char *line = packet_read_line(0, NULL);
8bf3b758
NTND
659 const char *arg;
660
960deccb 661 reset_timeout();
74543a04 662 if (!line)
ed09aef0 663 break;
e091eb93 664
8bf3b758 665 if (skip_prefix(line, "shallow ", &arg)) {
ed09aef0
JS
666 unsigned char sha1[20];
667 struct object *object;
8bf3b758 668 if (get_sha1_hex(arg, sha1))
ed09aef0
JS
669 die("invalid shallow line: %s", line);
670 object = parse_object(sha1);
671 if (!object)
af04fa2a 672 continue;
6293ded3
NTND
673 if (object->type != OBJ_COMMIT)
674 die("invalid shallow object %s", sha1_to_hex(sha1));
e58e57e4
JK
675 if (!(object->flags & CLIENT_SHALLOW)) {
676 object->flags |= CLIENT_SHALLOW;
677 add_object_array(object, NULL, &shallows);
678 }
ed09aef0
JS
679 continue;
680 }
8bf3b758 681 if (skip_prefix(line, "deepen ", &arg)) {
6e414e30 682 char *end = NULL;
8bf3b758 683 depth = strtol(arg, &end, 0);
6e414e30 684 if (!end || *end || depth <= 0)
016e6ccb
JS
685 die("Invalid deepen: %s", line);
686 continue;
687 }
569e554b
NTND
688 if (skip_prefix(line, "deepen-since ", &arg)) {
689 char *end = NULL;
690 deepen_since = strtoul(arg, &end, 0);
691 if (!end || *end || !deepen_since ||
692 /* revisions.c's max_age -1 is special */
693 deepen_since == -1)
694 die("Invalid deepen-since: %s", line);
695 deepen_rev_list = 1;
696 continue;
697 }
8bf3b758
NTND
698 if (!skip_prefix(line, "want ", &arg) ||
699 get_sha1_hex(arg, sha1_buf))
7e44c935 700 die("git upload-pack: protocol error, "
e091eb93 701 "expected to get sha, not '%s'", line);
f47182c8 702
8bf3b758 703 features = arg + 40;
f47182c8
JH
704
705 if (parse_feature_request(features, "multi_ack_detailed"))
78affc49 706 multi_ack = 2;
f47182c8 707 else if (parse_feature_request(features, "multi_ack"))
1bd8c8f0 708 multi_ack = 1;
f47182c8 709 if (parse_feature_request(features, "no-done"))
4e10cf9a 710 no_done = 1;
f47182c8 711 if (parse_feature_request(features, "thin-pack"))
b19696c2 712 use_thin_pack = 1;
f47182c8 713 if (parse_feature_request(features, "ofs-delta"))
e4fe4b8e 714 use_ofs_delta = 1;
f47182c8 715 if (parse_feature_request(features, "side-band-64k"))
d47f3db7 716 use_sideband = LARGE_PACKET_MAX;
f47182c8 717 else if (parse_feature_request(features, "side-band"))
d47f3db7 718 use_sideband = DEFAULT_PACKET_MAX;
f47182c8 719 if (parse_feature_request(features, "no-progress"))
b0e90897 720 no_progress = 1;
f47182c8 721 if (parse_feature_request(features, "include-tag"))
348e390b 722 use_include_tag = 1;
565ebbf7 723
f59de5d1 724 o = parse_object(sha1_buf);
051e4005 725 if (!o)
9f9aa761
EN
726 die("git upload-pack: not our ref %s",
727 sha1_to_hex(sha1_buf));
565ebbf7
JH
728 if (!(o->flags & WANTED)) {
729 o->flags |= WANTED;
390eb36b 730 if (!is_our_ref(o))
051e4005 731 has_non_tip = 1;
b1e9fff7 732 add_object_array(o, NULL, &want_obj);
565ebbf7 733 }
fb9040cc 734 }
9462e3f5 735
051e4005
JH
736 /*
737 * We have sent all our refs already, and the other end
738 * should have chosen out of them. When we are operating
739 * in the stateless RPC mode, however, their choice may
740 * have been based on the set of older refs advertised
741 * by another process that handled the initial request.
742 */
743 if (has_non_tip)
744 check_non_tip();
745
9462e3f5
JS
746 if (!use_sideband && daemon_mode)
747 no_progress = 1;
748
569e554b 749 if (depth == 0 && !deepen_rev_list && shallows.nr == 0)
f53514bc 750 return;
569e554b
NTND
751 if (depth > 0 && deepen_rev_list)
752 die("git upload-pack: deepen and deepen-since cannot be used together");
e8e44de7
NTND
753 if (depth > 0)
754 deepen(depth, &shallows);
569e554b
NTND
755 else if (deepen_rev_list) {
756 struct argv_array av = ARGV_ARRAY_INIT;
757 int i;
758
759 argv_array_push(&av, "rev-list");
760 if (deepen_since)
761 argv_array_pushf(&av, "--max-age=%lu", deepen_since);
762 for (i = 0; i < want_obj.nr; i++) {
763 struct object *o = want_obj.objects[i].item;
764 argv_array_push(&av, oid_to_hex(&o->oid));
765 }
766 deepen_by_rev_list(av.argc, av.argv, &shallows);
767 argv_array_clear(&av);
768 }
e8e44de7 769 else
f53514bc
JS
770 if (shallows.nr > 0) {
771 int i;
772 for (i = 0; i < shallows.nr; i++)
ed1c9977 773 register_shallow(shallows.objects[i].item->oid.hash);
f53514bc 774 }
f0cea83f
NE
775
776 shallow_nr += shallows.nr;
f53514bc 777 free(shallows.objects);
fb9040cc
LT
778}
779
daebaa78 780/* return non-zero if the ref is hidden, otherwise 0 */
78a766ab
LF
781static int mark_our_ref(const char *refname, const char *refname_full,
782 const struct object_id *oid)
cbbe50db 783{
363e98bf 784 struct object *o = lookup_unknown_object(oid->hash);
daebaa78 785
78a766ab 786 if (ref_is_hidden(refname, refname_full)) {
390eb36b 787 o->flags |= HIDDEN_REF;
daebaa78 788 return 1;
390eb36b 789 }
3f1da57f 790 o->flags |= OUR_REF;
cbbe50db
JH
791 return 0;
792}
793
78a766ab 794static int check_ref(const char *refname_full, const struct object_id *oid,
363e98bf 795 int flag, void *cb_data)
e172755b 796{
78a766ab
LF
797 const char *refname = strip_namespace(refname_full);
798
799 mark_our_ref(refname, refname_full, oid);
e172755b
JK
800 return 0;
801}
802
7171d8c1
JH
803static void format_symref_info(struct strbuf *buf, struct string_list *symref)
804{
805 struct string_list_item *item;
806
807 if (!symref->nr)
808 return;
809 for_each_string_list_item(item, symref)
810 strbuf_addf(buf, " symref=%s:%s", item->string, (char *)item->util);
811}
812
363e98bf
MH
813static int send_ref(const char *refname, const struct object_id *oid,
814 int flag, void *cb_data)
def88e9a 815{
ed09aef0 816 static const char *capabilities = "multi_ack thin-pack side-band"
569e554b 817 " side-band-64k ofs-delta shallow deepen-since no-progress"
78affc49 818 " include-tag multi_ack_detailed";
6b01ecfe 819 const char *refname_nons = strip_namespace(refname);
21758aff 820 struct object_id peeled;
b5b16990 821
78a766ab 822 if (mark_our_ref(refname_nons, refname, oid))
daebaa78 823 return 0;
cbbe50db 824
7171d8c1
JH
825 if (capabilities) {
826 struct strbuf symref_info = STRBUF_INIT;
827
828 format_symref_info(&symref_info, cb_data);
68ee6289 829 packet_write(1, "%s %s%c%s%s%s%s%s agent=%s\n",
363e98bf 830 oid_to_hex(oid), refname_nons,
cf2ad8e6 831 0, capabilities,
7199c093
FM
832 (allow_unadvertised_object_request & ALLOW_TIP_SHA1) ?
833 " allow-tip-sha1-in-want" : "",
68ee6289
FM
834 (allow_unadvertised_object_request & ALLOW_REACHABLE_SHA1) ?
835 " allow-reachable-sha1-in-want" : "",
ff5effdf 836 stateless_rpc ? " no-done" : "",
7171d8c1 837 symref_info.buf,
ff5effdf 838 git_user_agent_sanitized());
7171d8c1
JH
839 strbuf_release(&symref_info);
840 } else {
363e98bf 841 packet_write(1, "%s %s\n", oid_to_hex(oid), refname_nons);
7171d8c1 842 }
1f5881bb 843 capabilities = NULL;
21758aff
MH
844 if (!peel_ref(refname, peeled.hash))
845 packet_write(1, "%s %s^{}\n", oid_to_hex(&peeled), refname_nons);
def88e9a
LT
846 return 0;
847}
848
7dabd056
MH
849static int find_symref(const char *refname, const struct object_id *oid,
850 int flag, void *cb_data)
7171d8c1
JH
851{
852 const char *symref_target;
853 struct string_list_item *item;
e45a4949 854 struct object_id unused;
7171d8c1
JH
855
856 if ((flag & REF_ISSYMREF) == 0)
857 return 0;
e45a4949 858 symref_target = resolve_ref_unsafe(refname, 0, unused.hash, &flag);
7171d8c1
JH
859 if (!symref_target || (flag & REF_ISSYMREF) == 0)
860 die("'%s' is a symref but it is not?", refname);
861 item = string_list_append(cb_data, refname);
862 item->util = xstrdup(symref_target);
863 return 0;
864}
865
59076eba 866static void upload_pack(void)
def88e9a 867{
7171d8c1
JH
868 struct string_list symref = STRING_LIST_INIT_DUP;
869
870 head_ref_namespaced(find_symref, &symref);
871
42526b47
SP
872 if (advertise_refs || !stateless_rpc) {
873 reset_timeout();
7171d8c1
JH
874 head_ref_namespaced(send_ref, &symref);
875 for_each_namespaced_ref(send_ref, &symref);
ad491366 876 advertise_shallow_grafts(1);
42526b47
SP
877 packet_flush(1);
878 } else {
e172755b
JK
879 head_ref_namespaced(check_ref, NULL);
880 for_each_namespaced_ref(check_ref, NULL);
42526b47 881 }
7171d8c1 882 string_list_clear(&symref, 1);
42526b47
SP
883 if (advertise_refs)
884 return;
885
b1e9fff7 886 receive_needs();
59076eba
DR
887 if (want_obj.nr) {
888 get_common_commits();
889 create_pack_file();
890 }
def88e9a
LT
891}
892
daebaa78
JH
893static int upload_pack_config(const char *var, const char *value, void *unused)
894{
7199c093
FM
895 if (!strcmp("uploadpack.allowtipsha1inwant", var)) {
896 if (git_config_bool(var, value))
897 allow_unadvertised_object_request |= ALLOW_TIP_SHA1;
898 else
899 allow_unadvertised_object_request &= ~ALLOW_TIP_SHA1;
68ee6289
FM
900 } else if (!strcmp("uploadpack.allowreachablesha1inwant", var)) {
901 if (git_config_bool(var, value))
902 allow_unadvertised_object_request |= ALLOW_REACHABLE_SHA1;
903 else
904 allow_unadvertised_object_request &= ~ALLOW_REACHABLE_SHA1;
7199c093 905 } else if (!strcmp("uploadpack.keepalive", var)) {
05e95155
JK
906 keepalive = git_config_int(var, value);
907 if (!keepalive)
908 keepalive = -1;
909 }
daebaa78
JH
910 return parse_hide_refs_config(var, value, "uploadpack");
911}
912
def88e9a
LT
913int main(int argc, char **argv)
914{
8d630132 915 char *dir;
960deccb
PA
916 int i;
917 int strict = 0;
918
5e9637c6
ÆAB
919 git_setup_gettext();
920
bbc30f99 921 packet_trace_identity("upload-pack");
2fb3f6db 922 git_extract_argv0_path(argv[0]);
afc711b8 923 check_replace_refs = 0;
2fb3f6db 924
960deccb 925 for (i = 1; i < argc; i++) {
8bf3b758 926 const char *arg = argv[i];
960deccb
PA
927
928 if (arg[0] != '-')
929 break;
42526b47
SP
930 if (!strcmp(arg, "--advertise-refs")) {
931 advertise_refs = 1;
932 continue;
933 }
934 if (!strcmp(arg, "--stateless-rpc")) {
935 stateless_rpc = 1;
936 continue;
937 }
960deccb
PA
938 if (!strcmp(arg, "--strict")) {
939 strict = 1;
940 continue;
941 }
8bf3b758
NTND
942 if (skip_prefix(arg, "--timeout=", &arg)) {
943 timeout = atoi(arg);
9462e3f5 944 daemon_mode = 1;
960deccb
PA
945 continue;
946 }
947 if (!strcmp(arg, "--")) {
948 i++;
949 break;
950 }
951 }
a6080a0a 952
960deccb 953 if (i != argc-1)
def88e9a 954 usage(upload_pack_usage);
04b33055 955
e1464ca7 956 setup_path();
04b33055 957
960deccb 958 dir = argv[i];
113b9475 959
8d630132 960 if (!enter_repo(dir, strict))
05ac6b34 961 die("'%s' does not appear to be a git repository", dir);
ad491366 962
daebaa78 963 git_config(upload_pack_config, NULL);
def88e9a
LT
964 upload_pack();
965 return 0;
966}