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