?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'tb/clone-case-smashing-warning-test'
[git/debian.git] / builtin / fetch.c
blobe0140327aab23654c69e7388c23a07b98b8ff913
1 /*
2 * "git fetch"
3 */
4 #include "cache.h"
5 #include "config.h"
6 #include "repository.h"
7 #include "refs.h"
8 #include "refspec.h"
9 #include "object-store.h"
10 #include "commit.h"
11 #include "builtin.h"
12 #include "string-list.h"
13 #include "remote.h"
14 #include "transport.h"
15 #include "run-command.h"
16 #include "parse-options.h"
17 #include "sigchain.h"
18 #include "submodule-config.h"
19 #include "submodule.h"
20 #include "connected.h"
21 #include "argv-array.h"
22 #include "utf8.h"
23 #include "packfile.h"
24 #include "list-objects-filter-options.h"
25 #include "commit-reach.h"
26
27 static const char * const builtin_fetch_usage[] = {
28 N_("git fetch [<options>] [<repository> [<refspec>...]]"),
29 N_("git fetch [<options>] <group>"),
30 N_("git fetch --multiple [<options>] [(<repository> | <group>)...]"),
31 N_("git fetch --all [<options>]"),
32 NULL
33 };
34
35 enum {
36 TAGS_UNSET = 0,
37 TAGS_DEFAULT = 1,
38 TAGS_SET = 2
39 };
40
41 static int fetch_prune_config = -1; /* unspecified */
42 static int prune = -1; /* unspecified */
43 #define PRUNE_BY_DEFAULT 0 /* do we prune by default? */
44
45 static int fetch_prune_tags_config = -1; /* unspecified */
46 static int prune_tags = -1; /* unspecified */
47 #define PRUNE_TAGS_BY_DEFAULT 0 /* do we prune tags by default? */
48
49 static int all, append, dry_run, force, keep, multiple, update_head_ok, verbosity, deepen_relative;
50 static int progress = -1;
51 static int tags = TAGS_DEFAULT, unshallow, update_shallow, deepen;
52 static int max_children = 1;
53 static enum transport_family family;
54 static const char *depth;
55 static const char *deepen_since;
56 static const char *upload_pack;
57 static struct string_list deepen_not = STRING_LIST_INIT_NODUP;
58 static struct strbuf default_rla = STRBUF_INIT;
59 static struct transport *gtransport;
60 static struct transport *gsecondary;
61 static const char *submodule_prefix = "";
62 static int recurse_submodules = RECURSE_SUBMODULES_DEFAULT;
63 static int recurse_submodules_default = RECURSE_SUBMODULES_ON_DEMAND;
64 static int shown_url = 0;
65 static struct refspec refmap = REFSPEC_INIT_FETCH;
66 static struct list_objects_filter_options filter_options;
67 static struct string_list server_options = STRING_LIST_INIT_DUP;
68 static struct string_list negotiation_tip = STRING_LIST_INIT_NODUP;
69
70 static int git_fetch_config(const char *k, const char *v, void *cb)
71 {
72 if (!strcmp(k, "fetch.prune")) {
73 fetch_prune_config = git_config_bool(k, v);
74 return 0;
75 }
76
77 if (!strcmp(k, "fetch.prunetags")) {
78 fetch_prune_tags_config = git_config_bool(k, v);
79 return 0;
80 }
81
82 if (!strcmp(k, "submodule.recurse")) {
83 int r = git_config_bool(k, v) ?
84 RECURSE_SUBMODULES_ON : RECURSE_SUBMODULES_OFF;
85 recurse_submodules = r;
86 }
87
88 if (!strcmp(k, "submodule.fetchjobs")) {
89 max_children = parse_submodule_fetchjobs(k, v);
90 return 0;
91 } else if (!strcmp(k, "fetch.recursesubmodules")) {
92 recurse_submodules = parse_fetch_recurse_submodules_arg(k, v);
93 return 0;
94 }
95
96 return git_default_config(k, v, cb);
97 }
98
99 static int parse_refmap_arg(const struct option *opt, const char *arg, int unset)
100 {
101 BUG_ON_OPT_NEG(unset);
102
103 /*
104 * "git fetch --refmap='' origin foo"
105 * can be used to tell the command not to store anywhere
106 */
107 refspec_append(&refmap, arg);
108
109 return 0;
110 }
111
112 static struct option builtin_fetch_options[] = {
113 OPT__VERBOSITY(&verbosity),
114 OPT_BOOL(0, "all", &all,
115 N_("fetch from all remotes")),
116 OPT_BOOL('a', "append", &append,
117 N_("append to .git/FETCH_HEAD instead of overwriting")),
118 OPT_STRING(0, "upload-pack", &upload_pack, N_("path"),
119 N_("path to upload pack on remote end")),
120 OPT__FORCE(&force, N_("force overwrite of local reference"), 0),
121 OPT_BOOL('m', "multiple", &multiple,
122 N_("fetch from multiple remotes")),
123 OPT_SET_INT('t', "tags", &tags,
124 N_("fetch all tags and associated objects"), TAGS_SET),
125 OPT_SET_INT('n', NULL, &tags,
126 N_("do not fetch all tags (--no-tags)"), TAGS_UNSET),
127 OPT_INTEGER('j', "jobs", &max_children,
128 N_("number of submodules fetched in parallel")),
129 OPT_BOOL('p', "prune", &prune,
130 N_("prune remote-tracking branches no longer on remote")),
131 OPT_BOOL('P', "prune-tags", &prune_tags,
132 N_("prune local tags no longer on remote and clobber changed tags")),
133 { OPTION_CALLBACK, 0, "recurse-submodules", &recurse_submodules, N_("on-demand"),
134 N_("control recursive fetching of submodules"),
135 PARSE_OPT_OPTARG, option_fetch_parse_recurse_submodules },
136 OPT_BOOL(0, "dry-run", &dry_run,
137 N_("dry run")),
138 OPT_BOOL('k', "keep", &keep, N_("keep downloaded pack")),
139 OPT_BOOL('u', "update-head-ok", &update_head_ok,
140 N_("allow updating of HEAD ref")),
141 OPT_BOOL(0, "progress", &progress, N_("force progress reporting")),
142 OPT_STRING(0, "depth", &depth, N_("depth"),
143 N_("deepen history of shallow clone")),
144 OPT_STRING(0, "shallow-since", &deepen_since, N_("time"),
145 N_("deepen history of shallow repository based on time")),
146 OPT_STRING_LIST(0, "shallow-exclude", &deepen_not, N_("revision"),
147 N_("deepen history of shallow clone, excluding rev")),
148 OPT_INTEGER(0, "deepen", &deepen_relative,
149 N_("deepen history of shallow clone")),
150 OPT_SET_INT_F(0, "unshallow", &unshallow,
151 N_("convert to a complete repository"),
152 1, PARSE_OPT_NONEG),
153 { OPTION_STRING, 0, "submodule-prefix", &submodule_prefix, N_("dir"),
154 N_("prepend this to submodule path output"), PARSE_OPT_HIDDEN },
155 { OPTION_CALLBACK, 0, "recurse-submodules-default",
156 &recurse_submodules_default, N_("on-demand"),
157 N_("default for recursive fetching of submodules "
158 "(lower priority than config files)"),
159 PARSE_OPT_HIDDEN, option_fetch_parse_recurse_submodules },
160 OPT_BOOL(0, "update-shallow", &update_shallow,
161 N_("accept refs that update .git/shallow")),
162 { OPTION_CALLBACK, 0, "refmap", NULL, N_("refmap"),
163 N_("specify fetch refmap"), PARSE_OPT_NONEG, parse_refmap_arg },
164 OPT_STRING_LIST('o', "server-option", &server_options, N_("server-specific"), N_("option to transmit")),
165 OPT_SET_INT('4', "ipv4", &family, N_("use IPv4 addresses only"),
166 TRANSPORT_FAMILY_IPV4),
167 OPT_SET_INT('6', "ipv6", &family, N_("use IPv6 addresses only"),
168 TRANSPORT_FAMILY_IPV6),
169 OPT_STRING_LIST(0, "negotiation-tip", &negotiation_tip, N_("revision"),
170 N_("report that we have only objects reachable from this object")),
171 OPT_PARSE_LIST_OBJECTS_FILTER(&filter_options),
172 OPT_END()
173 };
174
175 static void unlock_pack(void)
176 {
177 if (gtransport)
178 transport_unlock_pack(gtransport);
179 if (gsecondary)
180 transport_unlock_pack(gsecondary);
181 }
182
183 static void unlock_pack_on_signal(int signo)
184 {
185 unlock_pack();
186 sigchain_pop(signo);
187 raise(signo);
188 }
189
190 static void add_merge_config(struct ref **head,
191 const struct ref *remote_refs,
192 struct branch *branch,
193 struct ref ***tail)
194 {
195 int i;
196
197 for (i = 0; i < branch->merge_nr; i++) {
198 struct ref *rm, **old_tail = *tail;
199 struct refspec_item refspec;
200
201 for (rm = *head; rm; rm = rm->next) {
202 if (branch_merge_matches(branch, i, rm->name)) {
203 rm->fetch_head_status = FETCH_HEAD_MERGE;
204 break;
205 }
206 }
207 if (rm)
208 continue;
209
210 /*
211 * Not fetched to a remote-tracking branch? We need to fetch
212 * it anyway to allow this branch's "branch.$name.merge"
213 * to be honored by 'git pull', but we do not have to
214 * fail if branch.$name.merge is misconfigured to point
215 * at a nonexisting branch. If we were indeed called by
216 * 'git pull', it will notice the misconfiguration because
217 * there is no entry in the resulting FETCH_HEAD marked
218 * for merging.
219 */
220 memset(&refspec, 0, sizeof(refspec));
221 refspec.src = branch->merge[i]->src;
222 get_fetch_map(remote_refs, &refspec, tail, 1);
223 for (rm = *old_tail; rm; rm = rm->next)
224 rm->fetch_head_status = FETCH_HEAD_MERGE;
225 }
226 }
227
228 static int will_fetch(struct ref **head, const unsigned char *sha1)
229 {
230 struct ref *rm = *head;
231 while (rm) {
232 if (hasheq(rm->old_oid.hash, sha1))
233 return 1;
234 rm = rm->next;
235 }
236 return 0;
237 }
238
239 struct refname_hash_entry {
240 struct hashmap_entry ent; /* must be the first member */
241 struct object_id oid;
242 char refname[FLEX_ARRAY];
243 };
244
245 static int refname_hash_entry_cmp(const void *hashmap_cmp_fn_data,
246 const void *e1_,
247 const void *e2_,
248 const void *keydata)
249 {
250 const struct refname_hash_entry *e1 = e1_;
251 const struct refname_hash_entry *e2 = e2_;
252
253 return strcmp(e1->refname, keydata ? keydata : e2->refname);
254 }
255
256 static struct refname_hash_entry *refname_hash_add(struct hashmap *map,
257 const char *refname,
258 const struct object_id *oid)
259 {
260 struct refname_hash_entry *ent;
261 size_t len = strlen(refname);
262
263 FLEX_ALLOC_MEM(ent, refname, refname, len);
264 hashmap_entry_init(ent, strhash(refname));
265 oidcpy(&ent->oid, oid);
266 hashmap_add(map, ent);
267 return ent;
268 }
269
270 static int add_one_refname(const char *refname,
271 const struct object_id *oid,
272 int flag, void *cbdata)
273 {
274 struct hashmap *refname_map = cbdata;
275
276 (void) refname_hash_add(refname_map, refname, oid);
277 return 0;
278 }
279
280 static void refname_hash_init(struct hashmap *map)
281 {
282 hashmap_init(map, refname_hash_entry_cmp, NULL, 0);
283 }
284
285 static int refname_hash_exists(struct hashmap *map, const char *refname)
286 {
287 return !!hashmap_get_from_hash(map, strhash(refname), refname);
288 }
289
290 static void find_non_local_tags(const struct ref *refs,
291 struct ref **head,
292 struct ref ***tail)
293 {
294 struct hashmap existing_refs;
295 struct hashmap remote_refs;
296 struct string_list remote_refs_list = STRING_LIST_INIT_NODUP;
297 struct string_list_item *remote_ref_item;
298 const struct ref *ref;
299 struct refname_hash_entry *item = NULL;
300
301 refname_hash_init(&existing_refs);
302 refname_hash_init(&remote_refs);
303
304 for_each_ref(add_one_refname, &existing_refs);
305 for (ref = refs; ref; ref = ref->next) {
306 if (!starts_with(ref->name, "refs/tags/"))
307 continue;
308
309 /*
310 * The peeled ref always follows the matching base
311 * ref, so if we see a peeled ref that we don't want
312 * to fetch then we can mark the ref entry in the list
313 * as one to ignore by setting util to NULL.
314 */
315 if (ends_with(ref->name, "^{}")) {
316 if (item &&
317 !has_object_file_with_flags(&ref->old_oid,
318 OBJECT_INFO_QUICK) &&
319 !will_fetch(head, ref->old_oid.hash) &&
320 !has_sha1_file_with_flags(item->oid.hash,
321 OBJECT_INFO_QUICK) &&
322 !will_fetch(head, item->oid.hash))
323 oidclr(&item->oid);
324 item = NULL;
325 continue;
326 }
327
328 /*
329 * If item is non-NULL here, then we previously saw a
330 * ref not followed by a peeled reference, so we need
331 * to check if it is a lightweight tag that we want to
332 * fetch.
333 */
334 if (item &&
335 !has_sha1_file_with_flags(item->oid.hash, OBJECT_INFO_QUICK) &&
336 !will_fetch(head, item->oid.hash))
337 oidclr(&item->oid);
338
339 item = NULL;
340
341 /* skip duplicates and refs that we already have */
342 if (refname_hash_exists(&remote_refs, ref->name) ||
343 refname_hash_exists(&existing_refs, ref->name))
344 continue;
345
346 item = refname_hash_add(&remote_refs, ref->name, &ref->old_oid);
347 string_list_insert(&remote_refs_list, ref->name);
348 }
349 hashmap_free(&existing_refs, 1);
350
351 /*
352 * We may have a final lightweight tag that needs to be
353 * checked to see if it needs fetching.
354 */
355 if (item &&
356 !has_sha1_file_with_flags(item->oid.hash, OBJECT_INFO_QUICK) &&
357 !will_fetch(head, item->oid.hash))
358 oidclr(&item->oid);
359
360 /*
361 * For all the tags in the remote_refs_list,
362 * add them to the list of refs to be fetched
363 */
364 for_each_string_list_item(remote_ref_item, &remote_refs_list) {
365 const char *refname = remote_ref_item->string;
366
367 item = hashmap_get_from_hash(&remote_refs, strhash(refname), refname);
368 if (!item)
369 BUG("unseen remote ref?");
370
371 /* Unless we have already decided to ignore this item... */
372 if (!is_null_oid(&item->oid)) {
373 struct ref *rm = alloc_ref(item->refname);
374 rm->peer_ref = alloc_ref(item->refname);
375 oidcpy(&rm->old_oid, &item->oid);
376 **tail = rm;
377 *tail = &rm->next;
378 }
379 }
380 hashmap_free(&remote_refs, 1);
381 string_list_clear(&remote_refs_list, 0);
382 }
383
384 static struct ref *get_ref_map(struct remote *remote,
385 const struct ref *remote_refs,
386 struct refspec *rs,
387 int tags, int *autotags)
388 {
389 int i;
390 struct ref *rm;
391 struct ref *ref_map = NULL;
392 struct ref **tail = &ref_map;
393
394 /* opportunistically-updated references: */
395 struct ref *orefs = NULL, **oref_tail = &orefs;
396
397 struct hashmap existing_refs;
398
399 if (rs->nr) {
400 struct refspec *fetch_refspec;
401
402 for (i = 0; i < rs->nr; i++) {
403 get_fetch_map(remote_refs, &rs->items[i], &tail, 0);
404 if (rs->items[i].dst && rs->items[i].dst[0])
405 *autotags = 1;
406 }
407 /* Merge everything on the command line (but not --tags) */
408 for (rm = ref_map; rm; rm = rm->next)
409 rm->fetch_head_status = FETCH_HEAD_MERGE;
410
411 /*
412 * For any refs that we happen to be fetching via
413 * command-line arguments, the destination ref might
414 * have been missing or have been different than the
415 * remote-tracking ref that would be derived from the
416 * configured refspec. In these cases, we want to
417 * take the opportunity to update their configured
418 * remote-tracking reference. However, we do not want
419 * to mention these entries in FETCH_HEAD at all, as
420 * they would simply be duplicates of existing
421 * entries, so we set them FETCH_HEAD_IGNORE below.
422 *
423 * We compute these entries now, based only on the
424 * refspecs specified on the command line. But we add
425 * them to the list following the refspecs resulting
426 * from the tags option so that one of the latter,
427 * which has FETCH_HEAD_NOT_FOR_MERGE, is not removed
428 * by ref_remove_duplicates() in favor of one of these
429 * opportunistic entries with FETCH_HEAD_IGNORE.
430 */
431 if (refmap.nr)
432 fetch_refspec = &refmap;
433 else
434 fetch_refspec = &remote->fetch;
435
436 for (i = 0; i < fetch_refspec->nr; i++)
437 get_fetch_map(ref_map, &fetch_refspec->items[i], &oref_tail, 1);
438 } else if (refmap.nr) {
439 die("--refmap option is only meaningful with command-line refspec(s).");
440 } else {
441 /* Use the defaults */
442 struct branch *branch = branch_get(NULL);
443 int has_merge = branch_has_merge_config(branch);
444 if (remote &&
445 (remote->fetch.nr ||
446 /* Note: has_merge implies non-NULL branch->remote_name */
447 (has_merge && !strcmp(branch->remote_name, remote->name)))) {
448 for (i = 0; i < remote->fetch.nr; i++) {
449 get_fetch_map(remote_refs, &remote->fetch.items[i], &tail, 0);
450 if (remote->fetch.items[i].dst &&
451 remote->fetch.items[i].dst[0])
452 *autotags = 1;
453 if (!i && !has_merge && ref_map &&
454 !remote->fetch.items[0].pattern)
455 ref_map->fetch_head_status = FETCH_HEAD_MERGE;
456 }
457 /*
458 * if the remote we're fetching from is the same
459 * as given in branch.<name>.remote, we add the
460 * ref given in branch.<name>.merge, too.
461 *
462 * Note: has_merge implies non-NULL branch->remote_name
463 */
464 if (has_merge &&
465 !strcmp(branch->remote_name, remote->name))
466 add_merge_config(&ref_map, remote_refs, branch, &tail);
467 } else {
468 ref_map = get_remote_ref(remote_refs, "HEAD");
469 if (!ref_map)
470 die(_("Couldn't find remote ref HEAD"));
471 ref_map->fetch_head_status = FETCH_HEAD_MERGE;
472 tail = &ref_map->next;
473 }
474 }
475
476 if (tags == TAGS_SET)
477 /* also fetch all tags */
478 get_fetch_map(remote_refs, tag_refspec, &tail, 0);
479 else if (tags == TAGS_DEFAULT && *autotags)
480 find_non_local_tags(remote_refs, &ref_map, &tail);
481
482 /* Now append any refs to be updated opportunistically: */
483 *tail = orefs;
484 for (rm = orefs; rm; rm = rm->next) {
485 rm->fetch_head_status = FETCH_HEAD_IGNORE;
486 tail = &rm->next;
487 }
488
489 ref_map = ref_remove_duplicates(ref_map);
490
491 refname_hash_init(&existing_refs);
492 for_each_ref(add_one_refname, &existing_refs);
493
494 for (rm = ref_map; rm; rm = rm->next) {
495 if (rm->peer_ref) {
496 const char *refname = rm->peer_ref->name;
497 struct refname_hash_entry *peer_item;
498
499 peer_item = hashmap_get_from_hash(&existing_refs,
500 strhash(refname),
501 refname);
502 if (peer_item) {
503 struct object_id *old_oid = &peer_item->oid;
504 oidcpy(&rm->peer_ref->old_oid, old_oid);
505 }
506 }
507 }
508 hashmap_free(&existing_refs, 1);
509
510 return ref_map;
511 }
512
513 #define STORE_REF_ERROR_OTHER 1
514 #define STORE_REF_ERROR_DF_CONFLICT 2
515
516 static int s_update_ref(const char *action,
517 struct ref *ref,
518 int check_old)
519 {
520 char *msg;
521 char *rla = getenv("GIT_REFLOG_ACTION");
522 struct ref_transaction *transaction;
523 struct strbuf err = STRBUF_INIT;
524 int ret, df_conflict = 0;
525
526 if (dry_run)
527 return 0;
528 if (!rla)
529 rla = default_rla.buf;
530 msg = xstrfmt("%s: %s", rla, action);
531
532 transaction = ref_transaction_begin(&err);
533 if (!transaction ||
534 ref_transaction_update(transaction, ref->name,
535 &ref->new_oid,
536 check_old ? &ref->old_oid : NULL,
537 0, msg, &err))
538 goto fail;
539
540 ret = ref_transaction_commit(transaction, &err);
541 if (ret) {
542 df_conflict = (ret == TRANSACTION_NAME_CONFLICT);
543 goto fail;
544 }
545
546 ref_transaction_free(transaction);
547 strbuf_release(&err);
548 free(msg);
549 return 0;
550 fail:
551 ref_transaction_free(transaction);
552 error("%s", err.buf);
553 strbuf_release(&err);
554 free(msg);
555 return df_conflict ? STORE_REF_ERROR_DF_CONFLICT
556 : STORE_REF_ERROR_OTHER;
557 }
558
559 static int refcol_width = 10;
560 static int compact_format;
561
562 static void adjust_refcol_width(const struct ref *ref)
563 {
564 int max, rlen, llen, len;
565
566 /* uptodate lines are only shown on high verbosity level */
567 if (!verbosity && oideq(&ref->peer_ref->old_oid, &ref->old_oid))
568 return;
569
570 max = term_columns();
571 rlen = utf8_strwidth(prettify_refname(ref->name));
572
573 llen = utf8_strwidth(prettify_refname(ref->peer_ref->name));
574
575 /*
576 * rough estimation to see if the output line is too long and
577 * should not be counted (we can't do precise calculation
578 * anyway because we don't know if the error explanation part
579 * will be printed in update_local_ref)
580 */
581 if (compact_format) {
582 llen = 0;
583 max = max * 2 / 3;
584 }
585 len = 21 /* flag and summary */ + rlen + 4 /* -> */ + llen;
586 if (len >= max)
587 return;
588
589 /*
590 * Not precise calculation for compact mode because '*' can
591 * appear on the left hand side of '->' and shrink the column
592 * back.
593 */
594 if (refcol_width < rlen)
595 refcol_width = rlen;
596 }
597
598 static void prepare_format_display(struct ref *ref_map)
599 {
600 struct ref *rm;
601 const char *format = "full";
602
603 git_config_get_string_const("fetch.output", &format);
604 if (!strcasecmp(format, "full"))
605 compact_format = 0;
606 else if (!strcasecmp(format, "compact"))
607 compact_format = 1;
608 else
609 die(_("configuration fetch.output contains invalid value %s"),
610 format);
611
612 for (rm = ref_map; rm; rm = rm->next) {
613 if (rm->status == REF_STATUS_REJECT_SHALLOW ||
614 !rm->peer_ref ||
615 !strcmp(rm->name, "HEAD"))
616 continue;
617
618 adjust_refcol_width(rm);
619 }
620 }
621
622 static void print_remote_to_local(struct strbuf *display,
623 const char *remote, const char *local)
624 {
625 strbuf_addf(display, "%-*s -> %s", refcol_width, remote, local);
626 }
627
628 static int find_and_replace(struct strbuf *haystack,
629 const char *needle,
630 const char *placeholder)
631 {
632 const char *p = strstr(haystack->buf, needle);
633 int plen, nlen;
634
635 if (!p)
636 return 0;
637
638 if (p > haystack->buf && p[-1] != '/')
639 return 0;
640
641 plen = strlen(p);
642 nlen = strlen(needle);
643 if (plen > nlen && p[nlen] != '/')
644 return 0;
645
646 strbuf_splice(haystack, p - haystack->buf, nlen,
647 placeholder, strlen(placeholder));
648 return 1;
649 }
650
651 static void print_compact(struct strbuf *display,
652 const char *remote, const char *local)
653 {
654 struct strbuf r = STRBUF_INIT;
655 struct strbuf l = STRBUF_INIT;
656
657 if (!strcmp(remote, local)) {
658 strbuf_addf(display, "%-*s -> *", refcol_width, remote);
659 return;
660 }
661
662 strbuf_addstr(&r, remote);
663 strbuf_addstr(&l, local);
664
665 if (!find_and_replace(&r, local, "*"))
666 find_and_replace(&l, remote, "*");
667 print_remote_to_local(display, r.buf, l.buf);
668
669 strbuf_release(&r);
670 strbuf_release(&l);
671 }
672
673 static void format_display(struct strbuf *display, char code,
674 const char *summary, const char *error,
675 const char *remote, const char *local,
676 int summary_width)
677 {
678 int width = (summary_width + strlen(summary) - gettext_width(summary));
679
680 strbuf_addf(display, "%c %-*s ", code, width, summary);
681 if (!compact_format)
682 print_remote_to_local(display, remote, local);
683 else
684 print_compact(display, remote, local);
685 if (error)
686 strbuf_addf(display, " (%s)", error);
687 }
688
689 static int update_local_ref(struct ref *ref,
690 const char *remote,
691 const struct ref *remote_ref,
692 struct strbuf *display,
693 int summary_width)
694 {
695 struct commit *current = NULL, *updated;
696 enum object_type type;
697 struct branch *current_branch = branch_get(NULL);
698 const char *pretty_ref = prettify_refname(ref->name);
699
700 type = oid_object_info(the_repository, &ref->new_oid, NULL);
701 if (type < 0)
702 die(_("object %s not found"), oid_to_hex(&ref->new_oid));
703
704 if (oideq(&ref->old_oid, &ref->new_oid)) {
705 if (verbosity > 0)
706 format_display(display, '=', _("[up to date]"), NULL,
707 remote, pretty_ref, summary_width);
708 return 0;
709 }
710
711 if (current_branch &&
712 !strcmp(ref->name, current_branch->name) &&
713 !(update_head_ok || is_bare_repository()) &&
714 !is_null_oid(&ref->old_oid)) {
715 /*
716 * If this is the head, and it's not okay to update
717 * the head, and the old value of the head isn't empty...
718 */
719 format_display(display, '!', _("[rejected]"),
720 _("can't fetch in current branch"),
721 remote, pretty_ref, summary_width);
722 return 1;
723 }
724
725 if (!is_null_oid(&ref->old_oid) &&
726 starts_with(ref->name, "refs/tags/")) {
727 if (force || ref->force) {
728 int r;
729 r = s_update_ref("updating tag", ref, 0);
730 format_display(display, r ? '!' : 't', _("[tag update]"),
731 r ? _("unable to update local ref") : NULL,
732 remote, pretty_ref, summary_width);
733 return r;
734 } else {
735 format_display(display, '!', _("[rejected]"), _("would clobber existing tag"),
736 remote, pretty_ref, summary_width);
737 return 1;
738 }
739 }
740
741 current = lookup_commit_reference_gently(the_repository,
742 &ref->old_oid, 1);
743 updated = lookup_commit_reference_gently(the_repository,
744 &ref->new_oid, 1);
745 if (!current || !updated) {
746 const char *msg;
747 const char *what;
748 int r;
749 /*
750 * Nicely describe the new ref we're fetching.
751 * Base this on the remote's ref name, as it's
752 * more likely to follow a standard layout.
753 */
754 const char *name = remote_ref ? remote_ref->name : "";
755 if (starts_with(name, "refs/tags/")) {
756 msg = "storing tag";
757 what = _("[new tag]");
758 } else if (starts_with(name, "refs/heads/")) {
759 msg = "storing head";
760 what = _("[new branch]");
761 } else {
762 msg = "storing ref";
763 what = _("[new ref]");
764 }
765
766 if ((recurse_submodules != RECURSE_SUBMODULES_OFF) &&
767 (recurse_submodules != RECURSE_SUBMODULES_ON))
768 check_for_new_submodule_commits(&ref->new_oid);
769 r = s_update_ref(msg, ref, 0);
770 format_display(display, r ? '!' : '*', what,
771 r ? _("unable to update local ref") : NULL,
772 remote, pretty_ref, summary_width);
773 return r;
774 }
775
776 if (in_merge_bases(current, updated)) {
777 struct strbuf quickref = STRBUF_INIT;
778 int r;
779 strbuf_add_unique_abbrev(&quickref, &current->object.oid, DEFAULT_ABBREV);
780 strbuf_addstr(&quickref, "..");
781 strbuf_add_unique_abbrev(&quickref, &ref->new_oid, DEFAULT_ABBREV);
782 if ((recurse_submodules != RECURSE_SUBMODULES_OFF) &&
783 (recurse_submodules != RECURSE_SUBMODULES_ON))
784 check_for_new_submodule_commits(&ref->new_oid);
785 r = s_update_ref("fast-forward", ref, 1);
786 format_display(display, r ? '!' : ' ', quickref.buf,
787 r ? _("unable to update local ref") : NULL,
788 remote, pretty_ref, summary_width);
789 strbuf_release(&quickref);
790 return r;
791 } else if (force || ref->force) {
792 struct strbuf quickref = STRBUF_INIT;
793 int r;
794 strbuf_add_unique_abbrev(&quickref, &current->object.oid, DEFAULT_ABBREV);
795 strbuf_addstr(&quickref, "...");
796 strbuf_add_unique_abbrev(&quickref, &ref->new_oid, DEFAULT_ABBREV);
797 if ((recurse_submodules != RECURSE_SUBMODULES_OFF) &&
798 (recurse_submodules != RECURSE_SUBMODULES_ON))
799 check_for_new_submodule_commits(&ref->new_oid);
800 r = s_update_ref("forced-update", ref, 1);
801 format_display(display, r ? '!' : '+', quickref.buf,
802 r ? _("unable to update local ref") : _("forced update"),
803 remote, pretty_ref, summary_width);
804 strbuf_release(&quickref);
805 return r;
806 } else {
807 format_display(display, '!', _("[rejected]"), _("non-fast-forward"),
808 remote, pretty_ref, summary_width);
809 return 1;
810 }
811 }
812
813 static int iterate_ref_map(void *cb_data, struct object_id *oid)
814 {
815 struct ref **rm = cb_data;
816 struct ref *ref = *rm;
817
818 while (ref && ref->status == REF_STATUS_REJECT_SHALLOW)
819 ref = ref->next;
820 if (!ref)
821 return -1; /* end of the list */
822 *rm = ref->next;
823 oidcpy(oid, &ref->old_oid);
824 return 0;
825 }
826
827 static int store_updated_refs(const char *raw_url, const char *remote_name,
828 int connectivity_checked, struct ref *ref_map)
829 {
830 FILE *fp;
831 struct commit *commit;
832 int url_len, i, rc = 0;
833 struct strbuf note = STRBUF_INIT;
834 const char *what, *kind;
835 struct ref *rm;
836 char *url;
837 const char *filename = dry_run ? "/dev/null" : git_path_fetch_head(the_repository);
838 int want_status;
839 int summary_width = transport_summary_width(ref_map);
840
841 fp = fopen(filename, "a");
842 if (!fp)
843 return error_errno(_("cannot open %s"), filename);
844
845 if (raw_url)
846 url = transport_anonymize_url(raw_url);
847 else
848 url = xstrdup("foreign");
849
850 if (!connectivity_checked) {
851 rm = ref_map;
852 if (check_connected(iterate_ref_map, &rm, NULL)) {
853 rc = error(_("%s did not send all necessary objects\n"), url);
854 goto abort;
855 }
856 }
857
858 prepare_format_display(ref_map);
859
860 /*
861 * We do a pass for each fetch_head_status type in their enum order, so
862 * merged entries are written before not-for-merge. That lets readers
863 * use FETCH_HEAD as a refname to refer to the ref to be merged.
864 */
865 for (want_status = FETCH_HEAD_MERGE;
866 want_status <= FETCH_HEAD_IGNORE;
867 want_status++) {
868 for (rm = ref_map; rm; rm = rm->next) {
869 struct ref *ref = NULL;
870 const char *merge_status_marker = "";
871
872 if (rm->status == REF_STATUS_REJECT_SHALLOW) {
873 if (want_status == FETCH_HEAD_MERGE)
874 warning(_("reject %s because shallow roots are not allowed to be updated"),
875 rm->peer_ref ? rm->peer_ref->name : rm->name);
876 continue;
877 }
878
879 commit = lookup_commit_reference_gently(the_repository,
880 &rm->old_oid,
881 1);
882 if (!commit)
883 rm->fetch_head_status = FETCH_HEAD_NOT_FOR_MERGE;
884
885 if (rm->fetch_head_status != want_status)
886 continue;
887
888 if (rm->peer_ref) {
889 ref = alloc_ref(rm->peer_ref->name);
890 oidcpy(&ref->old_oid, &rm->peer_ref->old_oid);
891 oidcpy(&ref->new_oid, &rm->old_oid);
892 ref->force = rm->peer_ref->force;
893 }
894
895
896 if (!strcmp(rm->name, "HEAD")) {
897 kind = "";
898 what = "";
899 }
900 else if (starts_with(rm->name, "refs/heads/")) {
901 kind = "branch";
902 what = rm->name + 11;
903 }
904 else if (starts_with(rm->name, "refs/tags/")) {
905 kind = "tag";
906 what = rm->name + 10;
907 }
908 else if (starts_with(rm->name, "refs/remotes/")) {
909 kind = "remote-tracking branch";
910 what = rm->name + 13;
911 }
912 else {
913 kind = "";
914 what = rm->name;
915 }
916
917 url_len = strlen(url);
918 for (i = url_len - 1; url[i] == '/' && 0 <= i; i--)
919 ;
920 url_len = i + 1;
921 if (4 < i && !strncmp(".git", url + i - 3, 4))
922 url_len = i - 3;
923
924 strbuf_reset(&note);
925 if (*what) {
926 if (*kind)
927 strbuf_addf(&note, "%s ", kind);
928 strbuf_addf(&note, "'%s' of ", what);
929 }
930 switch (rm->fetch_head_status) {
931 case FETCH_HEAD_NOT_FOR_MERGE:
932 merge_status_marker = "not-for-merge";
933 /* fall-through */
934 case FETCH_HEAD_MERGE:
935 fprintf(fp, "%s\t%s\t%s",
936 oid_to_hex(&rm->old_oid),
937 merge_status_marker,
938 note.buf);
939 for (i = 0; i < url_len; ++i)
940 if ('\n' == url[i])
941 fputs("\\n", fp);
942 else
943 fputc(url[i], fp);
944 fputc('\n', fp);
945 break;
946 default:
947 /* do not write anything to FETCH_HEAD */
948 break;
949 }
950
951 strbuf_reset(&note);
952 if (ref) {
953 rc |= update_local_ref(ref, what, rm, &note,
954 summary_width);
955 free(ref);
956 } else
957 format_display(&note, '*',
958 *kind ? kind : "branch", NULL,
959 *what ? what : "HEAD",
960 "FETCH_HEAD", summary_width);
961 if (note.len) {
962 if (verbosity >= 0 && !shown_url) {
963 fprintf(stderr, _("From %.*s\n"),
964 url_len, url);
965 shown_url = 1;
966 }
967 if (verbosity >= 0)
968 fprintf(stderr, " %s\n", note.buf);
969 }
970 }
971 }
972
973 if (rc & STORE_REF_ERROR_DF_CONFLICT)
974 error(_("some local refs could not be updated; try running\n"
975 " 'git remote prune %s' to remove any old, conflicting "
976 "branches"), remote_name);
977
978 abort:
979 strbuf_release(&note);
980 free(url);
981 fclose(fp);
982 return rc;
983 }
984
985 /*
986 * We would want to bypass the object transfer altogether if
987 * everything we are going to fetch already exists and is connected
988 * locally.
989 */
990 static int check_exist_and_connected(struct ref *ref_map)
991 {
992 struct ref *rm = ref_map;
993 struct check_connected_options opt = CHECK_CONNECTED_INIT;
994 struct ref *r;
995
996 /*
997 * If we are deepening a shallow clone we already have these
998 * objects reachable. Running rev-list here will return with
999 * a good (0) exit status and we'll bypass the fetch that we
1000 * really need to perform. Claiming failure now will ensure
1001 * we perform the network exchange to deepen our history.
1002 */
1003 if (deepen)
1004 return -1;
1005
1006 /*
1007 * check_connected() allows objects to merely be promised, but
1008 * we need all direct targets to exist.
1009 */
1010 for (r = rm; r; r = r->next) {
1011 if (!has_object_file(&r->old_oid))
1012 return -1;
1013 }
1014
1015 opt.quiet = 1;
1016 return check_connected(iterate_ref_map, &rm, &opt);
1017 }
1018
1019 static int fetch_refs(struct transport *transport, struct ref *ref_map)
1020 {
1021 int ret = check_exist_and_connected(ref_map);
1022 if (ret)
1023 ret = transport_fetch_refs(transport, ref_map);
1024 if (!ret)
1025 /*
1026 * Keep the new pack's ".keep" file around to allow the caller
1027 * time to update refs to reference the new objects.
1028 */
1029 return 0;
1030 transport_unlock_pack(transport);
1031 return ret;
1032 }
1033
1034 /* Update local refs based on the ref values fetched from a remote */
1035 static int consume_refs(struct transport *transport, struct ref *ref_map)
1036 {
1037 int connectivity_checked = transport->smart_options
1038 ? transport->smart_options->connectivity_checked : 0;
1039 int ret = store_updated_refs(transport->url,
1040 transport->remote->name,
1041 connectivity_checked,
1042 ref_map);
1043 transport_unlock_pack(transport);
1044 return ret;
1045 }
1046
1047 static int prune_refs(struct refspec *rs, struct ref *ref_map,
1048 const char *raw_url)
1049 {
1050 int url_len, i, result = 0;
1051 struct ref *ref, *stale_refs = get_stale_heads(rs, ref_map);
1052 char *url;
1053 int summary_width = transport_summary_width(stale_refs);
1054 const char *dangling_msg = dry_run
1055 ? _(" (%s will become dangling)")
1056 : _(" (%s has become dangling)");
1057
1058 if (raw_url)
1059 url = transport_anonymize_url(raw_url);
1060 else
1061 url = xstrdup("foreign");
1062
1063 url_len = strlen(url);
1064 for (i = url_len - 1; url[i] == '/' && 0 <= i; i--)
1065 ;
1066
1067 url_len = i + 1;
1068 if (4 < i && !strncmp(".git", url + i - 3, 4))
1069 url_len = i - 3;
1070
1071 if (!dry_run) {
1072 struct string_list refnames = STRING_LIST_INIT_NODUP;
1073
1074 for (ref = stale_refs; ref; ref = ref->next)
1075 string_list_append(&refnames, ref->name);
1076
1077 result = delete_refs("fetch: prune", &refnames, 0);
1078 string_list_clear(&refnames, 0);
1079 }
1080
1081 if (verbosity >= 0) {
1082 for (ref = stale_refs; ref; ref = ref->next) {
1083 struct strbuf sb = STRBUF_INIT;
1084 if (!shown_url) {
1085 fprintf(stderr, _("From %.*s\n"), url_len, url);
1086 shown_url = 1;
1087 }
1088 format_display(&sb, '-', _("[deleted]"), NULL,
1089 _("(none)"), prettify_refname(ref->name),
1090 summary_width);
1091 fprintf(stderr, " %s\n",sb.buf);
1092 strbuf_release(&sb);
1093 warn_dangling_symref(stderr, dangling_msg, ref->name);
1094 }
1095 }
1096
1097 free(url);
1098 free_refs(stale_refs);
1099 return result;
1100 }
1101
1102 static void check_not_current_branch(struct ref *ref_map)
1103 {
1104 struct branch *current_branch = branch_get(NULL);
1105
1106 if (is_bare_repository() || !current_branch)
1107 return;
1108
1109 for (; ref_map; ref_map = ref_map->next)
1110 if (ref_map->peer_ref && !strcmp(current_branch->refname,
1111 ref_map->peer_ref->name))
1112 die(_("Refusing to fetch into current branch %s "
1113 "of non-bare repository"), current_branch->refname);
1114 }
1115
1116 static int truncate_fetch_head(void)
1117 {
1118 const char *filename = git_path_fetch_head(the_repository);
1119 FILE *fp = fopen_for_writing(filename);
1120
1121 if (!fp)
1122 return error_errno(_("cannot open %s"), filename);
1123 fclose(fp);
1124 return 0;
1125 }
1126
1127 static void set_option(struct transport *transport, const char *name, const char *value)
1128 {
1129 int r = transport_set_option(transport, name, value);
1130 if (r < 0)
1131 die(_("Option \"%s\" value \"%s\" is not valid for %s"),
1132 name, value, transport->url);
1133 if (r > 0)
1134 warning(_("Option \"%s\" is ignored for %s\n"),
1135 name, transport->url);
1136 }
1137
1138
1139 static int add_oid(const char *refname, const struct object_id *oid, int flags,
1140 void *cb_data)
1141 {
1142 struct oid_array *oids = cb_data;
1143
1144 oid_array_append(oids, oid);
1145 return 0;
1146 }
1147
1148 static void add_negotiation_tips(struct git_transport_options *smart_options)
1149 {
1150 struct oid_array *oids = xcalloc(1, sizeof(*oids));
1151 int i;
1152
1153 for (i = 0; i < negotiation_tip.nr; i++) {
1154 const char *s = negotiation_tip.items[i].string;
1155 int old_nr;
1156 if (!has_glob_specials(s)) {
1157 struct object_id oid;
1158 if (get_oid(s, &oid))
1159 die("%s is not a valid object", s);
1160 oid_array_append(oids, &oid);
1161 continue;
1162 }
1163 old_nr = oids->nr;
1164 for_each_glob_ref(add_oid, s, oids);
1165 if (old_nr == oids->nr)
1166 warning("Ignoring --negotiation-tip=%s because it does not match any refs",
1167 s);
1168 }
1169 smart_options->negotiation_tips = oids;
1170 }
1171
1172 static struct transport *prepare_transport(struct remote *remote, int deepen)
1173 {
1174 struct transport *transport;
1175 transport = transport_get(remote, NULL);
1176 transport_set_verbosity(transport, verbosity, progress);
1177 transport->family = family;
1178 if (upload_pack)
1179 set_option(transport, TRANS_OPT_UPLOADPACK, upload_pack);
1180 if (keep)
1181 set_option(transport, TRANS_OPT_KEEP, "yes");
1182 if (depth)
1183 set_option(transport, TRANS_OPT_DEPTH, depth);
1184 if (deepen && deepen_since)
1185 set_option(transport, TRANS_OPT_DEEPEN_SINCE, deepen_since);
1186 if (deepen && deepen_not.nr)
1187 set_option(transport, TRANS_OPT_DEEPEN_NOT,
1188 (const char *)&deepen_not);
1189 if (deepen_relative)
1190 set_option(transport, TRANS_OPT_DEEPEN_RELATIVE, "yes");
1191 if (update_shallow)
1192 set_option(transport, TRANS_OPT_UPDATE_SHALLOW, "yes");
1193 if (filter_options.choice) {
1194 set_option(transport, TRANS_OPT_LIST_OBJECTS_FILTER,
1195 filter_options.filter_spec);
1196 set_option(transport, TRANS_OPT_FROM_PROMISOR, "1");
1197 }
1198 if (negotiation_tip.nr) {
1199 if (transport->smart_options)
1200 add_negotiation_tips(transport->smart_options);
1201 else
1202 warning("Ignoring --negotiation-tip because the protocol does not support it.");
1203 }
1204 return transport;
1205 }
1206
1207 static void backfill_tags(struct transport *transport, struct ref *ref_map)
1208 {
1209 int cannot_reuse;
1210
1211 /*
1212 * Once we have set TRANS_OPT_DEEPEN_SINCE, we can't unset it
1213 * when remote helper is used (setting it to an empty string
1214 * is not unsetting). We could extend the remote helper
1215 * protocol for that, but for now, just force a new connection
1216 * without deepen-since. Similar story for deepen-not.
1217 */
1218 cannot_reuse = transport->cannot_reuse ||
1219 deepen_since || deepen_not.nr;
1220 if (cannot_reuse) {
1221 gsecondary = prepare_transport(transport->remote, 0);
1222 transport = gsecondary;
1223 }
1224
1225 transport_set_option(transport, TRANS_OPT_FOLLOWTAGS, NULL);
1226 transport_set_option(transport, TRANS_OPT_DEPTH, "0");
1227 transport_set_option(transport, TRANS_OPT_DEEPEN_RELATIVE, NULL);
1228 if (!fetch_refs(transport, ref_map))
1229 consume_refs(transport, ref_map);
1230
1231 if (gsecondary) {
1232 transport_disconnect(gsecondary);
1233 gsecondary = NULL;
1234 }
1235 }
1236
1237 static int do_fetch(struct transport *transport,
1238 struct refspec *rs)
1239 {
1240 struct ref *ref_map;
1241 int autotags = (transport->remote->fetch_tags == 1);
1242 int retcode = 0;
1243 const struct ref *remote_refs;
1244 struct argv_array ref_prefixes = ARGV_ARRAY_INIT;
1245 int must_list_refs = 1;
1246
1247 if (tags == TAGS_DEFAULT) {
1248 if (transport->remote->fetch_tags == 2)
1249 tags = TAGS_SET;
1250 if (transport->remote->fetch_tags == -1)
1251 tags = TAGS_UNSET;
1252 }
1253
1254 /* if not appending, truncate FETCH_HEAD */
1255 if (!append && !dry_run) {
1256 retcode = truncate_fetch_head();
1257 if (retcode)
1258 goto cleanup;
1259 }
1260
1261 if (rs->nr) {
1262 int i;
1263
1264 refspec_ref_prefixes(rs, &ref_prefixes);
1265
1266 /*
1267 * We can avoid listing refs if all of them are exact
1268 * OIDs
1269 */
1270 must_list_refs = 0;
1271 for (i = 0; i < rs->nr; i++) {
1272 if (!rs->items[i].exact_sha1) {
1273 must_list_refs = 1;
1274 break;
1275 }
1276 }
1277 } else if (transport->remote && transport->remote->fetch.nr)
1278 refspec_ref_prefixes(&transport->remote->fetch, &ref_prefixes);
1279
1280 if (tags == TAGS_SET || tags == TAGS_DEFAULT) {
1281 must_list_refs = 1;
1282 if (ref_prefixes.argc)
1283 argv_array_push(&ref_prefixes, "refs/tags/");
1284 }
1285
1286 if (must_list_refs)
1287 remote_refs = transport_get_remote_refs(transport, &ref_prefixes);
1288 else
1289 remote_refs = NULL;
1290
1291 argv_array_clear(&ref_prefixes);
1292
1293 ref_map = get_ref_map(transport->remote, remote_refs, rs,
1294 tags, &autotags);
1295 if (!update_head_ok)
1296 check_not_current_branch(ref_map);
1297
1298 if (tags == TAGS_DEFAULT && autotags)
1299 transport_set_option(transport, TRANS_OPT_FOLLOWTAGS, "1");
1300 if (prune) {
1301 /*
1302 * We only prune based on refspecs specified
1303 * explicitly (via command line or configuration); we
1304 * don't care whether --tags was specified.
1305 */
1306 if (rs->nr) {
1307 prune_refs(rs, ref_map, transport->url);
1308 } else {
1309 prune_refs(&transport->remote->fetch,
1310 ref_map,
1311 transport->url);
1312 }
1313 }
1314 if (fetch_refs(transport, ref_map) || consume_refs(transport, ref_map)) {
1315 free_refs(ref_map);
1316 retcode = 1;
1317 goto cleanup;
1318 }
1319 free_refs(ref_map);
1320
1321 /* if neither --no-tags nor --tags was specified, do automated tag
1322 * following ... */
1323 if (tags == TAGS_DEFAULT && autotags) {
1324 struct ref **tail = &ref_map;
1325 ref_map = NULL;
1326 find_non_local_tags(remote_refs, &ref_map, &tail);
1327 if (ref_map)
1328 backfill_tags(transport, ref_map);
1329 free_refs(ref_map);
1330 }
1331
1332 cleanup:
1333 return retcode;
1334 }
1335
1336 static int get_one_remote_for_fetch(struct remote *remote, void *priv)
1337 {
1338 struct string_list *list = priv;
1339 if (!remote->skip_default_update)
1340 string_list_append(list, remote->name);
1341 return 0;
1342 }
1343
1344 struct remote_group_data {
1345 const char *name;
1346 struct string_list *list;
1347 };
1348
1349 static int get_remote_group(const char *key, const char *value, void *priv)
1350 {
1351 struct remote_group_data *g = priv;
1352
1353 if (skip_prefix(key, "remotes.", &key) && !strcmp(key, g->name)) {
1354 /* split list by white space */
1355 while (*value) {
1356 size_t wordlen = strcspn(value, " \t\n");
1357
1358 if (wordlen >= 1)
1359 string_list_append_nodup(g->list,
1360 xstrndup(value, wordlen));
1361 value += wordlen + (value[wordlen] != '\0');
1362 }
1363 }
1364
1365 return 0;
1366 }
1367
1368 static int add_remote_or_group(const char *name, struct string_list *list)
1369 {
1370 int prev_nr = list->nr;
1371 struct remote_group_data g;
1372 g.name = name; g.list = list;
1373
1374 git_config(get_remote_group, &g);
1375 if (list->nr == prev_nr) {
1376 struct remote *remote = remote_get(name);
1377 if (!remote_is_configured(remote, 0))
1378 return 0;
1379 string_list_append(list, remote->name);
1380 }
1381 return 1;
1382 }
1383
1384 static void add_options_to_argv(struct argv_array *argv)
1385 {
1386 if (dry_run)
1387 argv_array_push(argv, "--dry-run");
1388 if (prune != -1)
1389 argv_array_push(argv, prune ? "--prune" : "--no-prune");
1390 if (prune_tags != -1)
1391 argv_array_push(argv, prune_tags ? "--prune-tags" : "--no-prune-tags");
1392 if (update_head_ok)
1393 argv_array_push(argv, "--update-head-ok");
1394 if (force)
1395 argv_array_push(argv, "--force");
1396 if (keep)
1397 argv_array_push(argv, "--keep");
1398 if (recurse_submodules == RECURSE_SUBMODULES_ON)
1399 argv_array_push(argv, "--recurse-submodules");
1400 else if (recurse_submodules == RECURSE_SUBMODULES_ON_DEMAND)
1401 argv_array_push(argv, "--recurse-submodules=on-demand");
1402 if (tags == TAGS_SET)
1403 argv_array_push(argv, "--tags");
1404 else if (tags == TAGS_UNSET)
1405 argv_array_push(argv, "--no-tags");
1406 if (verbosity >= 2)
1407 argv_array_push(argv, "-v");
1408 if (verbosity >= 1)
1409 argv_array_push(argv, "-v");
1410 else if (verbosity < 0)
1411 argv_array_push(argv, "-q");
1412
1413 }
1414
1415 static int fetch_multiple(struct string_list *list)
1416 {
1417 int i, result = 0;
1418 struct argv_array argv = ARGV_ARRAY_INIT;
1419
1420 if (!append && !dry_run) {
1421 int errcode = truncate_fetch_head();
1422 if (errcode)
1423 return errcode;
1424 }
1425
1426 argv_array_pushl(&argv, "fetch", "--append", NULL);
1427 add_options_to_argv(&argv);
1428
1429 for (i = 0; i < list->nr; i++) {
1430 const char *name = list->items[i].string;
1431 argv_array_push(&argv, name);
1432 if (verbosity >= 0)
1433 printf(_("Fetching %s\n"), name);
1434 if (run_command_v_opt(argv.argv, RUN_GIT_CMD)) {
1435 error(_("Could not fetch %s"), name);
1436 result = 1;
1437 }
1438 argv_array_pop(&argv);
1439 }
1440
1441 argv_array_clear(&argv);
1442 return result;
1443 }
1444
1445 /*
1446 * Fetching from the promisor remote should use the given filter-spec
1447 * or inherit the default filter-spec from the config.
1448 */
1449 static inline void fetch_one_setup_partial(struct remote *remote)
1450 {
1451 /*
1452 * Explicit --no-filter argument overrides everything, regardless
1453 * of any prior partial clones and fetches.
1454 */
1455 if (filter_options.no_filter)
1456 return;
1457
1458 /*
1459 * If no prior partial clone/fetch and the current fetch DID NOT
1460 * request a partial-fetch, do a normal fetch.
1461 */
1462 if (!repository_format_partial_clone && !filter_options.choice)
1463 return;
1464
1465 /*
1466 * If this is the FIRST partial-fetch request, we enable partial
1467 * on this repo and remember the given filter-spec as the default
1468 * for subsequent fetches to this remote.
1469 */
1470 if (!repository_format_partial_clone && filter_options.choice) {
1471 partial_clone_register(remote->name, &filter_options);
1472 return;
1473 }
1474
1475 /*
1476 * We are currently limited to only ONE promisor remote and only
1477 * allow partial-fetches from the promisor remote.
1478 */
1479 if (strcmp(remote->name, repository_format_partial_clone)) {
1480 if (filter_options.choice)
1481 die(_("--filter can only be used with the remote configured in core.partialClone"));
1482 return;
1483 }
1484
1485 /*
1486 * Do a partial-fetch from the promisor remote using either the
1487 * explicitly given filter-spec or inherit the filter-spec from
1488 * the config.
1489 */
1490 if (!filter_options.choice)
1491 partial_clone_get_default_filter_spec(&filter_options);
1492 return;
1493 }
1494
1495 static int fetch_one(struct remote *remote, int argc, const char **argv, int prune_tags_ok)
1496 {
1497 struct refspec rs = REFSPEC_INIT_FETCH;
1498 int i;
1499 int exit_code;
1500 int maybe_prune_tags;
1501 int remote_via_config = remote_is_configured(remote, 0);
1502
1503 if (!remote)
1504 die(_("No remote repository specified. Please, specify either a URL or a\n"
1505 "remote name from which new revisions should be fetched."));
1506
1507 gtransport = prepare_transport(remote, 1);
1508
1509 if (prune < 0) {
1510 /* no command line request */
1511 if (0 <= remote->prune)
1512 prune = remote->prune;
1513 else if (0 <= fetch_prune_config)
1514 prune = fetch_prune_config;
1515 else
1516 prune = PRUNE_BY_DEFAULT;
1517 }
1518
1519 if (prune_tags < 0) {
1520 /* no command line request */
1521 if (0 <= remote->prune_tags)
1522 prune_tags = remote->prune_tags;
1523 else if (0 <= fetch_prune_tags_config)
1524 prune_tags = fetch_prune_tags_config;
1525 else
1526 prune_tags = PRUNE_TAGS_BY_DEFAULT;
1527 }
1528
1529 maybe_prune_tags = prune_tags_ok && prune_tags;
1530 if (maybe_prune_tags && remote_via_config)
1531 refspec_append(&remote->fetch, TAG_REFSPEC);
1532
1533 if (maybe_prune_tags && (argc || !remote_via_config))
1534 refspec_append(&rs, TAG_REFSPEC);
1535
1536 for (i = 0; i < argc; i++) {
1537 if (!strcmp(argv[i], "tag")) {
1538 char *tag;
1539 i++;
1540 if (i >= argc)
1541 die(_("You need to specify a tag name."));
1542
1543 tag = xstrfmt("refs/tags/%s:refs/tags/%s",
1544 argv[i], argv[i]);
1545 refspec_append(&rs, tag);
1546 free(tag);
1547 } else {
1548 refspec_append(&rs, argv[i]);
1549 }
1550 }
1551
1552 if (server_options.nr)
1553 gtransport->server_options = &server_options;
1554
1555 sigchain_push_common(unlock_pack_on_signal);
1556 atexit(unlock_pack);
1557 exit_code = do_fetch(gtransport, &rs);
1558 refspec_clear(&rs);
1559 transport_disconnect(gtransport);
1560 gtransport = NULL;
1561 return exit_code;
1562 }
1563
1564 int cmd_fetch(int argc, const char **argv, const char *prefix)
1565 {
1566 int i;
1567 struct string_list list = STRING_LIST_INIT_DUP;
1568 struct remote *remote = NULL;
1569 int result = 0;
1570 int prune_tags_ok = 1;
1571 struct argv_array argv_gc_auto = ARGV_ARRAY_INIT;
1572
1573 packet_trace_identity("fetch");
1574
1575 fetch_if_missing = 0;
1576
1577 /* Record the command line for the reflog */
1578 strbuf_addstr(&default_rla, "fetch");
1579 for (i = 1; i < argc; i++)
1580 strbuf_addf(&default_rla, " %s", argv[i]);
1581
1582 fetch_config_from_gitmodules(&max_children, &recurse_submodules);
1583 git_config(git_fetch_config, NULL);
1584
1585 argc = parse_options(argc, argv, prefix,
1586 builtin_fetch_options, builtin_fetch_usage, 0);
1587
1588 if (deepen_relative) {
1589 if (deepen_relative < 0)
1590 die(_("Negative depth in --deepen is not supported"));
1591 if (depth)
1592 die(_("--deepen and --depth are mutually exclusive"));
1593 depth = xstrfmt("%d", deepen_relative);
1594 }
1595 if (unshallow) {
1596 if (depth)
1597 die(_("--depth and --unshallow cannot be used together"));
1598 else if (!is_repository_shallow(the_repository))
1599 die(_("--unshallow on a complete repository does not make sense"));
1600 else
1601 depth = xstrfmt("%d", INFINITE_DEPTH);
1602 }
1603
1604 /* no need to be strict, transport_set_option() will validate it again */
1605 if (depth && atoi(depth) < 1)
1606 die(_("depth %s is not a positive number"), depth);
1607 if (depth || deepen_since || deepen_not.nr)
1608 deepen = 1;
1609
1610 if (filter_options.choice && !repository_format_partial_clone)
1611 die("--filter can only be used when extensions.partialClone is set");
1612
1613 if (all) {
1614 if (argc == 1)
1615 die(_("fetch --all does not take a repository argument"));
1616 else if (argc > 1)
1617 die(_("fetch --all does not make sense with refspecs"));
1618 (void) for_each_remote(get_one_remote_for_fetch, &list);
1619 } else if (argc == 0) {
1620 /* No arguments -- use default remote */
1621 remote = remote_get(NULL);
1622 } else if (multiple) {
1623 /* All arguments are assumed to be remotes or groups */
1624 for (i = 0; i < argc; i++)
1625 if (!add_remote_or_group(argv[i], &list))
1626 die(_("No such remote or remote group: %s"), argv[i]);
1627 } else {
1628 /* Single remote or group */
1629 (void) add_remote_or_group(argv[0], &list);
1630 if (list.nr > 1) {
1631 /* More than one remote */
1632 if (argc > 1)
1633 die(_("Fetching a group and specifying refspecs does not make sense"));
1634 } else {
1635 /* Zero or one remotes */
1636 remote = remote_get(argv[0]);
1637 prune_tags_ok = (argc == 1);
1638 argc--;
1639 argv++;
1640 }
1641 }
1642
1643 if (remote) {
1644 if (filter_options.choice || repository_format_partial_clone)
1645 fetch_one_setup_partial(remote);
1646 result = fetch_one(remote, argc, argv, prune_tags_ok);
1647 } else {
1648 if (filter_options.choice)
1649 die(_("--filter can only be used with the remote configured in core.partialClone"));
1650 /* TODO should this also die if we have a previous partial-clone? */
1651 result = fetch_multiple(&list);
1652 }
1653
1654 if (!result && (recurse_submodules != RECURSE_SUBMODULES_OFF)) {
1655 struct argv_array options = ARGV_ARRAY_INIT;
1656
1657 add_options_to_argv(&options);
1658 result = fetch_populated_submodules(the_repository,
1659 &options,
1660 submodule_prefix,
1661 recurse_submodules,
1662 recurse_submodules_default,
1663 verbosity < 0,
1664 max_children);
1665 argv_array_clear(&options);
1666 }
1667
1668 string_list_clear(&list, 0);
1669
1670 close_all_packs(the_repository->objects);
1671
1672 argv_array_pushl(&argv_gc_auto, "gc", "--auto", NULL);
1673 if (verbosity < 0)
1674 argv_array_push(&argv_gc_auto, "--quiet");
1675 run_command_v_opt(argv_gc_auto.argv, RUN_GIT_CMD);
1676 argv_array_clear(&argv_gc_auto);
1677
1678 return result;
1679 }
git for Debian