chain kill signals for cleanup functions
[git/mingw.git] / builtin-remote.c
blobabc8dd8389be4a51b467b4f6d4f74e2037d65423
1 #include "cache.h"
2 #include "parse-options.h"
3 #include "transport.h"
4 #include "remote.h"
5 #include "string-list.h"
6 #include "strbuf.h"
7 #include "run-command.h"
8 #include "refs.h"
10 static const char * const builtin_remote_usage[] = {
11 "git remote [-v | --verbose]",
12 "git remote add [-t <branch>] [-m <master>] [-f] [--mirror] <name> <url>",
13 "git remote rename <old> <new>",
14 "git remote rm <name>",
15 "git remote show [-n] <name>",
16 "git remote prune [-n | --dry-run] <name>",
17 "git remote [-v | --verbose] update [group]",
18 NULL
21 static int verbose;
23 static int show_all(void);
25 static inline int postfixcmp(const char *string, const char *postfix)
27 int len1 = strlen(string), len2 = strlen(postfix);
28 if (len1 < len2)
29 return 1;
30 return strcmp(string + len1 - len2, postfix);
33 static int opt_parse_track(const struct option *opt, const char *arg, int not)
35 struct string_list *list = opt->value;
36 if (not)
37 string_list_clear(list, 0);
38 else
39 string_list_append(arg, list);
40 return 0;
43 static int fetch_remote(const char *name)
45 const char *argv[] = { "fetch", name, NULL, NULL };
46 if (verbose) {
47 argv[1] = "-v";
48 argv[2] = name;
50 printf("Updating %s\n", name);
51 if (run_command_v_opt(argv, RUN_GIT_CMD))
52 return error("Could not fetch %s", name);
53 return 0;
56 static int add(int argc, const char **argv)
58 int fetch = 0, mirror = 0;
59 struct string_list track = { NULL, 0, 0 };
60 const char *master = NULL;
61 struct remote *remote;
62 struct strbuf buf = STRBUF_INIT, buf2 = STRBUF_INIT;
63 const char *name, *url;
64 int i;
66 struct option options[] = {
67 OPT_GROUP("add specific options"),
68 OPT_BOOLEAN('f', "fetch", &fetch, "fetch the remote branches"),
69 OPT_CALLBACK('t', "track", &track, "branch",
70 "branch(es) to track", opt_parse_track),
71 OPT_STRING('m', "master", &master, "branch", "master branch"),
72 OPT_BOOLEAN(0, "mirror", &mirror, "no separate remotes"),
73 OPT_END()
76 argc = parse_options(argc, argv, options, builtin_remote_usage, 0);
78 if (argc < 2)
79 usage_with_options(builtin_remote_usage, options);
81 name = argv[0];
82 url = argv[1];
84 remote = remote_get(name);
85 if (remote && (remote->url_nr > 1 || strcmp(name, remote->url[0]) ||
86 remote->fetch_refspec_nr))
87 die("remote %s already exists.", name);
89 strbuf_addf(&buf2, "refs/heads/test:refs/remotes/%s/test", name);
90 if (!valid_fetch_refspec(buf2.buf))
91 die("'%s' is not a valid remote name", name);
93 strbuf_addf(&buf, "remote.%s.url", name);
94 if (git_config_set(buf.buf, url))
95 return 1;
97 strbuf_reset(&buf);
98 strbuf_addf(&buf, "remote.%s.fetch", name);
100 if (track.nr == 0)
101 string_list_append("*", &track);
102 for (i = 0; i < track.nr; i++) {
103 struct string_list_item *item = track.items + i;
105 strbuf_reset(&buf2);
106 strbuf_addch(&buf2, '+');
107 if (mirror)
108 strbuf_addf(&buf2, "refs/%s:refs/%s",
109 item->string, item->string);
110 else
111 strbuf_addf(&buf2, "refs/heads/%s:refs/remotes/%s/%s",
112 item->string, name, item->string);
113 if (git_config_set_multivar(buf.buf, buf2.buf, "^$", 0))
114 return 1;
117 if (mirror) {
118 strbuf_reset(&buf);
119 strbuf_addf(&buf, "remote.%s.mirror", name);
120 if (git_config_set(buf.buf, "true"))
121 return 1;
124 if (fetch && fetch_remote(name))
125 return 1;
127 if (master) {
128 strbuf_reset(&buf);
129 strbuf_addf(&buf, "refs/remotes/%s/HEAD", name);
131 strbuf_reset(&buf2);
132 strbuf_addf(&buf2, "refs/remotes/%s/%s", name, master);
134 if (create_symref(buf.buf, buf2.buf, "remote add"))
135 return error("Could not setup master '%s'", master);
138 strbuf_release(&buf);
139 strbuf_release(&buf2);
140 string_list_clear(&track, 0);
142 return 0;
145 struct branch_info {
146 char *remote;
147 struct string_list merge;
150 static struct string_list branch_list;
152 static const char *abbrev_ref(const char *name, const char *prefix)
154 const char *abbrev = skip_prefix(name, prefix);
155 if (abbrev)
156 return abbrev;
157 return name;
159 #define abbrev_branch(name) abbrev_ref((name), "refs/heads/")
161 static int config_read_branches(const char *key, const char *value, void *cb)
163 if (!prefixcmp(key, "branch.")) {
164 char *name;
165 struct string_list_item *item;
166 struct branch_info *info;
167 enum { REMOTE, MERGE } type;
169 key += 7;
170 if (!postfixcmp(key, ".remote")) {
171 name = xstrndup(key, strlen(key) - 7);
172 type = REMOTE;
173 } else if (!postfixcmp(key, ".merge")) {
174 name = xstrndup(key, strlen(key) - 6);
175 type = MERGE;
176 } else
177 return 0;
179 item = string_list_insert(name, &branch_list);
181 if (!item->util)
182 item->util = xcalloc(sizeof(struct branch_info), 1);
183 info = item->util;
184 if (type == REMOTE) {
185 if (info->remote)
186 warning("more than one branch.%s", key);
187 info->remote = xstrdup(value);
188 } else {
189 char *space = strchr(value, ' ');
190 value = abbrev_branch(value);
191 while (space) {
192 char *merge;
193 merge = xstrndup(value, space - value);
194 string_list_append(merge, &info->merge);
195 value = abbrev_branch(space + 1);
196 space = strchr(value, ' ');
198 string_list_append(xstrdup(value), &info->merge);
201 return 0;
204 static void read_branches(void)
206 if (branch_list.nr)
207 return;
208 git_config(config_read_branches, NULL);
209 sort_string_list(&branch_list);
212 struct ref_states {
213 struct remote *remote;
214 struct string_list new, stale, tracked;
217 static int handle_one_branch(const char *refname,
218 const unsigned char *sha1, int flags, void *cb_data)
220 struct ref_states *states = cb_data;
221 struct refspec refspec;
223 memset(&refspec, 0, sizeof(refspec));
224 refspec.dst = (char *)refname;
225 if (!remote_find_tracking(states->remote, &refspec)) {
226 struct string_list_item *item;
227 const char *name = abbrev_branch(refspec.src);
228 /* symbolic refs pointing nowhere were handled already */
229 if ((flags & REF_ISSYMREF) ||
230 unsorted_string_list_has_string(&states->tracked,
231 name) ||
232 unsorted_string_list_has_string(&states->new,
233 name))
234 return 0;
235 item = string_list_append(name, &states->stale);
236 item->util = xstrdup(refname);
238 return 0;
241 static int get_ref_states(const struct ref *ref, struct ref_states *states)
243 struct ref *fetch_map = NULL, **tail = &fetch_map;
244 int i;
246 for (i = 0; i < states->remote->fetch_refspec_nr; i++)
247 if (get_fetch_map(ref, states->remote->fetch + i, &tail, 1))
248 die("Could not get fetch map for refspec %s",
249 states->remote->fetch_refspec[i]);
251 states->new.strdup_strings = states->tracked.strdup_strings = 1;
252 for (ref = fetch_map; ref; ref = ref->next) {
253 struct string_list *target = &states->tracked;
254 unsigned char sha1[20];
255 void *util = NULL;
257 if (!ref->peer_ref || read_ref(ref->peer_ref->name, sha1))
258 target = &states->new;
259 else {
260 target = &states->tracked;
261 if (hashcmp(sha1, ref->new_sha1))
262 util = &states;
264 string_list_append(abbrev_branch(ref->name), target)->util = util;
266 free_refs(fetch_map);
268 for_each_ref(handle_one_branch, states);
269 sort_string_list(&states->stale);
271 return 0;
274 struct known_remote {
275 struct known_remote *next;
276 struct remote *remote;
279 struct known_remotes {
280 struct remote *to_delete;
281 struct known_remote *list;
284 static int add_known_remote(struct remote *remote, void *cb_data)
286 struct known_remotes *all = cb_data;
287 struct known_remote *r;
289 if (!strcmp(all->to_delete->name, remote->name))
290 return 0;
292 r = xmalloc(sizeof(*r));
293 r->remote = remote;
294 r->next = all->list;
295 all->list = r;
296 return 0;
299 struct branches_for_remote {
300 struct remote *remote;
301 struct string_list *branches;
302 struct known_remotes *keep;
305 static int add_branch_for_removal(const char *refname,
306 const unsigned char *sha1, int flags, void *cb_data)
308 struct branches_for_remote *branches = cb_data;
309 struct refspec refspec;
310 struct string_list_item *item;
311 struct known_remote *kr;
313 memset(&refspec, 0, sizeof(refspec));
314 refspec.dst = (char *)refname;
315 if (remote_find_tracking(branches->remote, &refspec))
316 return 0;
318 /* don't delete a branch if another remote also uses it */
319 for (kr = branches->keep->list; kr; kr = kr->next) {
320 memset(&refspec, 0, sizeof(refspec));
321 refspec.dst = (char *)refname;
322 if (!remote_find_tracking(kr->remote, &refspec))
323 return 0;
326 /* make sure that symrefs are deleted */
327 if (flags & REF_ISSYMREF)
328 return unlink(git_path("%s", refname));
330 item = string_list_append(refname, branches->branches);
331 item->util = xmalloc(20);
332 hashcpy(item->util, sha1);
334 return 0;
337 struct rename_info {
338 const char *old;
339 const char *new;
340 struct string_list *remote_branches;
343 static int read_remote_branches(const char *refname,
344 const unsigned char *sha1, int flags, void *cb_data)
346 struct rename_info *rename = cb_data;
347 struct strbuf buf = STRBUF_INIT;
348 struct string_list_item *item;
349 int flag;
350 unsigned char orig_sha1[20];
351 const char *symref;
353 strbuf_addf(&buf, "refs/remotes/%s", rename->old);
354 if(!prefixcmp(refname, buf.buf)) {
355 item = string_list_append(xstrdup(refname), rename->remote_branches);
356 symref = resolve_ref(refname, orig_sha1, 1, &flag);
357 if (flag & REF_ISSYMREF)
358 item->util = xstrdup(symref);
359 else
360 item->util = NULL;
363 return 0;
366 static int migrate_file(struct remote *remote)
368 struct strbuf buf = STRBUF_INIT;
369 int i;
370 char *path = NULL;
372 strbuf_addf(&buf, "remote.%s.url", remote->name);
373 for (i = 0; i < remote->url_nr; i++)
374 if (git_config_set_multivar(buf.buf, remote->url[i], "^$", 0))
375 return error("Could not append '%s' to '%s'",
376 remote->url[i], buf.buf);
377 strbuf_reset(&buf);
378 strbuf_addf(&buf, "remote.%s.push", remote->name);
379 for (i = 0; i < remote->push_refspec_nr; i++)
380 if (git_config_set_multivar(buf.buf, remote->push_refspec[i], "^$", 0))
381 return error("Could not append '%s' to '%s'",
382 remote->push_refspec[i], buf.buf);
383 strbuf_reset(&buf);
384 strbuf_addf(&buf, "remote.%s.fetch", remote->name);
385 for (i = 0; i < remote->fetch_refspec_nr; i++)
386 if (git_config_set_multivar(buf.buf, remote->fetch_refspec[i], "^$", 0))
387 return error("Could not append '%s' to '%s'",
388 remote->fetch_refspec[i], buf.buf);
389 if (remote->origin == REMOTE_REMOTES)
390 path = git_path("remotes/%s", remote->name);
391 else if (remote->origin == REMOTE_BRANCHES)
392 path = git_path("branches/%s", remote->name);
393 if (path && unlink(path))
394 warning("failed to remove '%s'", path);
395 return 0;
398 static int mv(int argc, const char **argv)
400 struct option options[] = {
401 OPT_END()
403 struct remote *oldremote, *newremote;
404 struct strbuf buf = STRBUF_INIT, buf2 = STRBUF_INIT, buf3 = STRBUF_INIT;
405 struct string_list remote_branches = { NULL, 0, 0, 0 };
406 struct rename_info rename;
407 int i;
409 if (argc != 3)
410 usage_with_options(builtin_remote_usage, options);
412 rename.old = argv[1];
413 rename.new = argv[2];
414 rename.remote_branches = &remote_branches;
416 oldremote = remote_get(rename.old);
417 if (!oldremote)
418 die("No such remote: %s", rename.old);
420 if (!strcmp(rename.old, rename.new) && oldremote->origin != REMOTE_CONFIG)
421 return migrate_file(oldremote);
423 newremote = remote_get(rename.new);
424 if (newremote && (newremote->url_nr > 1 || newremote->fetch_refspec_nr))
425 die("remote %s already exists.", rename.new);
427 strbuf_addf(&buf, "refs/heads/test:refs/remotes/%s/test", rename.new);
428 if (!valid_fetch_refspec(buf.buf))
429 die("'%s' is not a valid remote name", rename.new);
431 strbuf_reset(&buf);
432 strbuf_addf(&buf, "remote.%s", rename.old);
433 strbuf_addf(&buf2, "remote.%s", rename.new);
434 if (git_config_rename_section(buf.buf, buf2.buf) < 1)
435 return error("Could not rename config section '%s' to '%s'",
436 buf.buf, buf2.buf);
438 strbuf_reset(&buf);
439 strbuf_addf(&buf, "remote.%s.fetch", rename.new);
440 if (git_config_set_multivar(buf.buf, NULL, NULL, 1))
441 return error("Could not remove config section '%s'", buf.buf);
442 for (i = 0; i < oldremote->fetch_refspec_nr; i++) {
443 char *ptr;
445 strbuf_reset(&buf2);
446 strbuf_addstr(&buf2, oldremote->fetch_refspec[i]);
447 ptr = strstr(buf2.buf, rename.old);
448 if (ptr)
449 strbuf_splice(&buf2, ptr-buf2.buf, strlen(rename.old),
450 rename.new, strlen(rename.new));
451 if (git_config_set_multivar(buf.buf, buf2.buf, "^$", 0))
452 return error("Could not append '%s'", buf.buf);
455 read_branches();
456 for (i = 0; i < branch_list.nr; i++) {
457 struct string_list_item *item = branch_list.items + i;
458 struct branch_info *info = item->util;
459 if (info->remote && !strcmp(info->remote, rename.old)) {
460 strbuf_reset(&buf);
461 strbuf_addf(&buf, "branch.%s.remote", item->string);
462 if (git_config_set(buf.buf, rename.new)) {
463 return error("Could not set '%s'", buf.buf);
469 * First remove symrefs, then rename the rest, finally create
470 * the new symrefs.
472 for_each_ref(read_remote_branches, &rename);
473 for (i = 0; i < remote_branches.nr; i++) {
474 struct string_list_item *item = remote_branches.items + i;
475 int flag = 0;
476 unsigned char sha1[20];
477 const char *symref;
479 symref = resolve_ref(item->string, sha1, 1, &flag);
480 if (!(flag & REF_ISSYMREF))
481 continue;
482 if (delete_ref(item->string, NULL, REF_NODEREF))
483 die("deleting '%s' failed", item->string);
485 for (i = 0; i < remote_branches.nr; i++) {
486 struct string_list_item *item = remote_branches.items + i;
488 if (item->util)
489 continue;
490 strbuf_reset(&buf);
491 strbuf_addstr(&buf, item->string);
492 strbuf_splice(&buf, strlen("refs/remotes/"), strlen(rename.old),
493 rename.new, strlen(rename.new));
494 strbuf_reset(&buf2);
495 strbuf_addf(&buf2, "remote: renamed %s to %s",
496 item->string, buf.buf);
497 if (rename_ref(item->string, buf.buf, buf2.buf))
498 die("renaming '%s' failed", item->string);
500 for (i = 0; i < remote_branches.nr; i++) {
501 struct string_list_item *item = remote_branches.items + i;
503 if (!item->util)
504 continue;
505 strbuf_reset(&buf);
506 strbuf_addstr(&buf, item->string);
507 strbuf_splice(&buf, strlen("refs/remotes/"), strlen(rename.old),
508 rename.new, strlen(rename.new));
509 strbuf_reset(&buf2);
510 strbuf_addstr(&buf2, item->util);
511 strbuf_splice(&buf2, strlen("refs/remotes/"), strlen(rename.old),
512 rename.new, strlen(rename.new));
513 strbuf_reset(&buf3);
514 strbuf_addf(&buf3, "remote: renamed %s to %s",
515 item->string, buf.buf);
516 if (create_symref(buf.buf, buf2.buf, buf3.buf))
517 die("creating '%s' failed", buf.buf);
519 return 0;
522 static int remove_branches(struct string_list *branches)
524 int i, result = 0;
525 for (i = 0; i < branches->nr; i++) {
526 struct string_list_item *item = branches->items + i;
527 const char *refname = item->string;
528 unsigned char *sha1 = item->util;
530 if (delete_ref(refname, sha1, 0))
531 result |= error("Could not remove branch %s", refname);
533 return result;
536 static int rm(int argc, const char **argv)
538 struct option options[] = {
539 OPT_END()
541 struct remote *remote;
542 struct strbuf buf = STRBUF_INIT;
543 struct known_remotes known_remotes = { NULL, NULL };
544 struct string_list branches = { NULL, 0, 0, 1 };
545 struct branches_for_remote cb_data = { NULL, &branches, &known_remotes };
546 int i;
548 if (argc != 2)
549 usage_with_options(builtin_remote_usage, options);
551 remote = remote_get(argv[1]);
552 if (!remote)
553 die("No such remote: %s", argv[1]);
555 known_remotes.to_delete = remote;
556 for_each_remote(add_known_remote, &known_remotes);
558 strbuf_addf(&buf, "remote.%s", remote->name);
559 if (git_config_rename_section(buf.buf, NULL) < 1)
560 return error("Could not remove config section '%s'", buf.buf);
562 read_branches();
563 for (i = 0; i < branch_list.nr; i++) {
564 struct string_list_item *item = branch_list.items + i;
565 struct branch_info *info = item->util;
566 if (info->remote && !strcmp(info->remote, remote->name)) {
567 const char *keys[] = { "remote", "merge", NULL }, **k;
568 for (k = keys; *k; k++) {
569 strbuf_reset(&buf);
570 strbuf_addf(&buf, "branch.%s.%s",
571 item->string, *k);
572 if (git_config_set(buf.buf, NULL)) {
573 strbuf_release(&buf);
574 return -1;
581 * We cannot just pass a function to for_each_ref() which deletes
582 * the branches one by one, since for_each_ref() relies on cached
583 * refs, which are invalidated when deleting a branch.
585 cb_data.remote = remote;
586 i = for_each_ref(add_branch_for_removal, &cb_data);
587 strbuf_release(&buf);
589 if (!i)
590 i = remove_branches(&branches);
591 string_list_clear(&branches, 1);
593 return i;
596 static void show_list(const char *title, struct string_list *list,
597 const char *extra_arg)
599 int i;
601 if (!list->nr)
602 return;
604 printf(title, list->nr > 1 ? "es" : "", extra_arg);
605 printf("\n");
606 for (i = 0; i < list->nr; i++)
607 printf(" %s\n", list->items[i].string);
610 static int get_remote_ref_states(const char *name,
611 struct ref_states *states,
612 int query)
614 struct transport *transport;
615 const struct ref *ref;
617 states->remote = remote_get(name);
618 if (!states->remote)
619 return error("No such remote: %s", name);
621 read_branches();
623 if (query) {
624 transport = transport_get(NULL, states->remote->url_nr > 0 ?
625 states->remote->url[0] : NULL);
626 ref = transport_get_remote_refs(transport);
627 transport_disconnect(transport);
629 get_ref_states(ref, states);
632 return 0;
635 static int append_ref_to_tracked_list(const char *refname,
636 const unsigned char *sha1, int flags, void *cb_data)
638 struct ref_states *states = cb_data;
639 struct refspec refspec;
641 memset(&refspec, 0, sizeof(refspec));
642 refspec.dst = (char *)refname;
643 if (!remote_find_tracking(states->remote, &refspec))
644 string_list_append(abbrev_branch(refspec.src), &states->tracked);
646 return 0;
649 static int show(int argc, const char **argv)
651 int no_query = 0, result = 0;
652 struct option options[] = {
653 OPT_GROUP("show specific options"),
654 OPT_BOOLEAN('n', NULL, &no_query, "do not query remotes"),
655 OPT_END()
657 struct ref_states states;
659 argc = parse_options(argc, argv, options, builtin_remote_usage, 0);
661 if (argc < 1)
662 return show_all();
664 memset(&states, 0, sizeof(states));
665 for (; argc; argc--, argv++) {
666 int i;
668 get_remote_ref_states(*argv, &states, !no_query);
670 printf("* remote %s\n URL: %s\n", *argv,
671 states.remote->url_nr > 0 ?
672 states.remote->url[0] : "(no URL)");
674 for (i = 0; i < branch_list.nr; i++) {
675 struct string_list_item *branch = branch_list.items + i;
676 struct branch_info *info = branch->util;
677 int j;
679 if (!info->merge.nr || strcmp(*argv, info->remote))
680 continue;
681 printf(" Remote branch%s merged with 'git pull' "
682 "while on branch %s\n ",
683 info->merge.nr > 1 ? "es" : "",
684 branch->string);
685 for (j = 0; j < info->merge.nr; j++)
686 printf(" %s", info->merge.items[j].string);
687 printf("\n");
690 if (!no_query) {
691 show_list(" New remote branch%s (next fetch "
692 "will store in remotes/%s)",
693 &states.new, states.remote->name);
694 show_list(" Stale tracking branch%s (use 'git remote "
695 "prune')", &states.stale, "");
698 if (no_query)
699 for_each_ref(append_ref_to_tracked_list, &states);
700 show_list(" Tracked remote branch%s", &states.tracked, "");
702 if (states.remote->push_refspec_nr) {
703 printf(" Local branch%s pushed with 'git push'\n",
704 states.remote->push_refspec_nr > 1 ?
705 "es" : "");
706 for (i = 0; i < states.remote->push_refspec_nr; i++) {
707 struct refspec *spec = states.remote->push + i;
708 printf(" %s%s%s%s\n",
709 spec->force ? "+" : "",
710 abbrev_branch(spec->src),
711 spec->dst ? ":" : "",
712 spec->dst ? abbrev_branch(spec->dst) : "");
716 /* NEEDSWORK: free remote */
717 string_list_clear(&states.new, 0);
718 string_list_clear(&states.stale, 0);
719 string_list_clear(&states.tracked, 0);
722 return result;
725 static int prune(int argc, const char **argv)
727 int dry_run = 0, result = 0;
728 struct option options[] = {
729 OPT_GROUP("prune specific options"),
730 OPT__DRY_RUN(&dry_run),
731 OPT_END()
733 struct ref_states states;
735 argc = parse_options(argc, argv, options, builtin_remote_usage, 0);
737 if (argc < 1)
738 usage_with_options(builtin_remote_usage, options);
740 memset(&states, 0, sizeof(states));
741 for (; argc; argc--, argv++) {
742 int i;
744 get_remote_ref_states(*argv, &states, 1);
746 if (states.stale.nr) {
747 printf("Pruning %s\n", *argv);
748 printf("URL: %s\n",
749 states.remote->url_nr
750 ? states.remote->url[0]
751 : "(no URL)");
754 for (i = 0; i < states.stale.nr; i++) {
755 const char *refname = states.stale.items[i].util;
757 if (!dry_run)
758 result |= delete_ref(refname, NULL, 0);
760 printf(" * [%s] %s\n", dry_run ? "would prune" : "pruned",
761 abbrev_ref(refname, "refs/remotes/"));
764 /* NEEDSWORK: free remote */
765 string_list_clear(&states.new, 0);
766 string_list_clear(&states.stale, 0);
767 string_list_clear(&states.tracked, 0);
770 return result;
773 static int get_one_remote_for_update(struct remote *remote, void *priv)
775 struct string_list *list = priv;
776 if (!remote->skip_default_update)
777 string_list_append(remote->name, list);
778 return 0;
781 struct remote_group {
782 const char *name;
783 struct string_list *list;
784 } remote_group;
786 static int get_remote_group(const char *key, const char *value, void *cb)
788 if (!prefixcmp(key, "remotes.") &&
789 !strcmp(key + 8, remote_group.name)) {
790 /* split list by white space */
791 int space = strcspn(value, " \t\n");
792 while (*value) {
793 if (space > 1)
794 string_list_append(xstrndup(value, space),
795 remote_group.list);
796 value += space + (value[space] != '\0');
797 space = strcspn(value, " \t\n");
801 return 0;
804 static int update(int argc, const char **argv)
806 int i, result = 0;
807 struct string_list list = { NULL, 0, 0, 0 };
808 static const char *default_argv[] = { NULL, "default", NULL };
810 if (argc < 2) {
811 argc = 2;
812 argv = default_argv;
815 remote_group.list = &list;
816 for (i = 1; i < argc; i++) {
817 remote_group.name = argv[i];
818 result = git_config(get_remote_group, NULL);
821 if (!result && !list.nr && argc == 2 && !strcmp(argv[1], "default"))
822 result = for_each_remote(get_one_remote_for_update, &list);
824 for (i = 0; i < list.nr; i++)
825 result |= fetch_remote(list.items[i].string);
827 /* all names were strdup()ed or strndup()ed */
828 list.strdup_strings = 1;
829 string_list_clear(&list, 0);
831 return result;
834 static int get_one_entry(struct remote *remote, void *priv)
836 struct string_list *list = priv;
838 if (remote->url_nr > 0) {
839 int i;
841 for (i = 0; i < remote->url_nr; i++)
842 string_list_append(remote->name, list)->util = (void *)remote->url[i];
843 } else
844 string_list_append(remote->name, list)->util = NULL;
846 return 0;
849 static int show_all(void)
851 struct string_list list = { NULL, 0, 0 };
852 int result = for_each_remote(get_one_entry, &list);
854 if (!result) {
855 int i;
857 sort_string_list(&list);
858 for (i = 0; i < list.nr; i++) {
859 struct string_list_item *item = list.items + i;
860 if (verbose)
861 printf("%s\t%s\n", item->string,
862 item->util ? (const char *)item->util : "");
863 else {
864 if (i && !strcmp((item - 1)->string, item->string))
865 continue;
866 printf("%s\n", item->string);
870 return result;
873 int cmd_remote(int argc, const char **argv, const char *prefix)
875 struct option options[] = {
876 OPT__VERBOSE(&verbose),
877 OPT_END()
879 int result;
881 argc = parse_options(argc, argv, options, builtin_remote_usage,
882 PARSE_OPT_STOP_AT_NON_OPTION);
884 if (argc < 1)
885 result = show_all();
886 else if (!strcmp(argv[0], "add"))
887 result = add(argc, argv);
888 else if (!strcmp(argv[0], "rename"))
889 result = mv(argc, argv);
890 else if (!strcmp(argv[0], "rm"))
891 result = rm(argc, argv);
892 else if (!strcmp(argv[0], "show"))
893 result = show(argc, argv);
894 else if (!strcmp(argv[0], "prune"))
895 result = prune(argc, argv);
896 else if (!strcmp(argv[0], "update"))
897 result = update(argc, argv);
898 else {
899 error("Unknown subcommand: %s", argv[0]);
900 usage_with_options(builtin_remote_usage, options);
903 return result ? 1 : 0;