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