Add callback data to for_each_ref() family.
[git/git.git] / fetch-pack.c
1 #include "cache.h"
2 #include "refs.h"
3 #include "pkt-line.h"
4 #include "commit.h"
5 #include "tag.h"
6
7 static int keep_pack;
8 static int quiet;
9 static int verbose;
10 static int fetch_all;
11 static const char fetch_pack_usage[] =
12 "git-fetch-pack [--all] [-q] [-v] [-k] [--thin] [--exec=upload-pack] [host:]directory <refs>...";
13 static const char *exec = "git-upload-pack";
14
15 #define COMPLETE (1U << 0)
16 #define COMMON (1U << 1)
17 #define COMMON_REF (1U << 2)
18 #define SEEN (1U << 3)
19 #define POPPED (1U << 4)
20
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
27 static struct commit_list *rev_list;
28 static int non_common_revs, multi_ack, use_thin_pack, use_sideband;
29
30 static 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
45 static int rev_list_insert_ref(const char *path, const unsigned char *sha1, void *cb_data)
46 {
47 struct object *o = deref_tag(parse_object(sha1), path, 0);
48
49 if (o && o->type == OBJ_COMMIT)
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
61 static 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
92 static const unsigned char* get_rev(void)
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 }
136
137 static int find_common(int fd[2], unsigned char *result_sha1,
138 struct ref *refs)
139 {
140 int fetching;
141 int count = 0, flushes = 0, retval;
142 const unsigned char *sha1;
143 unsigned in_vain = 0;
144 int got_continue = 0;
145
146 for_each_ref(rev_list_insert_ref, NULL);
147
148 fetching = 0;
149 for ( ; refs ; refs = refs->next) {
150 unsigned char *remote = refs->old_sha1;
151 struct object *o;
152
153 /*
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.
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.
162 */
163 if (((o = lookup_object(remote)) != NULL) &&
164 (o->flags & COMPLETE)) {
165 continue;
166 }
167
168 if (!fetching)
169 packet_write(fd[1], "want %s%s%s%s%s\n",
170 sha1_to_hex(remote),
171 (multi_ack ? " multi_ack" : ""),
172 (use_sideband == 2 ? " side-band-64k" : ""),
173 (use_sideband == 1 ? " side-band" : ""),
174 (use_thin_pack ? " thin-pack" : ""));
175 else
176 packet_write(fd[1], "want %s\n", sha1_to_hex(remote));
177 fetching++;
178 }
179 packet_flush(fd[1]);
180 if (!fetching)
181 return 1;
182
183 flushes = 0;
184 retval = -1;
185 while ((sha1 = get_rev())) {
186 packet_write(fd[1], "have %s\n", sha1_to_hex(sha1));
187 if (verbose)
188 fprintf(stderr, "have %s\n", sha1_to_hex(sha1));
189 in_vain++;
190 if (!(31 & ++count)) {
191 int ack;
192
193 packet_flush(fd[1]);
194 flushes++;
195
196 /*
197 * We keep one window "ahead" of the other side, and
198 * will wait for an ACK only on the next one
199 */
200 if (count == 32)
201 continue;
202
203 do {
204 ack = get_ack(fd[0], result_sha1);
205 if (verbose && ack)
206 fprintf(stderr, "got ack %d %s\n", ack,
207 sha1_to_hex(result_sha1));
208 if (ack == 1) {
209 flushes = 0;
210 multi_ack = 0;
211 retval = 0;
212 goto done;
213 } else if (ack == 2) {
214 struct commit *commit =
215 lookup_commit(result_sha1);
216 mark_common(commit, 0, 1);
217 retval = 0;
218 in_vain = 0;
219 got_continue = 1;
220 }
221 } while (ack);
222 flushes--;
223 if (got_continue && MAX_IN_VAIN < in_vain) {
224 if (verbose)
225 fprintf(stderr, "giving up\n");
226 break; /* give up */
227 }
228 }
229 }
230 done:
231 packet_write(fd[1], "done\n");
232 if (verbose)
233 fprintf(stderr, "done\n");
234 if (retval != 0) {
235 multi_ack = 0;
236 flushes++;
237 }
238 while (flushes || multi_ack) {
239 int ack = get_ack(fd[0], result_sha1);
240 if (ack) {
241 if (verbose)
242 fprintf(stderr, "got ack (%d) %s\n", ack,
243 sha1_to_hex(result_sha1));
244 if (ack == 1)
245 return 0;
246 multi_ack = 1;
247 continue;
248 }
249 flushes--;
250 }
251 return retval;
252 }
253
254 static struct commit_list *complete;
255
256 static int mark_complete(const char *path, const unsigned char *sha1, void *cb_data)
257 {
258 struct object *o = parse_object(sha1);
259
260 while (o && o->type == OBJ_TAG) {
261 struct tag *t = (struct tag *) o;
262 if (!t->tagged)
263 break; /* broken repository */
264 o->flags |= COMPLETE;
265 o = parse_object(t->tagged->sha1);
266 }
267 if (o && o->type == OBJ_COMMIT) {
268 struct commit *commit = (struct commit *)o;
269 commit->object.flags |= COMPLETE;
270 insert_by_date(commit, &complete);
271 }
272 return 0;
273 }
274
275 static void mark_recent_complete_commits(unsigned long cutoff)
276 {
277 while (complete && cutoff <= complete->item->date) {
278 if (verbose)
279 fprintf(stderr, "Marking %s as complete\n",
280 sha1_to_hex(complete->item->object.sha1));
281 pop_most_recent_commit(&complete, COMPLETE);
282 }
283 }
284
285 static void filter_refs(struct ref **refs, int nr_match, char **match)
286 {
287 struct ref **return_refs;
288 struct ref *newlist = NULL;
289 struct ref **newtail = &newlist;
290 struct ref *ref, *next;
291 struct ref *fastarray[32];
292
293 if (nr_match && !fetch_all) {
294 if (ARRAY_SIZE(fastarray) < nr_match)
295 return_refs = xcalloc(nr_match, sizeof(struct ref *));
296 else {
297 return_refs = fastarray;
298 memset(return_refs, 0, sizeof(struct ref *) * nr_match);
299 }
300 }
301 else
302 return_refs = NULL;
303
304 for (ref = *refs; ref; ref = next) {
305 next = ref->next;
306 if (!memcmp(ref->name, "refs/", 5) &&
307 check_ref_format(ref->name + 5))
308 ; /* trash */
309 else if (fetch_all) {
310 *newtail = ref;
311 ref->next = NULL;
312 newtail = &ref->next;
313 continue;
314 }
315 else {
316 int order = path_match(ref->name, nr_match, match);
317 if (order) {
318 return_refs[order-1] = ref;
319 continue; /* we will link it later */
320 }
321 }
322 free(ref);
323 }
324
325 if (!fetch_all) {
326 int i;
327 for (i = 0; i < nr_match; i++) {
328 ref = return_refs[i];
329 if (ref) {
330 *newtail = ref;
331 ref->next = NULL;
332 newtail = &ref->next;
333 }
334 }
335 if (return_refs != fastarray)
336 free(return_refs);
337 }
338 *refs = newlist;
339 }
340
341 static int everything_local(struct ref **refs, int nr_match, char **match)
342 {
343 struct ref *ref;
344 int retval;
345 unsigned long cutoff = 0;
346
347 track_object_refs = 0;
348 save_commit_buffer = 0;
349
350 for (ref = *refs; ref; ref = ref->next) {
351 struct object *o;
352
353 o = parse_object(ref->old_sha1);
354 if (!o)
355 continue;
356
357 /* We already have it -- which may mean that we were
358 * in sync with the other side at some time after
359 * that (it is OK if we guess wrong here).
360 */
361 if (o->type == OBJ_COMMIT) {
362 struct commit *commit = (struct commit *)o;
363 if (!cutoff || cutoff < commit->date)
364 cutoff = commit->date;
365 }
366 }
367
368 for_each_ref(mark_complete, NULL);
369 if (cutoff)
370 mark_recent_complete_commits(cutoff);
371
372 /*
373 * Mark all complete remote refs as common refs.
374 * Don't mark them common yet; the server has to be told so first.
375 */
376 for (ref = *refs; ref; ref = ref->next) {
377 struct object *o = deref_tag(lookup_object(ref->old_sha1),
378 NULL, 0);
379
380 if (!o || o->type != OBJ_COMMIT || !(o->flags & COMPLETE))
381 continue;
382
383 if (!(o->flags & SEEN)) {
384 rev_list_push((struct commit *)o, COMMON_REF | SEEN);
385
386 mark_common((struct commit *)o, 1, 1);
387 }
388 }
389
390 filter_refs(refs, nr_match, match);
391
392 for (retval = 1, ref = *refs; ref ; ref = ref->next) {
393 const unsigned char *remote = ref->old_sha1;
394 unsigned char local[20];
395 struct object *o;
396
397 o = lookup_object(remote);
398 if (!o || !(o->flags & COMPLETE)) {
399 retval = 0;
400 if (!verbose)
401 continue;
402 fprintf(stderr,
403 "want %s (%s)\n", sha1_to_hex(remote),
404 ref->name);
405 continue;
406 }
407
408 hashcpy(ref->new_sha1, local);
409 if (!verbose)
410 continue;
411 fprintf(stderr,
412 "already have %s (%s)\n", sha1_to_hex(remote),
413 ref->name);
414 }
415 return retval;
416 }
417
418 static int fetch_pack(int fd[2], int nr_match, char **match)
419 {
420 struct ref *ref;
421 unsigned char sha1[20];
422 int status;
423
424 get_remote_heads(fd[0], &ref, 0, NULL, 0);
425 if (server_supports("multi_ack")) {
426 if (verbose)
427 fprintf(stderr, "Server supports multi_ack\n");
428 multi_ack = 1;
429 }
430 if (server_supports("side-band-64k")) {
431 if (verbose)
432 fprintf(stderr, "Server supports side-band-64k\n");
433 use_sideband = 2;
434 }
435 else if (server_supports("side-band")) {
436 if (verbose)
437 fprintf(stderr, "Server supports side-band\n");
438 use_sideband = 1;
439 }
440 if (!ref) {
441 packet_flush(fd[1]);
442 die("no matching remote head");
443 }
444 if (everything_local(&ref, nr_match, match)) {
445 packet_flush(fd[1]);
446 goto all_done;
447 }
448 if (find_common(fd, sha1, ref) < 0)
449 if (!keep_pack)
450 /* When cloning, it is not unusual to have
451 * no common commit.
452 */
453 fprintf(stderr, "warning: no common commits\n");
454
455 if (keep_pack)
456 status = receive_keep_pack(fd, "git-fetch-pack", quiet, use_sideband);
457 else
458 status = receive_unpack_pack(fd, "git-fetch-pack", quiet, use_sideband);
459
460 if (status)
461 die("git-fetch-pack: fetch failed.");
462
463 all_done:
464 while (ref) {
465 printf("%s %s\n",
466 sha1_to_hex(ref->old_sha1), ref->name);
467 ref = ref->next;
468 }
469 return 0;
470 }
471
472 int main(int argc, char **argv)
473 {
474 int i, ret, nr_heads;
475 char *dest = NULL, **heads;
476 int fd[2];
477 pid_t pid;
478
479 setup_git_directory();
480
481 nr_heads = 0;
482 heads = NULL;
483 for (i = 1; i < argc; i++) {
484 char *arg = argv[i];
485
486 if (*arg == '-') {
487 if (!strncmp("--exec=", arg, 7)) {
488 exec = arg + 7;
489 continue;
490 }
491 if (!strcmp("--quiet", arg) || !strcmp("-q", arg)) {
492 quiet = 1;
493 continue;
494 }
495 if (!strcmp("--keep", arg) || !strcmp("-k", arg)) {
496 keep_pack = 1;
497 continue;
498 }
499 if (!strcmp("--thin", arg)) {
500 use_thin_pack = 1;
501 continue;
502 }
503 if (!strcmp("--all", arg)) {
504 fetch_all = 1;
505 continue;
506 }
507 if (!strcmp("-v", arg)) {
508 verbose = 1;
509 continue;
510 }
511 usage(fetch_pack_usage);
512 }
513 dest = arg;
514 heads = argv + i + 1;
515 nr_heads = argc - i - 1;
516 break;
517 }
518 if (!dest)
519 usage(fetch_pack_usage);
520 if (keep_pack)
521 use_thin_pack = 0;
522 pid = git_connect(fd, dest, exec);
523 if (pid < 0)
524 return 1;
525 ret = fetch_pack(fd, nr_heads, heads);
526 close(fd[0]);
527 close(fd[1]);
528 ret |= finish_connect(pid);
529
530 if (!ret && nr_heads) {
531 /* If the heads to pull were given, we should have
532 * consumed all of them by matching the remote.
533 * Otherwise, 'git-fetch remote no-such-ref' would
534 * silently succeed without issuing an error.
535 */
536 for (i = 0; i < nr_heads; i++)
537 if (heads[i] && heads[i][0]) {
538 error("no such remote ref %s", heads[i]);
539 ret = 1;
540 }
541 }
542
543 return !!ret;
544 }