Merge branch 'js/notes'
[git/git.git] / builtin-remote.c
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"
9
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
19 };
20
21 static int verbose;
22
23 static int show_all(void);
24
25 static inline int postfixcmp(const char *string, const char *postfix)
26 {
27 int len1 = strlen(string), len2 = strlen(postfix);
28 if (len1 < len2)
29 return 1;
30 return strcmp(string + len1 - len2, postfix);
31 }
32
33 static int opt_parse_track(const struct option *opt, const char *arg, int not)
34 {
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;
41 }
42
43 static int fetch_remote(const char *name)
44 {
45 const char *argv[] = { "fetch", name, NULL, NULL };
46 if (verbose) {
47 argv[1] = "-v";
48 argv[2] = name;
49 }
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;
54 }
55
56 static int add(int argc, const char **argv)
57 {
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;
65
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()
74 };
75
76 argc = parse_options(argc, argv, options, builtin_remote_usage, 0);
77
78 if (argc < 2)
79 usage_with_options(builtin_remote_usage, options);
80
81 name = argv[0];
82 url = argv[1];
83
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);
88
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);
92
93 strbuf_addf(&buf, "remote.%s.url", name);
94 if (git_config_set(buf.buf, url))
95 return 1;
96
97 strbuf_reset(&buf);
98 strbuf_addf(&buf, "remote.%s.fetch", name);
99
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;
104
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;
115 }
116
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;
122 }
123
124 if (fetch && fetch_remote(name))
125 return 1;
126
127 if (master) {
128 strbuf_reset(&buf);
129 strbuf_addf(&buf, "refs/remotes/%s/HEAD", name);
130
131 strbuf_reset(&buf2);
132 strbuf_addf(&buf2, "refs/remotes/%s/%s", name, master);
133
134 if (create_symref(buf.buf, buf2.buf, "remote add"))
135 return error("Could not setup master '%s'", master);
136 }
137
138 strbuf_release(&buf);
139 strbuf_release(&buf2);
140 string_list_clear(&track, 0);
141
142 return 0;
143 }
144
145 struct branch_info {
146 char *remote;
147 struct string_list merge;
148 };
149
150 static struct string_list branch_list;
151
152 static const char *abbrev_ref(const char *name, const char *prefix)
153 {
154 const char *abbrev = skip_prefix(name, prefix);
155 if (abbrev)
156 return abbrev;
157 return name;
158 }
159 #define abbrev_branch(name) abbrev_ref((name), "refs/heads/")
160
161 static int config_read_branches(const char *key, const char *value, void *cb)
162 {
163 if (!prefixcmp(key, "branch.")) {
164 char *name;
165 struct string_list_item *item;
166 struct branch_info *info;
167 enum { REMOTE, MERGE } type;
168
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;
178
179 item = string_list_insert(name, &branch_list);
180
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, ' ');
197 }
198 string_list_append(xstrdup(value), &info->merge);
199 }
200 }
201 return 0;
202 }
203
204 static void read_branches(void)
205 {
206 if (branch_list.nr)
207 return;
208 git_config(config_read_branches, NULL);
209 sort_string_list(&branch_list);
210 }
211
212 struct ref_states {
213 struct remote *remote;
214 struct string_list new, stale, tracked;
215 };
216
217 static int handle_one_branch(const char *refname,
218 const unsigned char *sha1, int flags, void *cb_data)
219 {
220 struct ref_states *states = cb_data;
221 struct refspec refspec;
222
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);
237 }
238 return 0;
239 }
240
241 static int get_ref_states(const struct ref *ref, struct ref_states *states)
242 {
243 struct ref *fetch_map = NULL, **tail = &fetch_map;
244 int i;
245
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]);
250
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;
256
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;
263 }
264 string_list_append(abbrev_branch(ref->name), target)->util = util;
265 }
266 free_refs(fetch_map);
267
268 for_each_ref(handle_one_branch, states);
269 sort_string_list(&states->stale);
270
271 return 0;
272 }
273
274 struct known_remote {
275 struct known_remote *next;
276 struct remote *remote;
277 };
278
279 struct known_remotes {
280 struct remote *to_delete;
281 struct known_remote *list;
282 };
283
284 static int add_known_remote(struct remote *remote, void *cb_data)
285 {
286 struct known_remotes *all = cb_data;
287 struct known_remote *r;
288
289 if (!strcmp(all->to_delete->name, remote->name))
290 return 0;
291
292 r = xmalloc(sizeof(*r));
293 r->remote = remote;
294 r->next = all->list;
295 all->list = r;
296 return 0;
297 }
298
299 struct branches_for_remote {
300 struct remote *remote;
301 struct string_list *branches;
302 struct known_remotes *keep;
303 };
304
305 static int add_branch_for_removal(const char *refname,
306 const unsigned char *sha1, int flags, void *cb_data)
307 {
308 struct branches_for_remote *branches = cb_data;
309 struct refspec refspec;
310 struct string_list_item *item;
311 struct known_remote *kr;
312
313 memset(&refspec, 0, sizeof(refspec));
314 refspec.dst = (char *)refname;
315 if (remote_find_tracking(branches->remote, &refspec))
316 return 0;
317
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;
324 }
325
326 /* make sure that symrefs are deleted */
327 if (flags & REF_ISSYMREF)
328 return unlink(git_path("%s", refname));
329
330 item = string_list_append(refname, branches->branches);
331 item->util = xmalloc(20);
332 hashcpy(item->util, sha1);
333
334 return 0;
335 }
336
337 struct rename_info {
338 const char *old;
339 const char *new;
340 struct string_list *remote_branches;
341 };
342
343 static int read_remote_branches(const char *refname,
344 const unsigned char *sha1, int flags, void *cb_data)
345 {
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;
352
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;
361 }
362
363 return 0;
364 }
365
366 static int migrate_file(struct remote *remote)
367 {
368 struct strbuf buf = STRBUF_INIT;
369 int i;
370 char *path = NULL;
371
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;
396 }
397
398 static int mv(int argc, const char **argv)
399 {
400 struct option options[] = {
401 OPT_END()
402 };
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;
408
409 if (argc != 3)
410 usage_with_options(builtin_remote_usage, options);
411
412 rename.old = argv[1];
413 rename.new = argv[2];
414 rename.remote_branches = &remote_branches;
415
416 oldremote = remote_get(rename.old);
417 if (!oldremote)
418 die("No such remote: %s", rename.old);
419
420 if (!strcmp(rename.old, rename.new) && oldremote->origin != REMOTE_CONFIG)
421 return migrate_file(oldremote);
422
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);
426
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);
430
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);
437
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;
444
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);
453 }
454
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);
464 }
465 }
466 }
467
468 /*
469 * First remove symrefs, then rename the rest, finally create
470 * the new symrefs.
471 */
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;
478
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);
484 }
485 for (i = 0; i < remote_branches.nr; i++) {
486 struct string_list_item *item = remote_branches.items + i;
487
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);
499 }
500 for (i = 0; i < remote_branches.nr; i++) {
501 struct string_list_item *item = remote_branches.items + i;
502
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);
518 }
519 return 0;
520 }
521
522 static int remove_branches(struct string_list *branches)
523 {
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;
529
530 if (delete_ref(refname, sha1, 0))
531 result |= error("Could not remove branch %s", refname);
532 }
533 return result;
534 }
535
536 static int rm(int argc, const char **argv)
537 {
538 struct option options[] = {
539 OPT_END()
540 };
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;
547
548 if (argc != 2)
549 usage_with_options(builtin_remote_usage, options);
550
551 remote = remote_get(argv[1]);
552 if (!remote)
553 die("No such remote: %s", argv[1]);
554
555 known_remotes.to_delete = remote;
556 for_each_remote(add_known_remote, &known_remotes);
557
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);
561
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;
575 }
576 }
577 }
578 }
579
580 /*
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.
584 */
585 cb_data.remote = remote;
586 i = for_each_ref(add_branch_for_removal, &cb_data);
587 strbuf_release(&buf);
588
589 if (!i)
590 i = remove_branches(&branches);
591 string_list_clear(&branches, 1);
592
593 return i;
594 }
595
596 static void show_list(const char *title, struct string_list *list,
597 const char *extra_arg)
598 {
599 int i;
600
601 if (!list->nr)
602 return;
603
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);
608 }
609
610 static int get_remote_ref_states(const char *name,
611 struct ref_states *states,
612 int query)
613 {
614 struct transport *transport;
615 const struct ref *ref;
616
617 states->remote = remote_get(name);
618 if (!states->remote)
619 return error("No such remote: %s", name);
620
621 read_branches();
622
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);
628
629 get_ref_states(ref, states);
630 }
631
632 return 0;
633 }
634
635 static int append_ref_to_tracked_list(const char *refname,
636 const unsigned char *sha1, int flags, void *cb_data)
637 {
638 struct ref_states *states = cb_data;
639 struct refspec refspec;
640
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);
645
646 return 0;
647 }
648
649 static int show(int argc, const char **argv)
650 {
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()
656 };
657 struct ref_states states;
658
659 argc = parse_options(argc, argv, options, builtin_remote_usage, 0);
660
661 if (argc < 1)
662 return show_all();
663
664 memset(&states, 0, sizeof(states));
665 for (; argc; argc--, argv++) {
666 int i;
667
668 get_remote_ref_states(*argv, &states, !no_query);
669
670 printf("* remote %s\n URL: %s\n", *argv,
671 states.remote->url_nr > 0 ?
672 states.remote->url[0] : "(no URL)");
673
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;
678
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");
688 }
689
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, "");
696 }
697
698 if (no_query)
699 for_each_ref(append_ref_to_tracked_list, &states);
700 show_list(" Tracked remote branch%s", &states.tracked, "");
701
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) : "");
713 }
714 }
715
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);
720 }
721
722 return result;
723 }
724
725 static int prune(int argc, const char **argv)
726 {
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()
732 };
733 struct ref_states states;
734
735 argc = parse_options(argc, argv, options, builtin_remote_usage, 0);
736
737 if (argc < 1)
738 usage_with_options(builtin_remote_usage, options);
739
740 memset(&states, 0, sizeof(states));
741 for (; argc; argc--, argv++) {
742 int i;
743
744 get_remote_ref_states(*argv, &states, 1);
745
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)");
752 }
753
754 for (i = 0; i < states.stale.nr; i++) {
755 const char *refname = states.stale.items[i].util;
756
757 if (!dry_run)
758 result |= delete_ref(refname, NULL, 0);
759
760 printf(" * [%s] %s\n", dry_run ? "would prune" : "pruned",
761 abbrev_ref(refname, "refs/remotes/"));
762 }
763
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);
768 }
769
770 return result;
771 }
772
773 static int get_one_remote_for_update(struct remote *remote, void *priv)
774 {
775 struct string_list *list = priv;
776 if (!remote->skip_default_update)
777 string_list_append(remote->name, list);
778 return 0;
779 }
780
781 struct remote_group {
782 const char *name;
783 struct string_list *list;
784 } remote_group;
785
786 static int get_remote_group(const char *key, const char *value, void *cb)
787 {
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");
798 }
799 }
800
801 return 0;
802 }
803
804 static int update(int argc, const char **argv)
805 {
806 int i, result = 0;
807 struct string_list list = { NULL, 0, 0, 0 };
808 static const char *default_argv[] = { NULL, "default", NULL };
809
810 if (argc < 2) {
811 argc = 2;
812 argv = default_argv;
813 }
814
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);
819 }
820
821 if (!result && !list.nr && argc == 2 && !strcmp(argv[1], "default"))
822 result = for_each_remote(get_one_remote_for_update, &list);
823
824 for (i = 0; i < list.nr; i++)
825 result |= fetch_remote(list.items[i].string);
826
827 /* all names were strdup()ed or strndup()ed */
828 list.strdup_strings = 1;
829 string_list_clear(&list, 0);
830
831 return result;
832 }
833
834 static int get_one_entry(struct remote *remote, void *priv)
835 {
836 struct string_list *list = priv;
837
838 if (remote->url_nr > 0) {
839 int i;
840
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;
845
846 return 0;
847 }
848
849 static int show_all(void)
850 {
851 struct string_list list = { NULL, 0, 0 };
852 int result = for_each_remote(get_one_entry, &list);
853
854 if (!result) {
855 int i;
856
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);
867 }
868 }
869 }
870 return result;
871 }
872
873 int cmd_remote(int argc, const char **argv, const char *prefix)
874 {
875 struct option options[] = {
876 OPT__VERBOSE(&verbose),
877 OPT_END()
878 };
879 int result;
880
881 argc = parse_options(argc, argv, options, builtin_remote_usage,
882 PARSE_OPT_STOP_AT_NON_OPTION);
883
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);
901 }
902
903 return result ? 1 : 0;
904 }