Merge branch 'jk/close-duped-fd-before-unlock-for-bundle'
[git] / builtin / fetch.c
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 }