Shrink "struct object" a bit
[git/git.git] / fetch-pack.c
CommitLineData
def88e9a 1#include "cache.h"
fb9040cc 2#include "refs.h"
def88e9a 3#include "pkt-line.h"
49bb805e
JH
4#include "commit.h"
5#include "tag.h"
def88e9a 6
ad897215 7static int keep_pack;
8b3d9dc0 8static int quiet;
33b83034 9static int verbose;
dfeff66e 10static int fetch_all;
33b83034 11static const char fetch_pack_usage[] =
dfeff66e 12"git-fetch-pack [--all] [-q] [-v] [-k] [--thin] [--exec=upload-pack] [host:]directory <refs>...";
def88e9a
LT
13static const char *exec = "git-upload-pack";
14
0a8944dd 15#define COMPLETE (1U << 0)
23d61f83
JS
16#define COMMON (1U << 1)
17#define COMMON_REF (1U << 2)
18#define SEEN (1U << 3)
19#define POPPED (1U << 4)
20
f061e5fd
JH
21/*
22 * After sending this many "have"s if we do not get any new ACK , we
23 * give up traversing our history.
24 */
25#define MAX_IN_VAIN 256
26
23d61f83 27static struct commit_list *rev_list = NULL;
b19696c2 28static int non_common_revs = 0, multi_ack = 0, use_thin_pack = 0;
23d61f83
JS
29
30static void rev_list_push(struct commit *commit, int mark)
31{
32 if (!(commit->object.flags & mark)) {
33 commit->object.flags |= mark;
34
35 if (!(commit->object.parsed))
36 parse_commit(commit);
37
38 insert_by_date(commit, &rev_list);
39
40 if (!(commit->object.flags & COMMON))
41 non_common_revs++;
42 }
43}
44
45static int rev_list_insert_ref(const char *path, const unsigned char *sha1)
46{
9534f40b 47 struct object *o = deref_tag(parse_object(sha1), path, 0);
23d61f83 48
885a86ab 49 if (o && o->type == TYPE_COMMIT)
23d61f83
JS
50 rev_list_push((struct commit *)o, SEEN);
51
52 return 0;
53}
54
55/*
56 This function marks a rev and its ancestors as common.
57 In some cases, it is desirable to mark only the ancestors (for example
58 when only the server does not yet know that they are common).
59*/
60
61static void mark_common(struct commit *commit,
62 int ancestors_only, int dont_parse)
63{
64 if (commit != NULL && !(commit->object.flags & COMMON)) {
65 struct object *o = (struct object *)commit;
66
67 if (!ancestors_only)
68 o->flags |= COMMON;
69
70 if (!(o->flags & SEEN))
71 rev_list_push(commit, SEEN);
72 else {
73 struct commit_list *parents;
74
75 if (!ancestors_only && !(o->flags & POPPED))
76 non_common_revs--;
77 if (!o->parsed && !dont_parse)
78 parse_commit(commit);
79
80 for (parents = commit->parents;
81 parents;
82 parents = parents->next)
83 mark_common(parents->item, 0, dont_parse);
84 }
85 }
86}
87
88/*
89 Get the next rev to send, ignoring the common.
90*/
91
962554c6 92static const unsigned char* get_rev(void)
23d61f83
JS
93{
94 struct commit *commit = NULL;
95
96 while (commit == NULL) {
97 unsigned int mark;
98 struct commit_list* parents;
99
100 if (rev_list == NULL || non_common_revs == 0)
101 return NULL;
102
103 commit = rev_list->item;
104 if (!(commit->object.parsed))
105 parse_commit(commit);
106 commit->object.flags |= POPPED;
107 if (!(commit->object.flags & COMMON))
108 non_common_revs--;
109
110 parents = commit->parents;
111
112 if (commit->object.flags & COMMON) {
113 /* do not send "have", and ignore ancestors */
114 commit = NULL;
115 mark = COMMON | SEEN;
116 } else if (commit->object.flags & COMMON_REF)
117 /* send "have", and ignore ancestors */
118 mark = COMMON | SEEN;
119 else
120 /* send "have", also for its ancestors */
121 mark = SEEN;
122
123 while (parents) {
124 if (!(parents->item->object.flags & SEEN))
125 rev_list_push(parents->item, mark);
126 if (mark & COMMON)
127 mark_common(parents->item, 1, 0);
128 parents = parents->next;
129 }
130
131 rev_list = rev_list->next;
132 }
133
134 return commit->object.sha1;
135}
0a8944dd 136
33b83034
JH
137static int find_common(int fd[2], unsigned char *result_sha1,
138 struct ref *refs)
def88e9a 139{
2759cbc7 140 int fetching;
23d61f83
JS
141 int count = 0, flushes = 0, retval;
142 const unsigned char *sha1;
f061e5fd
JH
143 unsigned in_vain = 0;
144 int got_continue = 0;
23d61f83
JS
145
146 for_each_ref(rev_list_insert_ref);
def88e9a 147
2759cbc7
LT
148 fetching = 0;
149 for ( ; refs ; refs = refs->next) {
33b83034 150 unsigned char *remote = refs->old_sha1;
4dab94d5 151 struct object *o;
2759cbc7 152
0a8944dd 153 /*
4dab94d5
JH
154 * If that object is complete (i.e. it is an ancestor of a
155 * local ref), we tell them we have it but do not have to
156 * tell them about its ancestors, which they already know
157 * about.
f1f0a2be
JH
158 *
159 * We use lookup_object here because we are only
160 * interested in the case we *know* the object is
161 * reachable and we have already scanned it.
4dab94d5 162 */
f1f0a2be 163 if (((o = lookup_object(remote)) != NULL) &&
1baaae5e 164 (o->flags & COMPLETE)) {
2759cbc7 165 continue;
0a8944dd 166 }
23d61f83 167
b19696c2
JH
168 packet_write(fd[1], "want %s%s%s\n", sha1_to_hex(remote),
169 (multi_ack ? " multi_ack" : ""),
170 (use_thin_pack ? " thin-pack" : ""));
2759cbc7 171 fetching++;
33b83034 172 }
fb9040cc 173 packet_flush(fd[1]);
2759cbc7
LT
174 if (!fetching)
175 return 1;
0a8944dd 176
23d61f83 177 flushes = 0;
75bfc6c2 178 retval = -1;
23d61f83 179 while ((sha1 = get_rev())) {
def88e9a 180 packet_write(fd[1], "have %s\n", sha1_to_hex(sha1));
33b83034
JH
181 if (verbose)
182 fprintf(stderr, "have %s\n", sha1_to_hex(sha1));
f061e5fd 183 in_vain++;
def88e9a 184 if (!(31 & ++count)) {
c4c86f07
JS
185 int ack;
186
def88e9a
LT
187 packet_flush(fd[1]);
188 flushes++;
189
190 /*
191 * We keep one window "ahead" of the other side, and
192 * will wait for an ACK only on the next one
193 */
194 if (count == 32)
195 continue;
c4c86f07
JS
196
197 do {
198 ack = get_ack(fd[0], result_sha1);
199 if (verbose && ack)
200 fprintf(stderr, "got ack %d %s\n", ack,
201 sha1_to_hex(result_sha1));
202 if (ack == 1) {
203 flushes = 0;
204 multi_ack = 0;
205 retval = 0;
206 goto done;
207 } else if (ack == 2) {
208 struct commit *commit =
209 lookup_commit(result_sha1);
210 mark_common(commit, 0, 1);
211 retval = 0;
f061e5fd
JH
212 in_vain = 0;
213 got_continue = 1;
c4c86f07
JS
214 }
215 } while (ack);
def88e9a 216 flushes--;
f061e5fd
JH
217 if (got_continue && MAX_IN_VAIN < in_vain) {
218 if (verbose)
219 fprintf(stderr, "giving up\n");
220 break; /* give up */
221 }
def88e9a
LT
222 }
223 }
c4c86f07 224done:
75bfc6c2 225 packet_write(fd[1], "done\n");
33b83034
JH
226 if (verbose)
227 fprintf(stderr, "done\n");
c4c86f07
JS
228 if (retval != 0) {
229 multi_ack = 0;
23d61f83 230 flushes++;
c4c86f07
JS
231 }
232 while (flushes || multi_ack) {
233 int ack = get_ack(fd[0], result_sha1);
234 if (ack) {
33b83034 235 if (verbose)
c4c86f07
JS
236 fprintf(stderr, "got ack (%d) %s\n", ack,
237 sha1_to_hex(result_sha1));
238 if (ack == 1)
239 return 0;
240 multi_ack = 1;
241 continue;
33b83034 242 }
c4c86f07 243 flushes--;
def88e9a 244 }
75bfc6c2 245 return retval;
def88e9a
LT
246}
247
49bb805e
JH
248static struct commit_list *complete = NULL;
249
250static int mark_complete(const char *path, const unsigned char *sha1)
251{
252 struct object *o = parse_object(sha1);
253
885a86ab 254 while (o && o->type == TYPE_TAG) {
f1f0a2be
JH
255 struct tag *t = (struct tag *) o;
256 if (!t->tagged)
257 break; /* broken repository */
49bb805e 258 o->flags |= COMPLETE;
f1f0a2be 259 o = parse_object(t->tagged->sha1);
49bb805e 260 }
885a86ab 261 if (o && o->type == TYPE_COMMIT) {
49bb805e
JH
262 struct commit *commit = (struct commit *)o;
263 commit->object.flags |= COMPLETE;
264 insert_by_date(commit, &complete);
265 }
266 return 0;
267}
268
269static void mark_recent_complete_commits(unsigned long cutoff)
270{
271 while (complete && cutoff <= complete->item->date) {
272 if (verbose)
273 fprintf(stderr, "Marking %s as complete\n",
274 sha1_to_hex(complete->item->object.sha1));
275 pop_most_recent_commit(&complete, COMPLETE);
276 }
277}
278
1baaae5e
JS
279static void filter_refs(struct ref **refs, int nr_match, char **match)
280{
9546010b
JH
281 struct ref **return_refs;
282 struct ref *newlist = NULL;
283 struct ref **newtail = &newlist;
284 struct ref *ref, *next;
285 struct ref *fastarray[32];
286
287 if (nr_match && !fetch_all) {
288 if (ARRAY_SIZE(fastarray) < nr_match)
289 return_refs = xcalloc(nr_match, sizeof(struct ref *));
290 else {
291 return_refs = fastarray;
292 memset(return_refs, 0, sizeof(struct ref *) * nr_match);
293 }
294 }
295 else
296 return_refs = NULL;
297
298 for (ref = *refs; ref; ref = next) {
299 next = ref->next;
300 if (!memcmp(ref->name, "refs/", 5) &&
301 check_ref_format(ref->name + 5))
302 ; /* trash */
303 else if (fetch_all) {
304 *newtail = ref;
305 ref->next = NULL;
306 newtail = &ref->next;
307 continue;
308 }
309 else {
310 int order = path_match(ref->name, nr_match, match);
311 if (order) {
312 return_refs[order-1] = ref;
313 continue; /* we will link it later */
314 }
315 }
316 free(ref);
317 }
318
319 if (!fetch_all) {
320 int i;
321 for (i = 0; i < nr_match; i++) {
322 ref = return_refs[i];
323 if (ref) {
324 *newtail = ref;
325 ref->next = NULL;
326 newtail = &ref->next;
327 }
328 }
329 if (return_refs != fastarray)
330 free(return_refs);
1baaae5e 331 }
9546010b 332 *refs = newlist;
1baaae5e
JS
333}
334
335static int everything_local(struct ref **refs, int nr_match, char **match)
2759cbc7 336{
49bb805e 337 struct ref *ref;
2759cbc7 338 int retval;
49bb805e
JH
339 unsigned long cutoff = 0;
340
341 track_object_refs = 0;
342 save_commit_buffer = 0;
343
1baaae5e 344 for (ref = *refs; ref; ref = ref->next) {
49bb805e
JH
345 struct object *o;
346
347 o = parse_object(ref->old_sha1);
348 if (!o)
349 continue;
350
351 /* We already have it -- which may mean that we were
352 * in sync with the other side at some time after
353 * that (it is OK if we guess wrong here).
354 */
885a86ab 355 if (o->type == TYPE_COMMIT) {
49bb805e
JH
356 struct commit *commit = (struct commit *)o;
357 if (!cutoff || cutoff < commit->date)
358 cutoff = commit->date;
359 }
360 }
361
362 for_each_ref(mark_complete);
363 if (cutoff)
364 mark_recent_complete_commits(cutoff);
2759cbc7 365
1baaae5e
JS
366 /*
367 * Mark all complete remote refs as common refs.
368 * Don't mark them common yet; the server has to be told so first.
369 */
370 for (ref = *refs; ref; ref = ref->next) {
9534f40b
JH
371 struct object *o = deref_tag(lookup_object(ref->old_sha1),
372 NULL, 0);
1baaae5e 373
885a86ab 374 if (!o || o->type != TYPE_COMMIT || !(o->flags & COMPLETE))
1baaae5e
JS
375 continue;
376
377 if (!(o->flags & SEEN)) {
378 rev_list_push((struct commit *)o, COMMON_REF | SEEN);
379
380 mark_common((struct commit *)o, 1, 1);
381 }
382 }
383
384 filter_refs(refs, nr_match, match);
385
386 for (retval = 1, ref = *refs; ref ; ref = ref->next) {
387 const unsigned char *remote = ref->old_sha1;
2759cbc7 388 unsigned char local[20];
49bb805e 389 struct object *o;
2759cbc7 390
1baaae5e 391 o = lookup_object(remote);
49bb805e 392 if (!o || !(o->flags & COMPLETE)) {
2759cbc7
LT
393 retval = 0;
394 if (!verbose)
395 continue;
396 fprintf(stderr,
397 "want %s (%s)\n", sha1_to_hex(remote),
1baaae5e 398 ref->name);
2759cbc7
LT
399 continue;
400 }
401
1baaae5e 402 memcpy(ref->new_sha1, local, 20);
2759cbc7
LT
403 if (!verbose)
404 continue;
405 fprintf(stderr,
406 "already have %s (%s)\n", sha1_to_hex(remote),
1baaae5e 407 ref->name);
2759cbc7
LT
408 }
409 return retval;
410}
411
def88e9a
LT
412static int fetch_pack(int fd[2], int nr_match, char **match)
413{
d1c133f5
LT
414 struct ref *ref;
415 unsigned char sha1[20];
416 int status;
def88e9a 417
1baaae5e 418 get_remote_heads(fd[0], &ref, 0, NULL, 0);
c4c86f07
JS
419 if (server_supports("multi_ack")) {
420 if (verbose)
421 fprintf(stderr, "Server supports multi_ack\n");
422 multi_ack = 1;
423 }
d1c133f5
LT
424 if (!ref) {
425 packet_flush(fd[1]);
426 die("no matching remote head");
427 }
1baaae5e 428 if (everything_local(&ref, nr_match, match)) {
2759cbc7
LT
429 packet_flush(fd[1]);
430 goto all_done;
431 }
33b83034 432 if (find_common(fd, sha1, ref) < 0)
dfeff66e
JH
433 if (!keep_pack)
434 /* When cloning, it is not unusual to have
435 * no common commit.
436 */
437 fprintf(stderr, "warning: no common commits\n");
ad897215
JH
438
439 if (keep_pack)
5ee2ad65 440 status = receive_keep_pack(fd, "git-fetch-pack", quiet);
ad897215
JH
441 else
442 status = receive_unpack_pack(fd, "git-fetch-pack", quiet);
443
444 if (status)
445 die("git-fetch-pack: fetch failed.");
446
447 all_done:
448 while (ref) {
449 printf("%s %s\n",
450 sha1_to_hex(ref->old_sha1), ref->name);
451 ref = ref->next;
75bfc6c2 452 }
ad897215 453 return 0;
def88e9a
LT
454}
455
456int main(int argc, char **argv)
457{
458 int i, ret, nr_heads;
459 char *dest = NULL, **heads;
460 int fd[2];
461 pid_t pid;
462
5a327713
JH
463 setup_git_directory();
464
def88e9a
LT
465 nr_heads = 0;
466 heads = NULL;
467 for (i = 1; i < argc; i++) {
468 char *arg = argv[i];
469
470 if (*arg == '-') {
8b3d9dc0
JH
471 if (!strncmp("--exec=", arg, 7)) {
472 exec = arg + 7;
473 continue;
474 }
2247efb4 475 if (!strcmp("--quiet", arg) || !strcmp("-q", arg)) {
33b83034
JH
476 quiet = 1;
477 continue;
478 }
2247efb4 479 if (!strcmp("--keep", arg) || !strcmp("-k", arg)) {
ad897215
JH
480 keep_pack = 1;
481 continue;
482 }
b19696c2
JH
483 if (!strcmp("--thin", arg)) {
484 use_thin_pack = 1;
485 continue;
486 }
dfeff66e
JH
487 if (!strcmp("--all", arg)) {
488 fetch_all = 1;
489 continue;
490 }
33b83034
JH
491 if (!strcmp("-v", arg)) {
492 verbose = 1;
493 continue;
494 }
def88e9a
LT
495 usage(fetch_pack_usage);
496 }
497 dest = arg;
498 heads = argv + i + 1;
499 nr_heads = argc - i - 1;
500 break;
501 }
502 if (!dest)
503 usage(fetch_pack_usage);
b19696c2
JH
504 if (keep_pack)
505 use_thin_pack = 0;
def88e9a
LT
506 pid = git_connect(fd, dest, exec);
507 if (pid < 0)
508 return 1;
509 ret = fetch_pack(fd, nr_heads, heads);
510 close(fd[0]);
511 close(fd[1]);
512 finish_connect(pid);
9e5d2b40
JH
513
514 if (!ret && nr_heads) {
515 /* If the heads to pull were given, we should have
516 * consumed all of them by matching the remote.
517 * Otherwise, 'git-fetch remote no-such-ref' would
518 * silently succeed without issuing an error.
519 */
520 for (i = 0; i < nr_heads; i++)
521 if (heads[i] && heads[i][0]) {
522 error("no such remote ref %s", heads[i]);
523 ret = 1;
524 }
525 }
526
def88e9a
LT
527 return ret;
528}