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