[PATCH] Clean up the SunOS Makefile rule
[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 #include <time.h>
7 #include <sys/wait.h>
8
9 static int quiet;
10 static int verbose;
11 static const char fetch_pack_usage[] =
12 "git-fetch-pack [-q] [-v] [--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 static struct commit_list *rev_list = NULL;
22 static int non_common_revs = 0, multi_ack = 0;
23
24 static 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
39 static int rev_list_insert_ref(const char *path, const unsigned char *sha1)
40 {
41 struct object *o = deref_tag(parse_object(sha1));
42
43 if (o->type == commit_type)
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
55 static 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
86 static const unsigned char* get_rev()
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 }
130
131 static int find_common(int fd[2], unsigned char *result_sha1,
132 struct ref *refs)
133 {
134 int fetching;
135 int count = 0, flushes = 0, retval;
136 const unsigned char *sha1;
137
138 for_each_ref(rev_list_insert_ref);
139
140 fetching = 0;
141 for ( ; refs ; refs = refs->next) {
142 unsigned char *remote = refs->old_sha1;
143 struct object *o;
144
145 /*
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.
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.
154 */
155 if (((o = lookup_object(remote)) != NULL) &&
156 (o->flags & COMPLETE)) {
157 continue;
158 }
159
160 packet_write(fd[1], "want %s%s\n", sha1_to_hex(remote),
161 multi_ack ? " multi_ack" : "");
162 fetching++;
163 }
164 packet_flush(fd[1]);
165 if (!fetching)
166 return 1;
167
168 flushes = 0;
169 retval = -1;
170 while ((sha1 = get_rev())) {
171 packet_write(fd[1], "have %s\n", sha1_to_hex(sha1));
172 if (verbose)
173 fprintf(stderr, "have %s\n", sha1_to_hex(sha1));
174 if (!(31 & ++count)) {
175 int ack;
176
177 packet_flush(fd[1]);
178 flushes++;
179
180 /*
181 * We keep one window "ahead" of the other side, and
182 * will wait for an ACK only on the next one
183 */
184 if (count == 32)
185 continue;
186
187 do {
188 ack = get_ack(fd[0], result_sha1);
189 if (verbose && ack)
190 fprintf(stderr, "got ack %d %s\n", ack,
191 sha1_to_hex(result_sha1));
192 if (ack == 1) {
193 flushes = 0;
194 multi_ack = 0;
195 retval = 0;
196 goto done;
197 } else if (ack == 2) {
198 struct commit *commit =
199 lookup_commit(result_sha1);
200 mark_common(commit, 0, 1);
201 retval = 0;
202 }
203 } while (ack);
204 flushes--;
205 }
206 }
207 done:
208 packet_write(fd[1], "done\n");
209 if (verbose)
210 fprintf(stderr, "done\n");
211 if (retval != 0) {
212 multi_ack = 0;
213 flushes++;
214 }
215 while (flushes || multi_ack) {
216 int ack = get_ack(fd[0], result_sha1);
217 if (ack) {
218 if (verbose)
219 fprintf(stderr, "got ack (%d) %s\n", ack,
220 sha1_to_hex(result_sha1));
221 if (ack == 1)
222 return 0;
223 multi_ack = 1;
224 continue;
225 }
226 flushes--;
227 }
228 return retval;
229 }
230
231 static struct commit_list *complete = NULL;
232
233 static int mark_complete(const char *path, const unsigned char *sha1)
234 {
235 struct object *o = parse_object(sha1);
236
237 while (o && o->type == tag_type) {
238 struct tag *t = (struct tag *) o;
239 if (!t->tagged)
240 break; /* broken repository */
241 o->flags |= COMPLETE;
242 o = parse_object(t->tagged->sha1);
243 }
244 if (o && o->type == commit_type) {
245 struct commit *commit = (struct commit *)o;
246 commit->object.flags |= COMPLETE;
247 insert_by_date(commit, &complete);
248 }
249 return 0;
250 }
251
252 static void mark_recent_complete_commits(unsigned long cutoff)
253 {
254 while (complete && cutoff <= complete->item->date) {
255 if (verbose)
256 fprintf(stderr, "Marking %s as complete\n",
257 sha1_to_hex(complete->item->object.sha1));
258 pop_most_recent_commit(&complete, COMPLETE);
259 }
260 }
261
262 static void filter_refs(struct ref **refs, int nr_match, char **match)
263 {
264 struct ref *prev, *current, *next;
265
266 if (!nr_match)
267 return;
268
269 for (prev = NULL, current = *refs; current; current = next) {
270 next = current->next;
271 if ((!memcmp(current->name, "refs/", 5) &&
272 check_ref_format(current->name + 5)) ||
273 !path_match(current->name, nr_match, match)) {
274 if (prev == NULL)
275 *refs = next;
276 else
277 prev->next = next;
278 free(current);
279 } else
280 prev = current;
281 }
282 }
283
284 static int everything_local(struct ref **refs, int nr_match, char **match)
285 {
286 struct ref *ref;
287 int retval;
288 unsigned long cutoff = 0;
289
290 track_object_refs = 0;
291 save_commit_buffer = 0;
292
293 for (ref = *refs; ref; ref = ref->next) {
294 struct object *o;
295
296 o = parse_object(ref->old_sha1);
297 if (!o)
298 continue;
299
300 /* We already have it -- which may mean that we were
301 * in sync with the other side at some time after
302 * that (it is OK if we guess wrong here).
303 */
304 if (o->type == commit_type) {
305 struct commit *commit = (struct commit *)o;
306 if (!cutoff || cutoff < commit->date)
307 cutoff = commit->date;
308 }
309 }
310
311 for_each_ref(mark_complete);
312 if (cutoff)
313 mark_recent_complete_commits(cutoff);
314
315 /*
316 * Mark all complete remote refs as common refs.
317 * Don't mark them common yet; the server has to be told so first.
318 */
319 for (ref = *refs; ref; ref = ref->next) {
320 struct object *o = deref_tag(lookup_object(ref->old_sha1));
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 pid_t pid;
366
367 get_remote_heads(fd[0], &ref, 0, NULL, 0);
368 if (server_supports("multi_ack")) {
369 if (verbose)
370 fprintf(stderr, "Server supports multi_ack\n");
371 multi_ack = 1;
372 }
373 if (!ref) {
374 packet_flush(fd[1]);
375 die("no matching remote head");
376 }
377 if (everything_local(&ref, nr_match, match)) {
378 packet_flush(fd[1]);
379 goto all_done;
380 }
381 if (find_common(fd, sha1, ref) < 0)
382 fprintf(stderr, "warning: no common commits\n");
383 pid = fork();
384 if (pid < 0)
385 die("git-fetch-pack: unable to fork off git-unpack-objects");
386 if (!pid) {
387 dup2(fd[0], 0);
388 close(fd[0]);
389 close(fd[1]);
390 execlp("git-unpack-objects", "git-unpack-objects",
391 quiet ? "-q" : NULL, NULL);
392 die("git-unpack-objects exec failed");
393 }
394 close(fd[0]);
395 close(fd[1]);
396 while (waitpid(pid, &status, 0) < 0) {
397 if (errno != EINTR)
398 die("waiting for git-unpack-objects: %s", strerror(errno));
399 }
400 if (WIFEXITED(status)) {
401 int code = WEXITSTATUS(status);
402 if (code)
403 die("git-unpack-objects died with error code %d", code);
404 all_done:
405 while (ref) {
406 printf("%s %s\n",
407 sha1_to_hex(ref->old_sha1), ref->name);
408 ref = ref->next;
409 }
410 return 0;
411 }
412 if (WIFSIGNALED(status)) {
413 int sig = WTERMSIG(status);
414 die("git-unpack-objects died of signal %d", sig);
415 }
416 die("Sherlock Holmes! git-unpack-objects died of unnatural causes %d!", status);
417 }
418
419 int main(int argc, char **argv)
420 {
421 int i, ret, nr_heads;
422 char *dest = NULL, **heads;
423 int fd[2];
424 pid_t pid;
425
426 nr_heads = 0;
427 heads = NULL;
428 for (i = 1; i < argc; i++) {
429 char *arg = argv[i];
430
431 if (*arg == '-') {
432 if (!strncmp("--exec=", arg, 7)) {
433 exec = arg + 7;
434 continue;
435 }
436 if (!strcmp("-q", arg)) {
437 quiet = 1;
438 continue;
439 }
440 if (!strcmp("-v", arg)) {
441 verbose = 1;
442 continue;
443 }
444 usage(fetch_pack_usage);
445 }
446 dest = arg;
447 heads = argv + i + 1;
448 nr_heads = argc - i - 1;
449 break;
450 }
451 if (!dest)
452 usage(fetch_pack_usage);
453 pid = git_connect(fd, dest, exec);
454 if (pid < 0)
455 return 1;
456 ret = fetch_pack(fd, nr_heads, heads);
457 close(fd[0]);
458 close(fd[1]);
459 finish_connect(pid);
460 return ret;
461 }