ca3bf265a93ee457d0069f1379ead105a470745a
   1#include "cache.h"
   2#include "parse-options.h"
   3#include "transport.h"
   4#include "remote.h"
   5#include "path-list.h"
   6#include "strbuf.h"
   7#include "run-command.h"
   8#include "refs.h"
   9
  10static const char * const builtin_remote_usage[] = {
  11        "git remote",
  12        "git remote add <name> <url>",
  13        "git remote rm <name>",
  14        "git remote show <name>",
  15        "git remote prune <name>",
  16        "git remote update [group]",
  17        NULL
  18};
  19
  20static int verbose;
  21
  22static inline int postfixcmp(const char *string, const char *postfix)
  23{
  24        int len1 = strlen(string), len2 = strlen(postfix);
  25        if (len1 < len2)
  26                return 1;
  27        return strcmp(string + len1 - len2, postfix);
  28}
  29
  30static inline const char *skip_prefix(const char *name, const char *prefix)
  31{
  32        return !name ? "" :
  33                prefixcmp(name, prefix) ?  name : name + strlen(prefix);
  34}
  35
  36static int opt_parse_track(const struct option *opt, const char *arg, int not)
  37{
  38        struct path_list *list = opt->value;
  39        if (not)
  40                path_list_clear(list, 0);
  41        else
  42                path_list_append(arg, list);
  43        return 0;
  44}
  45
  46static int fetch_remote(const char *name)
  47{
  48        const char *argv[] = { "fetch", name, NULL };
  49        if (run_command_v_opt(argv, RUN_GIT_CMD))
  50                return error("Could not fetch %s", name);
  51        return 0;
  52}
  53
  54static int add(int argc, const char **argv)
  55{
  56        int fetch = 0, mirror = 0;
  57        struct path_list track = { NULL, 0, 0 };
  58        const char *master = NULL;
  59        struct remote *remote;
  60        struct strbuf buf, buf2;
  61        const char *name, *url;
  62        int i;
  63
  64        struct option options[] = {
  65                OPT_GROUP("add specific options"),
  66                OPT_BOOLEAN('f', "fetch", &fetch, "fetch the remote branches"),
  67                OPT_CALLBACK('t', "track", &track, "branch",
  68                        "branch(es) to track", opt_parse_track),
  69                OPT_STRING('m', "master", &master, "branch", "master branch"),
  70                OPT_BOOLEAN(0, "mirror", &mirror, "no separate remotes"),
  71                OPT_END()
  72        };
  73
  74        argc = parse_options(argc, argv, options, builtin_remote_usage, 0);
  75
  76        if (argc < 2)
  77                usage_with_options(builtin_remote_usage, options);
  78
  79        name = argv[0];
  80        url = argv[1];
  81
  82        remote = remote_get(name);
  83        if (remote && (remote->url_nr > 1 || strcmp(name, remote->url[0]) ||
  84                        remote->fetch_refspec_nr))
  85                die("remote %s already exists.", name);
  86
  87        strbuf_init(&buf, 0);
  88        strbuf_init(&buf2, 0);
  89
  90        strbuf_addf(&buf, "remote.%s.url", name);
  91        if (git_config_set(buf.buf, url))
  92                return 1;
  93
  94        if (track.nr == 0)
  95                path_list_append("*", &track);
  96        for (i = 0; i < track.nr; i++) {
  97                struct path_list_item *item = track.items + i;
  98
  99                strbuf_reset(&buf);
 100                strbuf_addf(&buf, "remote.%s.fetch", name);
 101
 102                strbuf_reset(&buf2);
 103                if (mirror)
 104                        strbuf_addf(&buf2, "refs/%s:refs/%s",
 105                                        item->path, item->path);
 106                else
 107                        strbuf_addf(&buf2, "refs/heads/%s:refs/remotes/%s/%s",
 108                                        item->path, name, item->path);
 109                if (git_config_set_multivar(buf.buf, buf2.buf, "^$", 0))
 110                        return 1;
 111        }
 112
 113        if (fetch && fetch_remote(name))
 114                return 1;
 115
 116        if (master) {
 117                strbuf_reset(&buf);
 118                strbuf_addf(&buf, "refs/remotes/%s/HEAD", name);
 119
 120                strbuf_reset(&buf2);
 121                strbuf_addf(&buf2, "refs/remotes/%s/%s", name, master);
 122
 123                if (create_symref(buf.buf, buf2.buf, "remote add"))
 124                        return error("Could not setup master '%s'", master);
 125        }
 126
 127        strbuf_release(&buf);
 128        strbuf_release(&buf2);
 129        path_list_clear(&track, 0);
 130
 131        return 0;
 132}
 133
 134struct branch_info {
 135        char *remote;
 136        struct path_list merge;
 137};
 138
 139static struct path_list branch_list;
 140
 141static int config_read_branches(const char *key, const char *value)
 142{
 143        if (!prefixcmp(key, "branch.")) {
 144                char *name;
 145                struct path_list_item *item;
 146                struct branch_info *info;
 147                enum { REMOTE, MERGE } type;
 148
 149                key += 7;
 150                if (!postfixcmp(key, ".remote")) {
 151                        name = xstrndup(key, strlen(key) - 7);
 152                        type = REMOTE;
 153                } else if (!postfixcmp(key, ".merge")) {
 154                        name = xstrndup(key, strlen(key) - 6);
 155                        type = MERGE;
 156                } else
 157                        return 0;
 158
 159                item = path_list_insert(name, &branch_list);
 160
 161                if (!item->util)
 162                        item->util = xcalloc(sizeof(struct branch_info), 1);
 163                info = item->util;
 164                if (type == REMOTE) {
 165                        if (info->remote)
 166                                warning("more than one branch.%s", key);
 167                        info->remote = xstrdup(value);
 168                } else {
 169                        char *space = strchr(value, ' ');
 170                        value = skip_prefix(value, "refs/heads/");
 171                        while (space) {
 172                                char *merge;
 173                                merge = xstrndup(value, space - value);
 174                                path_list_append(merge, &info->merge);
 175                                value = skip_prefix(space + 1, "refs/heads/");
 176                                space = strchr(value, ' ');
 177                        }
 178                        path_list_append(xstrdup(value), &info->merge);
 179                }
 180        }
 181        return 0;
 182}
 183
 184static void read_branches(void)
 185{
 186        if (branch_list.nr)
 187                return;
 188        git_config(config_read_branches);
 189        sort_path_list(&branch_list);
 190}
 191
 192struct ref_states {
 193        struct remote *remote;
 194        struct strbuf remote_prefix;
 195        struct path_list new, stale, tracked;
 196};
 197
 198static int handle_one_branch(const char *refname,
 199        const unsigned char *sha1, int flags, void *cb_data)
 200{
 201        struct ref_states *states = cb_data;
 202        struct refspec refspec;
 203
 204        memset(&refspec, 0, sizeof(refspec));
 205        refspec.dst = (char *)refname;
 206        if (!remote_find_tracking(states->remote, &refspec)) {
 207                struct path_list_item *item;
 208                const char *name = skip_prefix(refspec.src, "refs/heads/");
 209                if (unsorted_path_list_has_path(&states->tracked, name) ||
 210                                unsorted_path_list_has_path(&states->new,
 211                                        name))
 212                        return 0;
 213                item = path_list_append(name, &states->stale);
 214                item->util = xstrdup(refname);
 215        }
 216        return 0;
 217}
 218
 219static int get_ref_states(const struct ref *ref, struct ref_states *states)
 220{
 221        struct ref *fetch_map = NULL, **tail = &fetch_map;
 222        int i;
 223
 224        for (i = 0; i < states->remote->fetch_refspec_nr; i++)
 225                if (get_fetch_map(ref, states->remote->fetch + i, &tail, 1))
 226                        die("Could not get fetch map for refspec %s",
 227                                states->remote->fetch_refspec[i]);
 228
 229        states->new.strdup_paths = states->tracked.strdup_paths = 1;
 230        for (ref = fetch_map; ref; ref = ref->next) {
 231                struct path_list *target = &states->tracked;
 232                unsigned char sha1[20];
 233                void *util = NULL;
 234
 235                if (!ref->peer_ref || read_ref(ref->peer_ref->name, sha1))
 236                        target = &states->new;
 237                else {
 238                        target = &states->tracked;
 239                        if (hashcmp(sha1, ref->new_sha1))
 240                                util = &states;
 241                }
 242                path_list_append(skip_prefix(ref->name, "refs/heads/"),
 243                                target)->util = util;
 244        }
 245        free_refs(fetch_map);
 246
 247        strbuf_addf(&states->remote_prefix,
 248                "refs/remotes/%s/", states->remote->name);
 249        for_each_ref(handle_one_branch, states);
 250        sort_path_list(&states->stale);
 251
 252        return 0;
 253}
 254
 255struct branches_for_remote {
 256        const char *prefix;
 257        struct path_list *branches;
 258};
 259
 260static int add_branch_for_removal(const char *refname,
 261        const unsigned char *sha1, int flags, void *cb_data)
 262{
 263        struct branches_for_remote *branches = cb_data;
 264
 265        if (!prefixcmp(refname, branches->prefix)) {
 266                struct path_list_item *item;
 267                item = path_list_append(refname, branches->branches);
 268                item->util = xmalloc(20);
 269                hashcpy(item->util, sha1);
 270        }
 271
 272        return 0;
 273}
 274
 275static int remove_branches(struct path_list *branches)
 276{
 277        int i, result = 0;
 278        for (i = 0; i < branches->nr; i++) {
 279                struct path_list_item *item = branches->items + i;
 280                const char *refname = item->path;
 281                unsigned char *sha1 = item->util;
 282
 283                if (delete_ref(refname, sha1))
 284                        result |= error("Could not remove branch %s", refname);
 285        }
 286        return result;
 287}
 288
 289static int rm(int argc, const char **argv)
 290{
 291        struct option options[] = {
 292                OPT_END()
 293        };
 294        struct remote *remote;
 295        struct strbuf buf;
 296        struct path_list branches = { NULL, 0, 0, 1 };
 297        struct branches_for_remote cb_data = { NULL, &branches };
 298        int i;
 299
 300        if (argc != 2)
 301                usage_with_options(builtin_remote_usage, options);
 302
 303        remote = remote_get(argv[1]);
 304        if (!remote)
 305                die("No such remote: %s", argv[1]);
 306
 307        strbuf_init(&buf, 0);
 308        strbuf_addf(&buf, "remote.%s", remote->name);
 309        if (git_config_rename_section(buf.buf, NULL) < 1)
 310                return error("Could not remove config section '%s'", buf.buf);
 311
 312        read_branches();
 313        for (i = 0; i < branch_list.nr; i++) {
 314                struct path_list_item *item = branch_list.items + i;
 315                struct branch_info *info = item->util;
 316                if (info->remote && !strcmp(info->remote, remote->name)) {
 317                        const char *keys[] = { "remote", "merge", NULL }, **k;
 318                        for (k = keys; *k; k++) {
 319                                strbuf_reset(&buf);
 320                                strbuf_addf(&buf, "branch.%s.%s",
 321                                                item->path, *k);
 322                                if (git_config_set(buf.buf, NULL)) {
 323                                        strbuf_release(&buf);
 324                                        return -1;
 325                                }
 326                        }
 327                }
 328        }
 329
 330        /*
 331         * We cannot just pass a function to for_each_ref() which deletes
 332         * the branches one by one, since for_each_ref() relies on cached
 333         * refs, which are invalidated when deleting a branch.
 334         */
 335        strbuf_reset(&buf);
 336        strbuf_addf(&buf, "refs/remotes/%s/", remote->name);
 337        cb_data.prefix = buf.buf;
 338        i = for_each_ref(add_branch_for_removal, &cb_data);
 339        strbuf_release(&buf);
 340
 341        if (!i)
 342                i = remove_branches(&branches);
 343        path_list_clear(&branches, 1);
 344
 345        return i;
 346}
 347
 348static void show_list(const char *title, struct path_list *list)
 349{
 350        int i;
 351
 352        if (!list->nr)
 353                return;
 354
 355        printf(title, list->nr > 1 ? "es" : "");
 356        printf("\n    ");
 357        for (i = 0; i < list->nr; i++)
 358                printf("%s%s", i ? " " : "", list->items[i].path);
 359        printf("\n");
 360}
 361
 362static int show_or_prune(int argc, const char **argv, int prune)
 363{
 364        int dry_run = 0, result = 0;
 365        struct option options[] = {
 366                OPT_GROUP("show specific options"),
 367                OPT__DRY_RUN(&dry_run),
 368                OPT_END()
 369        };
 370        struct ref_states states;
 371
 372        argc = parse_options(argc, argv, options, builtin_remote_usage, 0);
 373
 374        if (argc < 1)
 375                usage_with_options(builtin_remote_usage, options);
 376
 377        memset(&states, 0, sizeof(states));
 378        for (; argc; argc--, argv++) {
 379                struct transport *transport;
 380                const struct ref *ref;
 381                struct strbuf buf;
 382                int i, got_states;
 383
 384                states.remote = remote_get(*argv);
 385                if (!states.remote)
 386                        return error("No such remote: %s", *argv);
 387                transport = transport_get(NULL, states.remote->url_nr > 0 ?
 388                        states.remote->url[0] : NULL);
 389                ref = transport_get_remote_refs(transport);
 390                transport_disconnect(transport);
 391
 392                read_branches();
 393                got_states = get_ref_states(ref, &states);
 394                if (got_states)
 395                        result = error("Error getting local info for '%s'",
 396                                        states.remote->name);
 397
 398                if (prune) {
 399                        struct strbuf buf;
 400                        int prefix_len;
 401
 402                        strbuf_init(&buf, 0);
 403                        if (states.remote->fetch_refspec_nr == 1 &&
 404                                        states.remote->fetch->pattern &&
 405                                        !strcmp(states.remote->fetch->src,
 406                                                states.remote->fetch->dst))
 407                                /* handle --mirror remote */
 408                                strbuf_addstr(&buf, "refs/heads/");
 409                        else
 410                                strbuf_addf(&buf, "refs/remotes/%s/", *argv);
 411                        prefix_len = buf.len;
 412
 413                        for (i = 0; i < states.stale.nr; i++) {
 414                                strbuf_setlen(&buf, prefix_len);
 415                                strbuf_addstr(&buf, states.stale.items[i].path);
 416                                result |= delete_ref(buf.buf, NULL);
 417                        }
 418
 419                        strbuf_release(&buf);
 420                        goto cleanup_states;
 421                }
 422
 423                printf("* remote %s\n  URL: %s\n", *argv,
 424                        states.remote->url_nr > 0 ?
 425                                states.remote->url[0] : "(no URL)");
 426
 427                for (i = 0; i < branch_list.nr; i++) {
 428                        struct path_list_item *branch = branch_list.items + i;
 429                        struct branch_info *info = branch->util;
 430                        int j;
 431
 432                        if (!info->merge.nr || strcmp(*argv, info->remote))
 433                                continue;
 434                        printf("  Remote branch%s merged with 'git pull' "
 435                                "while on branch %s\n   ",
 436                                info->merge.nr > 1 ? "es" : "",
 437                                branch->path);
 438                        for (j = 0; j < info->merge.nr; j++)
 439                                printf(" %s", info->merge.items[j].path);
 440                        printf("\n");
 441                }
 442
 443                if (got_states)
 444                        continue;
 445                strbuf_init(&buf, 0);
 446                strbuf_addf(&buf, "  New remote branch%%s (next fetch will "
 447                        "store in remotes/%s)", states.remote->name);
 448                show_list(buf.buf, &states.new);
 449                strbuf_release(&buf);
 450                show_list("  Stale tracking branch%s (use 'git remote prune')",
 451                                &states.stale);
 452                show_list("  Tracked remote branch%s",
 453                                &states.tracked);
 454
 455                if (states.remote->push_refspec_nr) {
 456                        printf("  Local branch%s pushed with 'git push'\n   ",
 457                                states.remote->push_refspec_nr > 1 ?
 458                                        "es" : "");
 459                        for (i = 0; i < states.remote->push_refspec_nr; i++) {
 460                                struct refspec *spec = states.remote->push + i;
 461                                printf(" %s%s%s%s", spec->force ? "+" : "",
 462                                        skip_prefix(spec->src, "refs/heads/"),
 463                                        spec->dst ? ":" : "",
 464                                        skip_prefix(spec->dst, "refs/heads/"));
 465                        }
 466                }
 467cleanup_states:
 468                /* NEEDSWORK: free remote */
 469                path_list_clear(&states.new, 0);
 470                path_list_clear(&states.stale, 0);
 471                path_list_clear(&states.tracked, 0);
 472        }
 473
 474        return result;
 475}
 476
 477static int get_one_remote_for_update(struct remote *remote, void *priv)
 478{
 479        struct path_list *list = priv;
 480        if (!remote->skip_default_update)
 481                path_list_append(xstrdup(remote->name), list);
 482        return 0;
 483}
 484
 485struct remote_group {
 486        const char *name;
 487        struct path_list *list;
 488} remote_group;
 489
 490static int get_remote_group(const char *key, const char *value)
 491{
 492        if (!prefixcmp(key, "remotes.") &&
 493                        !strcmp(key + 8, remote_group.name)) {
 494                /* split list by white space */
 495                int space = strcspn(value, " \t\n");
 496                while (*value) {
 497                        if (space > 1)
 498                                path_list_append(xstrndup(value, space),
 499                                                remote_group.list);
 500                        value += space + (value[space] != '\0');
 501                        space = strcspn(value, " \t\n");
 502                }
 503        }
 504
 505        return 0;
 506}
 507
 508static int update(int argc, const char **argv)
 509{
 510        int i, result = 0;
 511        struct path_list list = { NULL, 0, 0, 0 };
 512        static const char *default_argv[] = { NULL, "default", NULL };
 513
 514        if (argc < 2) {
 515                argc = 2;
 516                argv = default_argv;
 517        }
 518
 519        remote_group.list = &list;
 520        for (i = 1; i < argc; i++) {
 521                remote_group.name = argv[i];
 522                result = git_config(get_remote_group);
 523        }
 524
 525        if (!result && !list.nr  && argc == 2 && !strcmp(argv[1], "default"))
 526                result = for_each_remote(get_one_remote_for_update, &list);
 527
 528        for (i = 0; i < list.nr; i++)
 529                result |= fetch_remote(list.items[i].path);
 530
 531        /* all names were strdup()ed or strndup()ed */
 532        list.strdup_paths = 1;
 533        path_list_clear(&list, 0);
 534
 535        return result;
 536}
 537
 538static int get_one_entry(struct remote *remote, void *priv)
 539{
 540        struct path_list *list = priv;
 541
 542        path_list_append(remote->name, list)->util = remote->url_nr ?
 543                (void *)remote->url[0] : NULL;
 544        if (remote->url_nr > 1)
 545                warning("Remote %s has more than one URL", remote->name);
 546
 547        return 0;
 548}
 549
 550static int show_all(void)
 551{
 552        struct path_list list = { NULL, 0, 0 };
 553        int result = for_each_remote(get_one_entry, &list);
 554
 555        if (!result) {
 556                int i;
 557
 558                sort_path_list(&list);
 559                for (i = 0; i < list.nr; i++) {
 560                        struct path_list_item *item = list.items + i;
 561                        printf("%s%s%s\n", item->path,
 562                                verbose ? "\t" : "",
 563                                verbose && item->util ?
 564                                        (const char *)item->util : "");
 565                }
 566        }
 567        return result;
 568}
 569
 570int cmd_remote(int argc, const char **argv, const char *prefix)
 571{
 572        struct option options[] = {
 573                OPT__VERBOSE(&verbose),
 574                OPT_END()
 575        };
 576        int result;
 577
 578        argc = parse_options(argc, argv, options, builtin_remote_usage,
 579                PARSE_OPT_STOP_AT_NON_OPTION);
 580
 581        if (argc < 1)
 582                result = show_all();
 583        else if (!strcmp(argv[0], "add"))
 584                result = add(argc, argv);
 585        else if (!strcmp(argv[0], "rm"))
 586                result = rm(argc, argv);
 587        else if (!strcmp(argv[0], "show"))
 588                result = show_or_prune(argc, argv, 0);
 589        else if (!strcmp(argv[0], "prune"))
 590                result = show_or_prune(argc, argv, 1);
 591        else if (!strcmp(argv[0], "update"))
 592                result = update(argc, argv);
 593        else {
 594                error("Unknown subcommand: %s", argv[0]);
 595                usage_with_options(builtin_remote_usage, options);
 596        }
 597
 598        return result ? 1 : 0;
 599}