1/*
2 * "git fetch"
3 */
4#include "cache.h"
5#include "config.h"
6#include "refs.h"
7#include "commit.h"
8#include "builtin.h"
9#include "string-list.h"
10#include "remote.h"
11#include "transport.h"
12#include "run-command.h"
13#include "parse-options.h"
14#include "sigchain.h"
15#include "submodule-config.h"
16#include "submodule.h"
17#include "connected.h"
18#include "argv-array.h"
19#include "utf8.h"
20static const char * const builtin_fetch_usage[] = {
22 N_("git fetch [<options>] [<repository> [<refspec>...]]"),
23 N_("git fetch [<options>] <group>"),
24 N_("git fetch --multiple [<options>] [(<repository> | <group>)...]"),
25 N_("git fetch --all [<options>]"),
26 NULL
27};
28enum {
30 TAGS_UNSET = 0,
31 TAGS_DEFAULT = 1,
32 TAGS_SET = 2
33};
34static int fetch_prune_config = -1; /* unspecified */
36static int prune = -1; /* unspecified */
37#define PRUNE_BY_DEFAULT 0 /* do we prune by default? */
38static int all, append, dry_run, force, keep, multiple, update_head_ok, verbosity, deepen_relative;
40static int progress = -1, recurse_submodules = RECURSE_SUBMODULES_DEFAULT;
41static int tags = TAGS_DEFAULT, unshallow, update_shallow, deepen;
42static int max_children = -1;
43static enum transport_family family;
44static const char *depth;
45static const char *deepen_since;
46static const char *upload_pack;
47static struct string_list deepen_not = STRING_LIST_INIT_NODUP;
48static struct strbuf default_rla = STRBUF_INIT;
49static struct transport *gtransport;
50static struct transport *gsecondary;
51static const char *submodule_prefix = "";
52static const char *recurse_submodules_default;
53static int shown_url = 0;
54static int refmap_alloc, refmap_nr;
55static const char **refmap_array;
56static int option_parse_recurse_submodules(const struct option *opt,
58 const char *arg, int unset)
59{
60 if (unset) {
61 recurse_submodules = RECURSE_SUBMODULES_OFF;
62 } else {
63 if (arg)
64 recurse_submodules = parse_fetch_recurse_submodules_arg(opt->long_name, arg);
65 else
66 recurse_submodules = RECURSE_SUBMODULES_ON;
67 }
68 return 0;
69}
70static int git_fetch_config(const char *k, const char *v, void *cb)
72{
73 if (!strcmp(k, "fetch.prune")) {
74 fetch_prune_config = git_config_bool(k, v);
75 return 0;
76 }
77 if (!strcmp(k, "submodule.recurse")) {
79 int r = git_config_bool(k, v) ?
80 RECURSE_SUBMODULES_ON : RECURSE_SUBMODULES_OFF;
81 recurse_submodules = r;
82 }
83 return git_default_config(k, v, cb);
85}
86static int parse_refmap_arg(const struct option *opt, const char *arg, int unset)
88{
89 ALLOC_GROW(refmap_array, refmap_nr + 1, refmap_alloc);
90 /*
92 * "git fetch --refmap='' origin foo"
93 * can be used to tell the command not to store anywhere
94 */
95 if (*arg)
96 refmap_array[refmap_nr++] = arg;
97 return 0;
98}
99static struct option builtin_fetch_options[] = {
101 OPT__VERBOSITY(&verbosity),
102 OPT_BOOL(0, "all", &all,
103 N_("fetch from all remotes")),
104 OPT_BOOL('a', "append", &append,
105 N_("append to .git/FETCH_HEAD instead of overwriting")),
106 OPT_STRING(0, "upload-pack", &upload_pack, N_("path"),
107 N_("path to upload pack on remote end")),
108 OPT__FORCE(&force, N_("force overwrite of local branch")),
109 OPT_BOOL('m', "multiple", &multiple,
110 N_("fetch from multiple remotes")),
111 OPT_SET_INT('t', "tags", &tags,
112 N_("fetch all tags and associated objects"), TAGS_SET),
113 OPT_SET_INT('n', NULL, &tags,
114 N_("do not fetch all tags (--no-tags)"), TAGS_UNSET),
115 OPT_INTEGER('j', "jobs", &max_children,
116 N_("number of submodules fetched in parallel")),
117 OPT_BOOL('p', "prune", &prune,
118 N_("prune remote-tracking branches no longer on remote")),
119 { OPTION_CALLBACK, 0, "recurse-submodules", NULL, N_("on-demand"),
120 N_("control recursive fetching of submodules"),
121 PARSE_OPT_OPTARG, option_parse_recurse_submodules },
122 OPT_BOOL(0, "dry-run", &dry_run,
123 N_("dry run")),
124 OPT_BOOL('k', "keep", &keep, N_("keep downloaded pack")),
125 OPT_BOOL('u', "update-head-ok", &update_head_ok,
126 N_("allow updating of HEAD ref")),
127 OPT_BOOL(0, "progress", &progress, N_("force progress reporting")),
128 OPT_STRING(0, "depth", &depth, N_("depth"),
129 N_("deepen history of shallow clone")),
130 OPT_STRING(0, "shallow-since", &deepen_since, N_("time"),
131 N_("deepen history of shallow repository based on time")),
132 OPT_STRING_LIST(0, "shallow-exclude", &deepen_not, N_("revision"),
133 N_("deepen history of shallow clone, excluding rev")),
134 OPT_INTEGER(0, "deepen", &deepen_relative,
135 N_("deepen history of shallow clone")),
136 { OPTION_SET_INT, 0, "unshallow", &unshallow, NULL,
137 N_("convert to a complete repository"),
138 PARSE_OPT_NONEG | PARSE_OPT_NOARG, NULL, 1 },
139 { OPTION_STRING, 0, "submodule-prefix", &submodule_prefix, N_("dir"),
140 N_("prepend this to submodule path output"), PARSE_OPT_HIDDEN },
141 { OPTION_STRING, 0, "recurse-submodules-default",
142 &recurse_submodules_default, NULL,
143 N_("default mode for recursion"), PARSE_OPT_HIDDEN },
144 OPT_BOOL(0, "update-shallow", &update_shallow,
145 N_("accept refs that update .git/shallow")),
146 { OPTION_CALLBACK, 0, "refmap", NULL, N_("refmap"),
147 N_("specify fetch refmap"), PARSE_OPT_NONEG, parse_refmap_arg },
148 OPT_SET_INT('4', "ipv4", &family, N_("use IPv4 addresses only"),
149 TRANSPORT_FAMILY_IPV4),
150 OPT_SET_INT('6', "ipv6", &family, N_("use IPv6 addresses only"),
151 TRANSPORT_FAMILY_IPV6),
152 OPT_END()
153};
154static void unlock_pack(void)
156{
157 if (gtransport)
158 transport_unlock_pack(gtransport);
159 if (gsecondary)
160 transport_unlock_pack(gsecondary);
161}
162static void unlock_pack_on_signal(int signo)
164{
165 unlock_pack();
166 sigchain_pop(signo);
167 raise(signo);
168}
169static void add_merge_config(struct ref **head,
171 const struct ref *remote_refs,
172 struct branch *branch,
173 struct ref ***tail)
174{
175 int i;
176 for (i = 0; i < branch->merge_nr; i++) {
178 struct ref *rm, **old_tail = *tail;
179 struct refspec refspec;
180 for (rm = *head; rm; rm = rm->next) {
182 if (branch_merge_matches(branch, i, rm->name)) {
183 rm->fetch_head_status = FETCH_HEAD_MERGE;
184 break;
185 }
186 }
187 if (rm)
188 continue;
189 /*
191 * Not fetched to a remote-tracking branch? We need to fetch
192 * it anyway to allow this branch's "branch.$name.merge"
193 * to be honored by 'git pull', but we do not have to
194 * fail if branch.$name.merge is misconfigured to point
195 * at a nonexisting branch. If we were indeed called by
196 * 'git pull', it will notice the misconfiguration because
197 * there is no entry in the resulting FETCH_HEAD marked
198 * for merging.
199 */
200 memset(&refspec, 0, sizeof(refspec));
201 refspec.src = branch->merge[i]->src;
202 get_fetch_map(remote_refs, &refspec, tail, 1);
203 for (rm = *old_tail; rm; rm = rm->next)
204 rm->fetch_head_status = FETCH_HEAD_MERGE;
205 }
206}
207static int add_existing(const char *refname, const struct object_id *oid,
209 int flag, void *cbdata)
210{
211 struct string_list *list = (struct string_list *)cbdata;
212 struct string_list_item *item = string_list_insert(list, refname);
213 struct object_id *old_oid = xmalloc(sizeof(*old_oid));
214 oidcpy(old_oid, oid);
216 item->util = old_oid;
217 return 0;
218}
219static int will_fetch(struct ref **head, const unsigned char *sha1)
221{
222 struct ref *rm = *head;
223 while (rm) {
224 if (!hashcmp(rm->old_oid.hash, sha1))
225 return 1;
226 rm = rm->next;
227 }
228 return 0;
229}
230static void find_non_local_tags(struct transport *transport,
232 struct ref **head,
233 struct ref ***tail)
234{
235 struct string_list existing_refs = STRING_LIST_INIT_DUP;
236 struct string_list remote_refs = STRING_LIST_INIT_NODUP;
237 const struct ref *ref;
238 struct string_list_item *item = NULL;
239 for_each_ref(add_existing, &existing_refs);
241 for (ref = transport_get_remote_refs(transport); ref; ref = ref->next) {
242 if (!starts_with(ref->name, "refs/tags/"))
243 continue;
244 /*
246 * The peeled ref always follows the matching base
247 * ref, so if we see a peeled ref that we don't want
248 * to fetch then we can mark the ref entry in the list
249 * as one to ignore by setting util to NULL.
250 */
251 if (ends_with(ref->name, "^{}")) {
252 if (item &&
253 !has_object_file_with_flags(&ref->old_oid,
254 OBJECT_INFO_QUICK) &&
255 !will_fetch(head, ref->old_oid.hash) &&
256 !has_sha1_file_with_flags(item->util,
257 OBJECT_INFO_QUICK) &&
258 !will_fetch(head, item->util))
259 item->util = NULL;
260 item = NULL;
261 continue;
262 }
263 /*
265 * If item is non-NULL here, then we previously saw a
266 * ref not followed by a peeled reference, so we need
267 * to check if it is a lightweight tag that we want to
268 * fetch.
269 */
270 if (item &&
271 !has_sha1_file_with_flags(item->util, OBJECT_INFO_QUICK) &&
272 !will_fetch(head, item->util))
273 item->util = NULL;
274 item = NULL;
276 /* skip duplicates and refs that we already have */
278 if (string_list_has_string(&remote_refs, ref->name) ||
279 string_list_has_string(&existing_refs, ref->name))
280 continue;
281 item = string_list_insert(&remote_refs, ref->name);
283 item->util = (void *)&ref->old_oid;
284 }
285 string_list_clear(&existing_refs, 1);
286 /*
288 * We may have a final lightweight tag that needs to be
289 * checked to see if it needs fetching.
290 */
291 if (item &&
292 !has_sha1_file_with_flags(item->util, OBJECT_INFO_QUICK) &&
293 !will_fetch(head, item->util))
294 item->util = NULL;
295 /*
297 * For all the tags in the remote_refs string list,
298 * add them to the list of refs to be fetched
299 */
300 for_each_string_list_item(item, &remote_refs) {
301 /* Unless we have already decided to ignore this item... */
302 if (item->util)
303 {
304 struct ref *rm = alloc_ref(item->string);
305 rm->peer_ref = alloc_ref(item->string);
306 oidcpy(&rm->old_oid, item->util);
307 **tail = rm;
308 *tail = &rm->next;
309 }
310 }
311 string_list_clear(&remote_refs, 0);
313}
314static struct ref *get_ref_map(struct transport *transport,
316 struct refspec *refspecs, int refspec_count,
317 int tags, int *autotags)
318{
319 int i;
320 struct ref *rm;
321 struct ref *ref_map = NULL;
322 struct ref **tail = &ref_map;
323 /* opportunistically-updated references: */
325 struct ref *orefs = NULL, **oref_tail = &orefs;
326 const struct ref *remote_refs = transport_get_remote_refs(transport);
328 if (refspec_count) {
330 struct refspec *fetch_refspec;
331 int fetch_refspec_nr;
332 for (i = 0; i < refspec_count; i++) {
334 get_fetch_map(remote_refs, &refspecs[i], &tail, 0);
335 if (refspecs[i].dst && refspecs[i].dst[0])
336 *autotags = 1;
337 }
338 /* Merge everything on the command line (but not --tags) */
339 for (rm = ref_map; rm; rm = rm->next)
340 rm->fetch_head_status = FETCH_HEAD_MERGE;
341 /*
343 * For any refs that we happen to be fetching via
344 * command-line arguments, the destination ref might
345 * have been missing or have been different than the
346 * remote-tracking ref that would be derived from the
347 * configured refspec. In these cases, we want to
348 * take the opportunity to update their configured
349 * remote-tracking reference. However, we do not want
350 * to mention these entries in FETCH_HEAD at all, as
351 * they would simply be duplicates of existing
352 * entries, so we set them FETCH_HEAD_IGNORE below.
353 *
354 * We compute these entries now, based only on the
355 * refspecs specified on the command line. But we add
356 * them to the list following the refspecs resulting
357 * from the tags option so that one of the latter,
358 * which has FETCH_HEAD_NOT_FOR_MERGE, is not removed
359 * by ref_remove_duplicates() in favor of one of these
360 * opportunistic entries with FETCH_HEAD_IGNORE.
361 */
362 if (refmap_array) {
363 fetch_refspec = parse_fetch_refspec(refmap_nr, refmap_array);
364 fetch_refspec_nr = refmap_nr;
365 } else {
366 fetch_refspec = transport->remote->fetch;
367 fetch_refspec_nr = transport->remote->fetch_refspec_nr;
368 }
369 for (i = 0; i < fetch_refspec_nr; i++)
371 get_fetch_map(ref_map, &fetch_refspec[i], &oref_tail, 1);
372 } else if (refmap_array) {
373 die("--refmap option is only meaningful with command-line refspec(s).");
374 } else {
375 /* Use the defaults */
376 struct remote *remote = transport->remote;
377 struct branch *branch = branch_get(NULL);
378 int has_merge = branch_has_merge_config(branch);
379 if (remote &&
380 (remote->fetch_refspec_nr ||
381 /* Note: has_merge implies non-NULL branch->remote_name */
382 (has_merge && !strcmp(branch->remote_name, remote->name)))) {
383 for (i = 0; i < remote->fetch_refspec_nr; i++) {
384 get_fetch_map(remote_refs, &remote->fetch[i], &tail, 0);
385 if (remote->fetch[i].dst &&
386 remote->fetch[i].dst[0])
387 *autotags = 1;
388 if (!i && !has_merge && ref_map &&
389 !remote->fetch[0].pattern)
390 ref_map->fetch_head_status = FETCH_HEAD_MERGE;
391 }
392 /*
393 * if the remote we're fetching from is the same
394 * as given in branch.<name>.remote, we add the
395 * ref given in branch.<name>.merge, too.
396 *
397 * Note: has_merge implies non-NULL branch->remote_name
398 */
399 if (has_merge &&
400 !strcmp(branch->remote_name, remote->name))
401 add_merge_config(&ref_map, remote_refs, branch, &tail);
402 } else {
403 ref_map = get_remote_ref(remote_refs, "HEAD");
404 if (!ref_map)
405 die(_("Couldn't find remote ref HEAD"));
406 ref_map->fetch_head_status = FETCH_HEAD_MERGE;
407 tail = &ref_map->next;
408 }
409 }
410 if (tags == TAGS_SET)
412 /* also fetch all tags */
413 get_fetch_map(remote_refs, tag_refspec, &tail, 0);
414 else if (tags == TAGS_DEFAULT && *autotags)
415 find_non_local_tags(transport, &ref_map, &tail);
416 /* Now append any refs to be updated opportunistically: */
418 *tail = orefs;
419 for (rm = orefs; rm; rm = rm->next) {
420 rm->fetch_head_status = FETCH_HEAD_IGNORE;
421 tail = &rm->next;
422 }
423 return ref_remove_duplicates(ref_map);
425}
426#define STORE_REF_ERROR_OTHER 1
428#define STORE_REF_ERROR_DF_CONFLICT 2
429static int s_update_ref(const char *action,
431 struct ref *ref,
432 int check_old)
433{
434 char *msg;
435 char *rla = getenv("GIT_REFLOG_ACTION");
436 struct ref_transaction *transaction;
437 struct strbuf err = STRBUF_INIT;
438 int ret, df_conflict = 0;
439 if (dry_run)
441 return 0;
442 if (!rla)
443 rla = default_rla.buf;
444 msg = xstrfmt("%s: %s", rla, action);
445 transaction = ref_transaction_begin(&err);
447 if (!transaction ||
448 ref_transaction_update(transaction, ref->name,
449 ref->new_oid.hash,
450 check_old ? ref->old_oid.hash : NULL,
451 0, msg, &err))
452 goto fail;
453 ret = ref_transaction_commit(transaction, &err);
455 if (ret) {
456 df_conflict = (ret == TRANSACTION_NAME_CONFLICT);
457 goto fail;
458 }
459 ref_transaction_free(transaction);
461 strbuf_release(&err);
462 free(msg);
463 return 0;
464fail:
465 ref_transaction_free(transaction);
466 error("%s", err.buf);
467 strbuf_release(&err);
468 free(msg);
469 return df_conflict ? STORE_REF_ERROR_DF_CONFLICT
470 : STORE_REF_ERROR_OTHER;
471}
472static int refcol_width = 10;
474static int compact_format;
475static void adjust_refcol_width(const struct ref *ref)
477{
478 int max, rlen, llen, len;
479 /* uptodate lines are only shown on high verbosity level */
481 if (!verbosity && !oidcmp(&ref->peer_ref->old_oid, &ref->old_oid))
482 return;
483 max = term_columns();
485 rlen = utf8_strwidth(prettify_refname(ref->name));
486 llen = utf8_strwidth(prettify_refname(ref->peer_ref->name));
488 /*
490 * rough estimation to see if the output line is too long and
491 * should not be counted (we can't do precise calculation
492 * anyway because we don't know if the error explanation part
493 * will be printed in update_local_ref)
494 */
495 if (compact_format) {
496 llen = 0;
497 max = max * 2 / 3;
498 }
499 len = 21 /* flag and summary */ + rlen + 4 /* -> */ + llen;
500 if (len >= max)
501 return;
502 /*
504 * Not precise calculation for compact mode because '*' can
505 * appear on the left hand side of '->' and shrink the column
506 * back.
507 */
508 if (refcol_width < rlen)
509 refcol_width = rlen;
510}
511static void prepare_format_display(struct ref *ref_map)
513{
514 struct ref *rm;
515 const char *format = "full";
516 git_config_get_string_const("fetch.output", &format);
518 if (!strcasecmp(format, "full"))
519 compact_format = 0;
520 else if (!strcasecmp(format, "compact"))
521 compact_format = 1;
522 else
523 die(_("configuration fetch.output contains invalid value %s"),
524 format);
525 for (rm = ref_map; rm; rm = rm->next) {
527 if (rm->status == REF_STATUS_REJECT_SHALLOW ||
528 !rm->peer_ref ||
529 !strcmp(rm->name, "HEAD"))
530 continue;
531 adjust_refcol_width(rm);
533 }
534}
535static void print_remote_to_local(struct strbuf *display,
537 const char *remote, const char *local)
538{
539 strbuf_addf(display, "%-*s -> %s", refcol_width, remote, local);
540}
541static int find_and_replace(struct strbuf *haystack,
543 const char *needle,
544 const char *placeholder)
545{
546 const char *p = strstr(haystack->buf, needle);
547 int plen, nlen;
548 if (!p)
550 return 0;
551 if (p > haystack->buf && p[-1] != '/')
553 return 0;
554 plen = strlen(p);
556 nlen = strlen(needle);
557 if (plen > nlen && p[nlen] != '/')
558 return 0;
559 strbuf_splice(haystack, p - haystack->buf, nlen,
561 placeholder, strlen(placeholder));
562 return 1;
563}
564static void print_compact(struct strbuf *display,
566 const char *remote, const char *local)
567{
568 struct strbuf r = STRBUF_INIT;
569 struct strbuf l = STRBUF_INIT;
570 if (!strcmp(remote, local)) {
572 strbuf_addf(display, "%-*s -> *", refcol_width, remote);
573 return;
574 }
575 strbuf_addstr(&r, remote);
577 strbuf_addstr(&l, local);
578 if (!find_and_replace(&r, local, "*"))
580 find_and_replace(&l, remote, "*");
581 print_remote_to_local(display, r.buf, l.buf);
582 strbuf_release(&r);
584 strbuf_release(&l);
585}
586static void format_display(struct strbuf *display, char code,
588 const char *summary, const char *error,
589 const char *remote, const char *local,
590 int summary_width)
591{
592 int width = (summary_width + strlen(summary) - gettext_width(summary));
593 strbuf_addf(display, "%c %-*s ", code, width, summary);
595 if (!compact_format)
596 print_remote_to_local(display, remote, local);
597 else
598 print_compact(display, remote, local);
599 if (error)
600 strbuf_addf(display, " (%s)", error);
601}
602static int update_local_ref(struct ref *ref,
604 const char *remote,
605 const struct ref *remote_ref,
606 struct strbuf *display,
607 int summary_width)
608{
609 struct commit *current = NULL, *updated;
610 enum object_type type;
611 struct branch *current_branch = branch_get(NULL);
612 const char *pretty_ref = prettify_refname(ref->name);
613 type = sha1_object_info(ref->new_oid.hash, NULL);
615 if (type < 0)
616 die(_("object %s not found"), oid_to_hex(&ref->new_oid));
617 if (!oidcmp(&ref->old_oid, &ref->new_oid)) {
619 if (verbosity > 0)
620 format_display(display, '=', _("[up to date]"), NULL,
621 remote, pretty_ref, summary_width);
622 return 0;
623 }
624 if (current_branch &&
626 !strcmp(ref->name, current_branch->name) &&
627 !(update_head_ok || is_bare_repository()) &&
628 !is_null_oid(&ref->old_oid)) {
629 /*
630 * If this is the head, and it's not okay to update
631 * the head, and the old value of the head isn't empty...
632 */
633 format_display(display, '!', _("[rejected]"),
634 _("can't fetch in current branch"),
635 remote, pretty_ref, summary_width);
636 return 1;
637 }
638 if (!is_null_oid(&ref->old_oid) &&
640 starts_with(ref->name, "refs/tags/")) {
641 int r;
642 r = s_update_ref("updating tag", ref, 0);
643 format_display(display, r ? '!' : 't', _("[tag update]"),
644 r ? _("unable to update local ref") : NULL,
645 remote, pretty_ref, summary_width);
646 return r;
647 }
648 current = lookup_commit_reference_gently(&ref->old_oid, 1);
650 updated = lookup_commit_reference_gently(&ref->new_oid, 1);
651 if (!current || !updated) {
652 const char *msg;
653 const char *what;
654 int r;
655 /*
656 * Nicely describe the new ref we're fetching.
657 * Base this on the remote's ref name, as it's
658 * more likely to follow a standard layout.
659 */
660 const char *name = remote_ref ? remote_ref->name : "";
661 if (starts_with(name, "refs/tags/")) {
662 msg = "storing tag";
663 what = _("[new tag]");
664 } else if (starts_with(name, "refs/heads/")) {
665 msg = "storing head";
666 what = _("[new branch]");
667 } else {
668 msg = "storing ref";
669 what = _("[new ref]");
670 }
671 if ((recurse_submodules != RECURSE_SUBMODULES_OFF) &&
673 (recurse_submodules != RECURSE_SUBMODULES_ON))
674 check_for_new_submodule_commits(&ref->new_oid);
675 r = s_update_ref(msg, ref, 0);
676 format_display(display, r ? '!' : '*', what,
677 r ? _("unable to update local ref") : NULL,
678 remote, pretty_ref, summary_width);
679 return r;
680 }
681 if (in_merge_bases(current, updated)) {
683 struct strbuf quickref = STRBUF_INIT;
684 int r;
685 strbuf_add_unique_abbrev(&quickref, current->object.oid.hash, DEFAULT_ABBREV);
686 strbuf_addstr(&quickref, "..");
687 strbuf_add_unique_abbrev(&quickref, ref->new_oid.hash, DEFAULT_ABBREV);
688 if ((recurse_submodules != RECURSE_SUBMODULES_OFF) &&
689 (recurse_submodules != RECURSE_SUBMODULES_ON))
690 check_for_new_submodule_commits(&ref->new_oid);
691 r = s_update_ref("fast-forward", ref, 1);
692 format_display(display, r ? '!' : ' ', quickref.buf,
693 r ? _("unable to update local ref") : NULL,
694 remote, pretty_ref, summary_width);
695 strbuf_release(&quickref);
696 return r;
697 } else if (force || ref->force) {
698 struct strbuf quickref = STRBUF_INIT;
699 int r;
700 strbuf_add_unique_abbrev(&quickref, current->object.oid.hash, DEFAULT_ABBREV);
701 strbuf_addstr(&quickref, "...");
702 strbuf_add_unique_abbrev(&quickref, ref->new_oid.hash, DEFAULT_ABBREV);
703 if ((recurse_submodules != RECURSE_SUBMODULES_OFF) &&
704 (recurse_submodules != RECURSE_SUBMODULES_ON))
705 check_for_new_submodule_commits(&ref->new_oid);
706 r = s_update_ref("forced-update", ref, 1);
707 format_display(display, r ? '!' : '+', quickref.buf,
708 r ? _("unable to update local ref") : _("forced update"),
709 remote, pretty_ref, summary_width);
710 strbuf_release(&quickref);
711 return r;
712 } else {
713 format_display(display, '!', _("[rejected]"), _("non-fast-forward"),
714 remote, pretty_ref, summary_width);
715 return 1;
716 }
717}
718static int iterate_ref_map(void *cb_data, unsigned char sha1[20])
720{
721 struct ref **rm = cb_data;
722 struct ref *ref = *rm;
723 while (ref && ref->status == REF_STATUS_REJECT_SHALLOW)
725 ref = ref->next;
726 if (!ref)
727 return -1; /* end of the list */
728 *rm = ref->next;
729 hashcpy(sha1, ref->old_oid.hash);
730 return 0;
731}
732static int store_updated_refs(const char *raw_url, const char *remote_name,
734 struct ref *ref_map)
735{
736 FILE *fp;
737 struct commit *commit;
738 int url_len, i, rc = 0;
739 struct strbuf note = STRBUF_INIT;
740 const char *what, *kind;
741 struct ref *rm;
742 char *url;
743 const char *filename = dry_run ? "/dev/null" : git_path_fetch_head();
744 int want_status;
745 int summary_width = transport_summary_width(ref_map);
746 fp = fopen(filename, "a");
748 if (!fp)
749 return error_errno(_("cannot open %s"), filename);
750 if (raw_url)
752 url = transport_anonymize_url(raw_url);
753 else
754 url = xstrdup("foreign");
755 rm = ref_map;
757 if (check_connected(iterate_ref_map, &rm, NULL)) {
758 rc = error(_("%s did not send all necessary objects\n"), url);
759 goto abort;
760 }
761 prepare_format_display(ref_map);
763 /*
765 * We do a pass for each fetch_head_status type in their enum order, so
766 * merged entries are written before not-for-merge. That lets readers
767 * use FETCH_HEAD as a refname to refer to the ref to be merged.
768 */
769 for (want_status = FETCH_HEAD_MERGE;
770 want_status <= FETCH_HEAD_IGNORE;
771 want_status++) {
772 for (rm = ref_map; rm; rm = rm->next) {
773 struct ref *ref = NULL;
774 const char *merge_status_marker = "";
775 if (rm->status == REF_STATUS_REJECT_SHALLOW) {
777 if (want_status == FETCH_HEAD_MERGE)
778 warning(_("reject %s because shallow roots are not allowed to be updated"),
779 rm->peer_ref ? rm->peer_ref->name : rm->name);
780 continue;
781 }
782 commit = lookup_commit_reference_gently(&rm->old_oid,
784 1);
785 if (!commit)
786 rm->fetch_head_status = FETCH_HEAD_NOT_FOR_MERGE;
787 if (rm->fetch_head_status != want_status)
789 continue;
790 if (rm->peer_ref) {
792 ref = alloc_ref(rm->peer_ref->name);
793 oidcpy(&ref->old_oid, &rm->peer_ref->old_oid);
794 oidcpy(&ref->new_oid, &rm->old_oid);
795 ref->force = rm->peer_ref->force;
796 }
797 if (!strcmp(rm->name, "HEAD")) {
800 kind = "";
801 what = "";
802 }
803 else if (starts_with(rm->name, "refs/heads/")) {
804 kind = "branch";
805 what = rm->name + 11;
806 }
807 else if (starts_with(rm->name, "refs/tags/")) {
808 kind = "tag";
809 what = rm->name + 10;
810 }
811 else if (starts_with(rm->name, "refs/remotes/")) {
812 kind = "remote-tracking branch";
813 what = rm->name + 13;
814 }
815 else {
816 kind = "";
817 what = rm->name;
818 }
819 url_len = strlen(url);
821 for (i = url_len - 1; url[i] == '/' && 0 <= i; i--)
822 ;
823 url_len = i + 1;
824 if (4 < i && !strncmp(".git", url + i - 3, 4))
825 url_len = i - 3;
826 strbuf_reset(¬e);
828 if (*what) {
829 if (*kind)
830 strbuf_addf(¬e, "%s ", kind);
831 strbuf_addf(¬e, "'%s' of ", what);
832 }
833 switch (rm->fetch_head_status) {
834 case FETCH_HEAD_NOT_FOR_MERGE:
835 merge_status_marker = "not-for-merge";
836 /* fall-through */
837 case FETCH_HEAD_MERGE:
838 fprintf(fp, "%s\t%s\t%s",
839 oid_to_hex(&rm->old_oid),
840 merge_status_marker,
841 note.buf);
842 for (i = 0; i < url_len; ++i)
843 if ('\n' == url[i])
844 fputs("\\n", fp);
845 else
846 fputc(url[i], fp);
847 fputc('\n', fp);
848 break;
849 default:
850 /* do not write anything to FETCH_HEAD */
851 break;
852 }
853 strbuf_reset(¬e);
855 if (ref) {
856 rc |= update_local_ref(ref, what, rm, ¬e,
857 summary_width);
858 free(ref);
859 } else
860 format_display(¬e, '*',
861 *kind ? kind : "branch", NULL,
862 *what ? what : "HEAD",
863 "FETCH_HEAD", summary_width);
864 if (note.len) {
865 if (verbosity >= 0 && !shown_url) {
866 fprintf(stderr, _("From %.*s\n"),
867 url_len, url);
868 shown_url = 1;
869 }
870 if (verbosity >= 0)
871 fprintf(stderr, " %s\n", note.buf);
872 }
873 }
874 }
875 if (rc & STORE_REF_ERROR_DF_CONFLICT)
877 error(_("some local refs could not be updated; try running\n"
878 " 'git remote prune %s' to remove any old, conflicting "
879 "branches"), remote_name);
880 abort:
882 strbuf_release(¬e);
883 free(url);
884 fclose(fp);
885 return rc;
886}
887/*
889 * We would want to bypass the object transfer altogether if
890 * everything we are going to fetch already exists and is connected
891 * locally.
892 */
893static int quickfetch(struct ref *ref_map)
894{
895 struct ref *rm = ref_map;
896 struct check_connected_options opt = CHECK_CONNECTED_INIT;
897 /*
899 * If we are deepening a shallow clone we already have these
900 * objects reachable. Running rev-list here will return with
901 * a good (0) exit status and we'll bypass the fetch that we
902 * really need to perform. Claiming failure now will ensure
903 * we perform the network exchange to deepen our history.
904 */
905 if (deepen)
906 return -1;
907 opt.quiet = 1;
908 return check_connected(iterate_ref_map, &rm, &opt);
909}
910static int fetch_refs(struct transport *transport, struct ref *ref_map)
912{
913 int ret = quickfetch(ref_map);
914 if (ret)
915 ret = transport_fetch_refs(transport, ref_map);
916 if (!ret)
917 ret |= store_updated_refs(transport->url,
918 transport->remote->name,
919 ref_map);
920 transport_unlock_pack(transport);
921 return ret;
922}
923static int prune_refs(struct refspec *refs, int ref_count, struct ref *ref_map,
925 const char *raw_url)
926{
927 int url_len, i, result = 0;
928 struct ref *ref, *stale_refs = get_stale_heads(refs, ref_count, ref_map);
929 char *url;
930 int summary_width = transport_summary_width(stale_refs);
931 const char *dangling_msg = dry_run
932 ? _(" (%s will become dangling)")
933 : _(" (%s has become dangling)");
934 if (raw_url)
936 url = transport_anonymize_url(raw_url);
937 else
938 url = xstrdup("foreign");
939 url_len = strlen(url);
941 for (i = url_len - 1; url[i] == '/' && 0 <= i; i--)
942 ;
943 url_len = i + 1;
945 if (4 < i && !strncmp(".git", url + i - 3, 4))
946 url_len = i - 3;
947 if (!dry_run) {
949 struct string_list refnames = STRING_LIST_INIT_NODUP;
950 for (ref = stale_refs; ref; ref = ref->next)
952 string_list_append(&refnames, ref->name);
953 result = delete_refs("fetch: prune", &refnames, 0);
955 string_list_clear(&refnames, 0);
956 }
957 if (verbosity >= 0) {
959 for (ref = stale_refs; ref; ref = ref->next) {
960 struct strbuf sb = STRBUF_INIT;
961 if (!shown_url) {
962 fprintf(stderr, _("From %.*s\n"), url_len, url);
963 shown_url = 1;
964 }
965 format_display(&sb, '-', _("[deleted]"), NULL,
966 _("(none)"), prettify_refname(ref->name),
967 summary_width);
968 fprintf(stderr, " %s\n",sb.buf);
969 strbuf_release(&sb);
970 warn_dangling_symref(stderr, dangling_msg, ref->name);
971 }
972 }
973 free(url);
975 free_refs(stale_refs);
976 return result;
977}
978static void check_not_current_branch(struct ref *ref_map)
980{
981 struct branch *current_branch = branch_get(NULL);
982 if (is_bare_repository() || !current_branch)
984 return;
985 for (; ref_map; ref_map = ref_map->next)
987 if (ref_map->peer_ref && !strcmp(current_branch->refname,
988 ref_map->peer_ref->name))
989 die(_("Refusing to fetch into current branch %s "
990 "of non-bare repository"), current_branch->refname);
991}
992static int truncate_fetch_head(void)
994{
995 const char *filename = git_path_fetch_head();
996 FILE *fp = fopen_for_writing(filename);
997 if (!fp)
999 return error_errno(_("cannot open %s"), filename);
1000 fclose(fp);
1001 return 0;
1002}
1003static void set_option(struct transport *transport, const char *name, const char *value)
1005{
1006 int r = transport_set_option(transport, name, value);
1007 if (r < 0)
1008 die(_("Option \"%s\" value \"%s\" is not valid for %s"),
1009 name, value, transport->url);
1010 if (r > 0)
1011 warning(_("Option \"%s\" is ignored for %s\n"),
1012 name, transport->url);
1013}
1014static struct transport *prepare_transport(struct remote *remote, int deepen)
1016{
1017 struct transport *transport;
1018 transport = transport_get(remote, NULL);
1019 transport_set_verbosity(transport, verbosity, progress);
1020 transport->family = family;
1021 if (upload_pack)
1022 set_option(transport, TRANS_OPT_UPLOADPACK, upload_pack);
1023 if (keep)
1024 set_option(transport, TRANS_OPT_KEEP, "yes");
1025 if (depth)
1026 set_option(transport, TRANS_OPT_DEPTH, depth);
1027 if (deepen && deepen_since)
1028 set_option(transport, TRANS_OPT_DEEPEN_SINCE, deepen_since);
1029 if (deepen && deepen_not.nr)
1030 set_option(transport, TRANS_OPT_DEEPEN_NOT,
1031 (const char *)&deepen_not);
1032 if (deepen_relative)
1033 set_option(transport, TRANS_OPT_DEEPEN_RELATIVE, "yes");
1034 if (update_shallow)
1035 set_option(transport, TRANS_OPT_UPDATE_SHALLOW, "yes");
1036 return transport;
1037}
1038static void backfill_tags(struct transport *transport, struct ref *ref_map)
1040{
1041 int cannot_reuse;
1042 /*
1044 * Once we have set TRANS_OPT_DEEPEN_SINCE, we can't unset it
1045 * when remote helper is used (setting it to an empty string
1046 * is not unsetting). We could extend the remote helper
1047 * protocol for that, but for now, just force a new connection
1048 * without deepen-since. Similar story for deepen-not.
1049 */
1050 cannot_reuse = transport->cannot_reuse ||
1051 deepen_since || deepen_not.nr;
1052 if (cannot_reuse) {
1053 gsecondary = prepare_transport(transport->remote, 0);
1054 transport = gsecondary;
1055 }
1056 transport_set_option(transport, TRANS_OPT_FOLLOWTAGS, NULL);
1058 transport_set_option(transport, TRANS_OPT_DEPTH, "0");
1059 transport_set_option(transport, TRANS_OPT_DEEPEN_RELATIVE, NULL);
1060 fetch_refs(transport, ref_map);
1061 if (gsecondary) {
1063 transport_disconnect(gsecondary);
1064 gsecondary = NULL;
1065 }
1066}
1067static int do_fetch(struct transport *transport,
1069 struct refspec *refs, int ref_count)
1070{
1071 struct string_list existing_refs = STRING_LIST_INIT_DUP;
1072 struct ref *ref_map;
1073 struct ref *rm;
1074 int autotags = (transport->remote->fetch_tags == 1);
1075 int retcode = 0;
1076 for_each_ref(add_existing, &existing_refs);
1078 if (tags == TAGS_DEFAULT) {
1080 if (transport->remote->fetch_tags == 2)
1081 tags = TAGS_SET;
1082 if (transport->remote->fetch_tags == -1)
1083 tags = TAGS_UNSET;
1084 }
1085 if (!transport->get_refs_list || !transport->fetch)
1087 die(_("Don't know how to fetch from %s"), transport->url);
1088 /* if not appending, truncate FETCH_HEAD */
1090 if (!append && !dry_run) {
1091 retcode = truncate_fetch_head();
1092 if (retcode)
1093 goto cleanup;
1094 }
1095 ref_map = get_ref_map(transport, refs, ref_count, tags, &autotags);
1097 if (!update_head_ok)
1098 check_not_current_branch(ref_map);
1099 for (rm = ref_map; rm; rm = rm->next) {
1101 if (rm->peer_ref) {
1102 struct string_list_item *peer_item =
1103 string_list_lookup(&existing_refs,
1104 rm->peer_ref->name);
1105 if (peer_item) {
1106 struct object_id *old_oid = peer_item->util;
1107 oidcpy(&rm->peer_ref->old_oid, old_oid);
1108 }
1109 }
1110 }
1111 if (tags == TAGS_DEFAULT && autotags)
1113 transport_set_option(transport, TRANS_OPT_FOLLOWTAGS, "1");
1114 if (prune) {
1115 /*
1116 * We only prune based on refspecs specified
1117 * explicitly (via command line or configuration); we
1118 * don't care whether --tags was specified.
1119 */
1120 if (ref_count) {
1121 prune_refs(refs, ref_count, ref_map, transport->url);
1122 } else {
1123 prune_refs(transport->remote->fetch,
1124 transport->remote->fetch_refspec_nr,
1125 ref_map,
1126 transport->url);
1127 }
1128 }
1129 if (fetch_refs(transport, ref_map)) {
1130 free_refs(ref_map);
1131 retcode = 1;
1132 goto cleanup;
1133 }
1134 free_refs(ref_map);
1135 /* if neither --no-tags nor --tags was specified, do automated tag
1137 * following ... */
1138 if (tags == TAGS_DEFAULT && autotags) {
1139 struct ref **tail = &ref_map;
1140 ref_map = NULL;
1141 find_non_local_tags(transport, &ref_map, &tail);
1142 if (ref_map)
1143 backfill_tags(transport, ref_map);
1144 free_refs(ref_map);
1145 }
1146 cleanup:
1148 string_list_clear(&existing_refs, 1);
1149 return retcode;
1150}
1151static int get_one_remote_for_fetch(struct remote *remote, void *priv)
1153{
1154 struct string_list *list = priv;
1155 if (!remote->skip_default_update)
1156 string_list_append(list, remote->name);
1157 return 0;
1158}
1159struct remote_group_data {
1161 const char *name;
1162 struct string_list *list;
1163};
1164static int get_remote_group(const char *key, const char *value, void *priv)
1166{
1167 struct remote_group_data *g = priv;
1168 if (skip_prefix(key, "remotes.", &key) && !strcmp(key, g->name)) {
1170 /* split list by white space */
1171 while (*value) {
1172 size_t wordlen = strcspn(value, " \t\n");
1173 if (wordlen >= 1)
1175 string_list_append_nodup(g->list,
1176 xstrndup(value, wordlen));
1177 value += wordlen + (value[wordlen] != '\0');
1178 }
1179 }
1180 return 0;
1182}
1183static int add_remote_or_group(const char *name, struct string_list *list)
1185{
1186 int prev_nr = list->nr;
1187 struct remote_group_data g;
1188 g.name = name; g.list = list;
1189 git_config(get_remote_group, &g);
1191 if (list->nr == prev_nr) {
1192 struct remote *remote = remote_get(name);
1193 if (!remote_is_configured(remote, 0))
1194 return 0;
1195 string_list_append(list, remote->name);
1196 }
1197 return 1;
1198}
1199static void add_options_to_argv(struct argv_array *argv)
1201{
1202 if (dry_run)
1203 argv_array_push(argv, "--dry-run");
1204 if (prune != -1)
1205 argv_array_push(argv, prune ? "--prune" : "--no-prune");
1206 if (update_head_ok)
1207 argv_array_push(argv, "--update-head-ok");
1208 if (force)
1209 argv_array_push(argv, "--force");
1210 if (keep)
1211 argv_array_push(argv, "--keep");
1212 if (recurse_submodules == RECURSE_SUBMODULES_ON)
1213 argv_array_push(argv, "--recurse-submodules");
1214 else if (recurse_submodules == RECURSE_SUBMODULES_ON_DEMAND)
1215 argv_array_push(argv, "--recurse-submodules=on-demand");
1216 if (tags == TAGS_SET)
1217 argv_array_push(argv, "--tags");
1218 else if (tags == TAGS_UNSET)
1219 argv_array_push(argv, "--no-tags");
1220 if (verbosity >= 2)
1221 argv_array_push(argv, "-v");
1222 if (verbosity >= 1)
1223 argv_array_push(argv, "-v");
1224 else if (verbosity < 0)
1225 argv_array_push(argv, "-q");
1226}
1228static int fetch_multiple(struct string_list *list)
1230{
1231 int i, result = 0;
1232 struct argv_array argv = ARGV_ARRAY_INIT;
1233 if (!append && !dry_run) {
1235 int errcode = truncate_fetch_head();
1236 if (errcode)
1237 return errcode;
1238 }
1239 argv_array_pushl(&argv, "fetch", "--append", NULL);
1241 add_options_to_argv(&argv);
1242 for (i = 0; i < list->nr; i++) {
1244 const char *name = list->items[i].string;
1245 argv_array_push(&argv, name);
1246 if (verbosity >= 0)
1247 printf(_("Fetching %s\n"), name);
1248 if (run_command_v_opt(argv.argv, RUN_GIT_CMD)) {
1249 error(_("Could not fetch %s"), name);
1250 result = 1;
1251 }
1252 argv_array_pop(&argv);
1253 }
1254 argv_array_clear(&argv);
1256 return result;
1257}
1258static int fetch_one(struct remote *remote, int argc, const char **argv)
1260{
1261 static const char **refs = NULL;
1262 struct refspec *refspec;
1263 int ref_nr = 0;
1264 int exit_code;
1265 if (!remote)
1267 die(_("No remote repository specified. Please, specify either a URL or a\n"
1268 "remote name from which new revisions should be fetched."));
1269 gtransport = prepare_transport(remote, 1);
1271 if (prune < 0) {
1273 /* no command line request */
1274 if (0 <= gtransport->remote->prune)
1275 prune = gtransport->remote->prune;
1276 else if (0 <= fetch_prune_config)
1277 prune = fetch_prune_config;
1278 else
1279 prune = PRUNE_BY_DEFAULT;
1280 }
1281 if (argc > 0) {
1283 int j = 0;
1284 int i;
1285 refs = xcalloc(st_add(argc, 1), sizeof(const char *));
1286 for (i = 0; i < argc; i++) {
1287 if (!strcmp(argv[i], "tag")) {
1288 i++;
1289 if (i >= argc)
1290 die(_("You need to specify a tag name."));
1291 refs[j++] = xstrfmt("refs/tags/%s:refs/tags/%s",
1292 argv[i], argv[i]);
1293 } else
1294 refs[j++] = argv[i];
1295 }
1296 refs[j] = NULL;
1297 ref_nr = j;
1298 }
1299 sigchain_push_common(unlock_pack_on_signal);
1301 atexit(unlock_pack);
1302 refspec = parse_fetch_refspec(ref_nr, refs);
1303 exit_code = do_fetch(gtransport, refspec, ref_nr);
1304 free_refspec(ref_nr, refspec);
1305 transport_disconnect(gtransport);
1306 gtransport = NULL;
1307 return exit_code;
1308}
1309int cmd_fetch(int argc, const char **argv, const char *prefix)
1311{
1312 int i;
1313 struct string_list list = STRING_LIST_INIT_DUP;
1314 struct remote *remote;
1315 int result = 0;
1316 struct argv_array argv_gc_auto = ARGV_ARRAY_INIT;
1317 packet_trace_identity("fetch");
1319 /* Record the command line for the reflog */
1321 strbuf_addstr(&default_rla, "fetch");
1322 for (i = 1; i < argc; i++)
1323 strbuf_addf(&default_rla, " %s", argv[i]);
1324 git_config(git_fetch_config, NULL);
1326 argc = parse_options(argc, argv, prefix,
1328 builtin_fetch_options, builtin_fetch_usage, 0);
1329 if (deepen_relative) {
1331 if (deepen_relative < 0)
1332 die(_("Negative depth in --deepen is not supported"));
1333 if (depth)
1334 die(_("--deepen and --depth are mutually exclusive"));
1335 depth = xstrfmt("%d", deepen_relative);
1336 }
1337 if (unshallow) {
1338 if (depth)
1339 die(_("--depth and --unshallow cannot be used together"));
1340 else if (!is_repository_shallow())
1341 die(_("--unshallow on a complete repository does not make sense"));
1342 else
1343 depth = xstrfmt("%d", INFINITE_DEPTH);
1344 }
1345 /* no need to be strict, transport_set_option() will validate it again */
1347 if (depth && atoi(depth) < 1)
1348 die(_("depth %s is not a positive number"), depth);
1349 if (depth || deepen_since || deepen_not.nr)
1350 deepen = 1;
1351 if (recurse_submodules != RECURSE_SUBMODULES_OFF) {
1353 if (recurse_submodules_default) {
1354 int arg = parse_fetch_recurse_submodules_arg("--recurse-submodules-default", recurse_submodules_default);
1355 set_config_fetch_recurse_submodules(arg);
1356 }
1357 gitmodules_config();
1358 git_config(submodule_config, NULL);
1359 }
1360 if (all) {
1362 if (argc == 1)
1363 die(_("fetch --all does not take a repository argument"));
1364 else if (argc > 1)
1365 die(_("fetch --all does not make sense with refspecs"));
1366 (void) for_each_remote(get_one_remote_for_fetch, &list);
1367 result = fetch_multiple(&list);
1368 } else if (argc == 0) {
1369 /* No arguments -- use default remote */
1370 remote = remote_get(NULL);
1371 result = fetch_one(remote, argc, argv);
1372 } else if (multiple) {
1373 /* All arguments are assumed to be remotes or groups */
1374 for (i = 0; i < argc; i++)
1375 if (!add_remote_or_group(argv[i], &list))
1376 die(_("No such remote or remote group: %s"), argv[i]);
1377 result = fetch_multiple(&list);
1378 } else {
1379 /* Single remote or group */
1380 (void) add_remote_or_group(argv[0], &list);
1381 if (list.nr > 1) {
1382 /* More than one remote */
1383 if (argc > 1)
1384 die(_("Fetching a group and specifying refspecs does not make sense"));
1385 result = fetch_multiple(&list);
1386 } else {
1387 /* Zero or one remotes */
1388 remote = remote_get(argv[0]);
1389 result = fetch_one(remote, argc-1, argv+1);
1390 }
1391 }
1392 if (!result && (recurse_submodules != RECURSE_SUBMODULES_OFF)) {
1394 struct argv_array options = ARGV_ARRAY_INIT;
1395 add_options_to_argv(&options);
1397 result = fetch_populated_submodules(&options,
1398 submodule_prefix,
1399 recurse_submodules,
1400 verbosity < 0,
1401 max_children);
1402 argv_array_clear(&options);
1403 }
1404 string_list_clear(&list, 0);
1406 close_all_packs();
1408 argv_array_pushl(&argv_gc_auto, "gc", "--auto", NULL);
1410 if (verbosity < 0)
1411 argv_array_push(&argv_gc_auto, "--quiet");
1412 run_command_v_opt(argv_gc_auto.argv, RUN_GIT_CMD);
1413 argv_array_clear(&argv_gc_auto);
1414 return result;
1416}