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";
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)
22 * After sending this many "have"s if we do not get any new ACK , we
23 * give up traversing our history.
25 #define MAX_IN_VAIN 256
27 static struct commit_list
*rev_list
= NULL
;
28 static int non_common_revs
= 0, multi_ack
= 0, use_thin_pack
= 0;
30 static void rev_list_push(struct commit
*commit
, int mark
)
32 if (!(commit
->object
.flags
& mark
)) {
33 commit
->object
.flags
|= mark
;
35 if (!(commit
->object
.parsed
))
38 insert_by_date(commit
, &rev_list
);
40 if (!(commit
->object
.flags
& COMMON
))
45 static int rev_list_insert_ref(const char *path
, const unsigned char *sha1
)
47 struct object
*o
= deref_tag(parse_object(sha1
), path
, 0);
49 if (o
&& o
->type
== commit_type
)
50 rev_list_push((struct commit
*)o
, SEEN
);
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).
61 static void mark_common(struct commit
*commit
,
62 int ancestors_only
, int dont_parse
)
64 if (commit
!= NULL
&& !(commit
->object
.flags
& COMMON
)) {
65 struct object
*o
= (struct object
*)commit
;
70 if (!(o
->flags
& SEEN
))
71 rev_list_push(commit
, SEEN
);
73 struct commit_list
*parents
;
75 if (!ancestors_only
&& !(o
->flags
& POPPED
))
77 if (!o
->parsed
&& !dont_parse
)
80 for (parents
= commit
->parents
;
82 parents
= parents
->next
)
83 mark_common(parents
->item
, 0, dont_parse
);
89 Get the next rev to send, ignoring the common.
92 static const unsigned char* get_rev(void)
94 struct commit
*commit
= NULL
;
96 while (commit
== NULL
) {
98 struct commit_list
* parents
;
100 if (rev_list
== NULL
|| non_common_revs
== 0)
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
))
110 parents
= commit
->parents
;
112 if (commit
->object
.flags
& COMMON
) {
113 /* do not send "have", and ignore ancestors */
115 mark
= COMMON
| SEEN
;
116 } else if (commit
->object
.flags
& COMMON_REF
)
117 /* send "have", and ignore ancestors */
118 mark
= COMMON
| SEEN
;
120 /* send "have", also for its ancestors */
124 if (!(parents
->item
->object
.flags
& SEEN
))
125 rev_list_push(parents
->item
, mark
);
127 mark_common(parents
->item
, 1, 0);
128 parents
= parents
->next
;
131 rev_list
= rev_list
->next
;
134 return commit
->object
.sha1
;
137 static int find_common(int fd
[2], unsigned char *result_sha1
,
141 int count
= 0, flushes
= 0, retval
;
142 const unsigned char *sha1
;
143 unsigned in_vain
= 0;
144 int got_continue
= 0;
146 for_each_ref(rev_list_insert_ref
);
149 for ( ; refs
; refs
= refs
->next
) {
150 unsigned char *remote
= refs
->old_sha1
;
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
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.
163 if (((o
= lookup_object(remote
)) != NULL
) &&
164 (o
->flags
& COMPLETE
)) {
168 packet_write(fd
[1], "want %s%s%s\n", sha1_to_hex(remote
),
169 (multi_ack
? " multi_ack" : ""),
170 (use_thin_pack
? " thin-pack" : ""));
179 while ((sha1
= get_rev())) {
180 packet_write(fd
[1], "have %s\n", sha1_to_hex(sha1
));
182 fprintf(stderr
, "have %s\n", sha1_to_hex(sha1
));
184 if (!(31 & ++count
)) {
191 * We keep one window "ahead" of the other side, and
192 * will wait for an ACK only on the next one
198 ack
= get_ack(fd
[0], result_sha1
);
200 fprintf(stderr
, "got ack %d %s\n", ack
,
201 sha1_to_hex(result_sha1
));
207 } else if (ack
== 2) {
208 struct commit
*commit
=
209 lookup_commit(result_sha1
);
210 mark_common(commit
, 0, 1);
217 if (got_continue
&& MAX_IN_VAIN
< in_vain
) {
219 fprintf(stderr
, "giving up\n");
225 packet_write(fd
[1], "done\n");
227 fprintf(stderr
, "done\n");
232 while (flushes
|| multi_ack
) {
233 int ack
= get_ack(fd
[0], result_sha1
);
236 fprintf(stderr
, "got ack (%d) %s\n", ack
,
237 sha1_to_hex(result_sha1
));
248 static struct commit_list
*complete
= NULL
;
250 static int mark_complete(const char *path
, const unsigned char *sha1
)
252 struct object
*o
= parse_object(sha1
);
254 while (o
&& o
->type
== tag_type
) {
255 struct tag
*t
= (struct tag
*) o
;
257 break; /* broken repository */
258 o
->flags
|= COMPLETE
;
259 o
= parse_object(t
->tagged
->sha1
);
261 if (o
&& o
->type
== commit_type
) {
262 struct commit
*commit
= (struct commit
*)o
;
263 commit
->object
.flags
|= COMPLETE
;
264 insert_by_date(commit
, &complete
);
269 static void mark_recent_complete_commits(unsigned long cutoff
)
271 while (complete
&& cutoff
<= complete
->item
->date
) {
273 fprintf(stderr
, "Marking %s as complete\n",
274 sha1_to_hex(complete
->item
->object
.sha1
));
275 pop_most_recent_commit(&complete
, COMPLETE
);
279 static void filter_refs(struct ref
**refs
, int nr_match
, char **match
)
281 struct ref
**return_refs
;
282 struct ref
*newlist
= NULL
;
283 struct ref
**newtail
= &newlist
;
284 struct ref
*ref
, *next
;
285 struct ref
*fastarray
[32];
287 if (nr_match
&& !fetch_all
) {
288 if (ARRAY_SIZE(fastarray
) < nr_match
)
289 return_refs
= xcalloc(nr_match
, sizeof(struct ref
*));
291 return_refs
= fastarray
;
292 memset(return_refs
, 0, sizeof(struct ref
*) * nr_match
);
298 for (ref
= *refs
; ref
; ref
= next
) {
300 if (!memcmp(ref
->name
, "refs/", 5) &&
301 check_ref_format(ref
->name
+ 5))
303 else if (fetch_all
) {
306 newtail
= &ref
->next
;
310 int order
= path_match(ref
->name
, nr_match
, match
);
312 return_refs
[order
-1] = ref
;
313 continue; /* we will link it later */
321 for (i
= 0; i
< nr_match
; i
++) {
322 ref
= return_refs
[i
];
326 newtail
= &ref
->next
;
329 if (return_refs
!= fastarray
)
335 static int everything_local(struct ref
**refs
, int nr_match
, char **match
)
339 unsigned long cutoff
= 0;
341 track_object_refs
= 0;
342 save_commit_buffer
= 0;
344 for (ref
= *refs
; ref
; ref
= ref
->next
) {
347 o
= parse_object(ref
->old_sha1
);
351 /* We already have it -- which may mean that we were
352 * in sync with the other side at some time after
353 * that (it is OK if we guess wrong here).
355 if (o
->type
== commit_type
) {
356 struct commit
*commit
= (struct commit
*)o
;
357 if (!cutoff
|| cutoff
< commit
->date
)
358 cutoff
= commit
->date
;
362 for_each_ref(mark_complete
);
364 mark_recent_complete_commits(cutoff
);
367 * Mark all complete remote refs as common refs.
368 * Don't mark them common yet; the server has to be told so first.
370 for (ref
= *refs
; ref
; ref
= ref
->next
) {
371 struct object
*o
= deref_tag(lookup_object(ref
->old_sha1
),
374 if (!o
|| o
->type
!= commit_type
|| !(o
->flags
& COMPLETE
))
377 if (!(o
->flags
& SEEN
)) {
378 rev_list_push((struct commit
*)o
, COMMON_REF
| SEEN
);
380 mark_common((struct commit
*)o
, 1, 1);
384 filter_refs(refs
, nr_match
, match
);
386 for (retval
= 1, ref
= *refs
; ref
; ref
= ref
->next
) {
387 const unsigned char *remote
= ref
->old_sha1
;
388 unsigned char local
[20];
391 o
= lookup_object(remote
);
392 if (!o
|| !(o
->flags
& COMPLETE
)) {
397 "want %s (%s)\n", sha1_to_hex(remote
),
402 memcpy(ref
->new_sha1
, local
, 20);
406 "already have %s (%s)\n", sha1_to_hex(remote
),
412 static int fetch_pack(int fd
[2], int nr_match
, char **match
)
415 unsigned char sha1
[20];
418 get_remote_heads(fd
[0], &ref
, 0, NULL
, 0);
419 if (server_supports("multi_ack")) {
421 fprintf(stderr
, "Server supports multi_ack\n");
426 die("no matching remote head");
428 if (everything_local(&ref
, nr_match
, match
)) {
432 if (find_common(fd
, sha1
, ref
) < 0)
434 /* When cloning, it is not unusual to have
437 fprintf(stderr
, "warning: no common commits\n");
440 status
= receive_keep_pack(fd
, "git-fetch-pack", quiet
);
442 status
= receive_unpack_pack(fd
, "git-fetch-pack", quiet
);
445 die("git-fetch-pack: fetch failed.");
450 sha1_to_hex(ref
->old_sha1
), ref
->name
);
456 int main(int argc
, char **argv
)
458 int i
, ret
, nr_heads
;
459 char *dest
= NULL
, **heads
;
463 setup_git_directory();
467 for (i
= 1; i
< argc
; i
++) {
471 if (!strncmp("--exec=", arg
, 7)) {
475 if (!strcmp("--quiet", arg
) || !strcmp("-q", arg
)) {
479 if (!strcmp("--keep", arg
) || !strcmp("-k", arg
)) {
483 if (!strcmp("--thin", arg
)) {
487 if (!strcmp("--all", arg
)) {
491 if (!strcmp("-v", arg
)) {
495 usage(fetch_pack_usage
);
498 heads
= argv
+ i
+ 1;
499 nr_heads
= argc
- i
- 1;
503 usage(fetch_pack_usage
);
506 pid
= git_connect(fd
, dest
, exec
);
509 ret
= fetch_pack(fd
, nr_heads
, heads
);
514 if (!ret
&& nr_heads
) {
515 /* If the heads to pull were given, we should have
516 * consumed all of them by matching the remote.
517 * Otherwise, 'git-fetch remote no-such-ref' would
518 * silently succeed without issuing an error.
520 for (i
= 0; i
< nr_heads
; i
++)
521 if (heads
[i
] && heads
[i
][0]) {
522 error("no such remote ref %s", heads
[i
]);