Andrew's git / gitweb.git / remote.c
?
remote.con commit remote: handle pushremote config in any order (98b406f)
   1#include "cache.h"
   2#include "remote.h"
   3#include "refs.h"
   4#include "commit.h"
   5#include "diff.h"
   6#include "revision.h"
   7#include "dir.h"
   8#include "tag.h"
   9#include "string-list.h"
  10#include "mergesort.h"
  11
  12enum map_direction { FROM_SRC, FROM_DST };
  13
  14static struct refspec s_tag_refspec = {
  15        0,
  16        1,
  17        0,
  18        0,
  19        "refs/tags/*",
  20        "refs/tags/*"
  21};
  22
  23const struct refspec *tag_refspec = &s_tag_refspec;
  24
  25struct counted_string {
  26        size_t len;
  27        const char *s;
  28};
  29struct rewrite {
  30        const char *base;
  31        size_t baselen;
  32        struct counted_string *instead_of;
  33        int instead_of_nr;
  34        int instead_of_alloc;
  35};
  36struct rewrites {
  37        struct rewrite **rewrite;
  38        int rewrite_alloc;
  39        int rewrite_nr;
  40};
  41
  42static struct remote **remotes;
  43static int remotes_alloc;
  44static int remotes_nr;
  45
  46static struct branch **branches;
  47static int branches_alloc;
  48static int branches_nr;
  49
  50static struct branch *current_branch;
  51static const char *default_remote_name;
  52static const char *branch_pushremote_name;
  53static const char *pushremote_name;
  54static int explicit_default_remote_name;
  55
  56static struct rewrites rewrites;
  57static struct rewrites rewrites_push;
  58
  59#define BUF_SIZE (2048)
  60static char buffer[BUF_SIZE];
  61
  62static int valid_remote(const struct remote *remote)
  63{
  64        return (!!remote->url) || (!!remote->foreign_vcs);
  65}
  66
  67static const char *alias_url(const char *url, struct rewrites *r)
  68{
  69        int i, j;
  70        char *ret;
  71        struct counted_string *longest;
  72        int longest_i;
  73
  74        longest = NULL;
  75        longest_i = -1;
  76        for (i = 0; i < r->rewrite_nr; i++) {
  77                if (!r->rewrite[i])
  78                        continue;
  79                for (j = 0; j < r->rewrite[i]->instead_of_nr; j++) {
  80                        if (!prefixcmp(url, r->rewrite[i]->instead_of[j].s) &&
  81                            (!longest ||
  82                             longest->len < r->rewrite[i]->instead_of[j].len)) {
  83                                longest = &(r->rewrite[i]->instead_of[j]);
  84                                longest_i = i;
  85                        }
  86                }
  87        }
  88        if (!longest)
  89                return url;
  90
  91        ret = xmalloc(r->rewrite[longest_i]->baselen +
  92                     (strlen(url) - longest->len) + 1);
  93        strcpy(ret, r->rewrite[longest_i]->base);
  94        strcpy(ret + r->rewrite[longest_i]->baselen, url + longest->len);
  95        return ret;
  96}
  97
  98static void add_push_refspec(struct remote *remote, const char *ref)
  99{
 100        ALLOC_GROW(remote->push_refspec,
 101                   remote->push_refspec_nr + 1,
 102                   remote->push_refspec_alloc);
 103        remote->push_refspec[remote->push_refspec_nr++] = ref;
 104}
 105
 106static void add_fetch_refspec(struct remote *remote, const char *ref)
 107{
 108        ALLOC_GROW(remote->fetch_refspec,
 109                   remote->fetch_refspec_nr + 1,
 110                   remote->fetch_refspec_alloc);
 111        remote->fetch_refspec[remote->fetch_refspec_nr++] = ref;
 112}
 113
 114static void add_url(struct remote *remote, const char *url)
 115{
 116        ALLOC_GROW(remote->url, remote->url_nr + 1, remote->url_alloc);
 117        remote->url[remote->url_nr++] = url;
 118}
 119
 120static void add_pushurl(struct remote *remote, const char *pushurl)
 121{
 122        ALLOC_GROW(remote->pushurl, remote->pushurl_nr + 1, remote->pushurl_alloc);
 123        remote->pushurl[remote->pushurl_nr++] = pushurl;
 124}
 125
 126static void add_pushurl_alias(struct remote *remote, const char *url)
 127{
 128        const char *pushurl = alias_url(url, &rewrites_push);
 129        if (pushurl != url)
 130                add_pushurl(remote, pushurl);
 131}
 132
 133static void add_url_alias(struct remote *remote, const char *url)
 134{
 135        add_url(remote, alias_url(url, &rewrites));
 136        add_pushurl_alias(remote, url);
 137}
 138
 139static struct remote *make_remote(const char *name, int len)
 140{
 141        struct remote *ret;
 142        int i;
 143
 144        for (i = 0; i < remotes_nr; i++) {
 145                if (len ? (!strncmp(name, remotes[i]->name, len) &&
 146                           !remotes[i]->name[len]) :
 147                    !strcmp(name, remotes[i]->name))
 148                        return remotes[i];
 149        }
 150
 151        ret = xcalloc(1, sizeof(struct remote));
 152        ret->prune = -1;  /* unspecified */
 153        ALLOC_GROW(remotes, remotes_nr + 1, remotes_alloc);
 154        remotes[remotes_nr++] = ret;
 155        if (len)
 156                ret->name = xstrndup(name, len);
 157        else
 158                ret->name = xstrdup(name);
 159        return ret;
 160}
 161
 162static void add_merge(struct branch *branch, const char *name)
 163{
 164        ALLOC_GROW(branch->merge_name, branch->merge_nr + 1,
 165                   branch->merge_alloc);
 166        branch->merge_name[branch->merge_nr++] = name;
 167}
 168
 169static struct branch *make_branch(const char *name, int len)
 170{
 171        struct branch *ret;
 172        int i;
 173        char *refname;
 174
 175        for (i = 0; i < branches_nr; i++) {
 176                if (len ? (!strncmp(name, branches[i]->name, len) &&
 177                           !branches[i]->name[len]) :
 178                    !strcmp(name, branches[i]->name))
 179                        return branches[i];
 180        }
 181
 182        ALLOC_GROW(branches, branches_nr + 1, branches_alloc);
 183        ret = xcalloc(1, sizeof(struct branch));
 184        branches[branches_nr++] = ret;
 185        if (len)
 186                ret->name = xstrndup(name, len);
 187        else
 188                ret->name = xstrdup(name);
 189        refname = xmalloc(strlen(name) + strlen("refs/heads/") + 1);
 190        strcpy(refname, "refs/heads/");
 191        strcpy(refname + strlen("refs/heads/"), ret->name);
 192        ret->refname = refname;
 193
 194        return ret;
 195}
 196
 197static struct rewrite *make_rewrite(struct rewrites *r, const char *base, int len)
 198{
 199        struct rewrite *ret;
 200        int i;
 201
 202        for (i = 0; i < r->rewrite_nr; i++) {
 203                if (len
 204                    ? (len == r->rewrite[i]->baselen &&
 205                       !strncmp(base, r->rewrite[i]->base, len))
 206                    : !strcmp(base, r->rewrite[i]->base))
 207                        return r->rewrite[i];
 208        }
 209
 210        ALLOC_GROW(r->rewrite, r->rewrite_nr + 1, r->rewrite_alloc);
 211        ret = xcalloc(1, sizeof(struct rewrite));
 212        r->rewrite[r->rewrite_nr++] = ret;
 213        if (len) {
 214                ret->base = xstrndup(base, len);
 215                ret->baselen = len;
 216        }
 217        else {
 218                ret->base = xstrdup(base);
 219                ret->baselen = strlen(base);
 220        }
 221        return ret;
 222}
 223
 224static void add_instead_of(struct rewrite *rewrite, const char *instead_of)
 225{
 226        ALLOC_GROW(rewrite->instead_of, rewrite->instead_of_nr + 1, rewrite->instead_of_alloc);
 227        rewrite->instead_of[rewrite->instead_of_nr].s = instead_of;
 228        rewrite->instead_of[rewrite->instead_of_nr].len = strlen(instead_of);
 229        rewrite->instead_of_nr++;
 230}
 231
 232static void read_remotes_file(struct remote *remote)
 233{
 234        FILE *f = fopen(git_path("remotes/%s", remote->name), "r");
 235
 236        if (!f)
 237                return;
 238        remote->origin = REMOTE_REMOTES;
 239        while (fgets(buffer, BUF_SIZE, f)) {
 240                int value_list;
 241                char *s, *p;
 242
 243                if (!prefixcmp(buffer, "URL:")) {
 244                        value_list = 0;
 245                        s = buffer + 4;
 246                } else if (!prefixcmp(buffer, "Push:")) {
 247                        value_list = 1;
 248                        s = buffer + 5;
 249                } else if (!prefixcmp(buffer, "Pull:")) {
 250                        value_list = 2;
 251                        s = buffer + 5;
 252                } else
 253                        continue;
 254
 255                while (isspace(*s))
 256                        s++;
 257                if (!*s)
 258                        continue;
 259
 260                p = s + strlen(s);
 261                while (isspace(p[-1]))
 262                        *--p = 0;
 263
 264                switch (value_list) {
 265                case 0:
 266                        add_url_alias(remote, xstrdup(s));
 267                        break;
 268                case 1:
 269                        add_push_refspec(remote, xstrdup(s));
 270                        break;
 271                case 2:
 272                        add_fetch_refspec(remote, xstrdup(s));
 273                        break;
 274                }
 275        }
 276        fclose(f);
 277}
 278
 279static void read_branches_file(struct remote *remote)
 280{
 281        char *frag;
 282        struct strbuf branch = STRBUF_INIT;
 283        int n = 1000;
 284        FILE *f = fopen(git_path("branches/%.*s", n, remote->name), "r");
 285        char *s, *p;
 286        int len;
 287
 288        if (!f)
 289                return;
 290        s = fgets(buffer, BUF_SIZE, f);
 291        fclose(f);
 292        if (!s)
 293                return;
 294        while (isspace(*s))
 295                s++;
 296        if (!*s)
 297                return;
 298        remote->origin = REMOTE_BRANCHES;
 299        p = s + strlen(s);
 300        while (isspace(p[-1]))
 301                *--p = 0;
 302        len = p - s;
 303        p = xmalloc(len + 1);
 304        strcpy(p, s);
 305
 306        /*
 307         * The branches file would have URL and optionally
 308         * #branch specified.  The "master" (or specified) branch is
 309         * fetched and stored in the local branch of the same name.
 310         */
 311        frag = strchr(p, '#');
 312        if (frag) {
 313                *(frag++) = '\0';
 314                strbuf_addf(&branch, "refs/heads/%s", frag);
 315        } else
 316                strbuf_addstr(&branch, "refs/heads/master");
 317
 318        strbuf_addf(&branch, ":refs/heads/%s", remote->name);
 319        add_url_alias(remote, p);
 320        add_fetch_refspec(remote, strbuf_detach(&branch, NULL));
 321        /*
 322         * Cogito compatible push: push current HEAD to remote #branch
 323         * (master if missing)
 324         */
 325        strbuf_init(&branch, 0);
 326        strbuf_addstr(&branch, "HEAD");
 327        if (frag)
 328                strbuf_addf(&branch, ":refs/heads/%s", frag);
 329        else
 330                strbuf_addstr(&branch, ":refs/heads/master");
 331        add_push_refspec(remote, strbuf_detach(&branch, NULL));
 332        remote->fetch_tags = 1; /* always auto-follow */
 333}
 334
 335static int handle_config(const char *key, const char *value, void *cb)
 336{
 337        const char *name;
 338        const char *subkey;
 339        struct remote *remote;
 340        struct branch *branch;
 341        if (!prefixcmp(key, "branch.")) {
 342                name = key + 7;
 343                subkey = strrchr(name, '.');
 344                if (!subkey)
 345                        return 0;
 346                branch = make_branch(name, subkey - name);
 347                if (!strcmp(subkey, ".remote")) {
 348                        if (git_config_string(&branch->remote_name, key, value))
 349                                return -1;
 350                        if (branch == current_branch) {
 351                                default_remote_name = branch->remote_name;
 352                                explicit_default_remote_name = 1;
 353                        }
 354                } else if (!strcmp(subkey, ".pushremote")) {
 355                        if (branch == current_branch)
 356                                if (git_config_string(&branch_pushremote_name, key, value))
 357                                        return -1;
 358                } else if (!strcmp(subkey, ".merge")) {
 359                        if (!value)
 360                                return config_error_nonbool(key);
 361                        add_merge(branch, xstrdup(value));
 362                }
 363                return 0;
 364        }
 365        if (!prefixcmp(key, "url.")) {
 366                struct rewrite *rewrite;
 367                name = key + 4;
 368                subkey = strrchr(name, '.');
 369                if (!subkey)
 370                        return 0;
 371                if (!strcmp(subkey, ".insteadof")) {
 372                        rewrite = make_rewrite(&rewrites, name, subkey - name);
 373                        if (!value)
 374                                return config_error_nonbool(key);
 375                        add_instead_of(rewrite, xstrdup(value));
 376                } else if (!strcmp(subkey, ".pushinsteadof")) {
 377                        rewrite = make_rewrite(&rewrites_push, name, subkey - name);
 378                        if (!value)
 379                                return config_error_nonbool(key);
 380                        add_instead_of(rewrite, xstrdup(value));
 381                }
 382        }
 383
 384        if (prefixcmp(key,  "remote."))
 385                return 0;
 386        name = key + 7;
 387
 388        /* Handle remote.* variables */
 389        if (!strcmp(name, "pushdefault"))
 390                return git_config_string(&pushremote_name, key, value);
 391
 392        /* Handle remote.<name>.* variables */
 393        if (*name == '/') {
 394                warning("Config remote shorthand cannot begin with '/': %s",
 395                        name);
 396                return 0;
 397        }
 398        subkey = strrchr(name, '.');
 399        if (!subkey)
 400                return 0;
 401        remote = make_remote(name, subkey - name);
 402        remote->origin = REMOTE_CONFIG;
 403        if (!strcmp(subkey, ".mirror"))
 404                remote->mirror = git_config_bool(key, value);
 405        else if (!strcmp(subkey, ".skipdefaultupdate"))
 406                remote->skip_default_update = git_config_bool(key, value);
 407        else if (!strcmp(subkey, ".skipfetchall"))
 408                remote->skip_default_update = git_config_bool(key, value);
 409        else if (!strcmp(subkey, ".prune"))
 410                remote->prune = git_config_bool(key, value);
 411        else if (!strcmp(subkey, ".url")) {
 412                const char *v;
 413                if (git_config_string(&v, key, value))
 414                        return -1;
 415                add_url(remote, v);
 416        } else if (!strcmp(subkey, ".pushurl")) {
 417                const char *v;
 418                if (git_config_string(&v, key, value))
 419                        return -1;
 420                add_pushurl(remote, v);
 421        } else if (!strcmp(subkey, ".push")) {
 422                const char *v;
 423                if (git_config_string(&v, key, value))
 424                        return -1;
 425                add_push_refspec(remote, v);
 426        } else if (!strcmp(subkey, ".fetch")) {
 427                const char *v;
 428                if (git_config_string(&v, key, value))
 429                        return -1;
 430                add_fetch_refspec(remote, v);
 431        } else if (!strcmp(subkey, ".receivepack")) {
 432                const char *v;
 433                if (git_config_string(&v, key, value))
 434                        return -1;
 435                if (!remote->receivepack)
 436                        remote->receivepack = v;
 437                else
 438                        error("more than one receivepack given, using the first");
 439        } else if (!strcmp(subkey, ".uploadpack")) {
 440                const char *v;
 441                if (git_config_string(&v, key, value))
 442                        return -1;
 443                if (!remote->uploadpack)
 444                        remote->uploadpack = v;
 445                else
 446                        error("more than one uploadpack given, using the first");
 447        } else if (!strcmp(subkey, ".tagopt")) {
 448                if (!strcmp(value, "--no-tags"))
 449                        remote->fetch_tags = -1;
 450                else if (!strcmp(value, "--tags"))
 451                        remote->fetch_tags = 2;
 452        } else if (!strcmp(subkey, ".proxy")) {
 453                return git_config_string((const char **)&remote->http_proxy,
 454                                         key, value);
 455        } else if (!strcmp(subkey, ".vcs")) {
 456                return git_config_string(&remote->foreign_vcs, key, value);
 457        }
 458        return 0;
 459}
 460
 461static void alias_all_urls(void)
 462{
 463        int i, j;
 464        for (i = 0; i < remotes_nr; i++) {
 465                int add_pushurl_aliases;
 466                if (!remotes[i])
 467                        continue;
 468                for (j = 0; j < remotes[i]->pushurl_nr; j++) {
 469                        remotes[i]->pushurl[j] = alias_url(remotes[i]->pushurl[j], &rewrites);
 470                }
 471                add_pushurl_aliases = remotes[i]->pushurl_nr == 0;
 472                for (j = 0; j < remotes[i]->url_nr; j++) {
 473                        if (add_pushurl_aliases)
 474                                add_pushurl_alias(remotes[i], remotes[i]->url[j]);
 475                        remotes[i]->url[j] = alias_url(remotes[i]->url[j], &rewrites);
 476                }
 477        }
 478}
 479
 480static void read_config(void)
 481{
 482        unsigned char sha1[20];
 483        const char *head_ref;
 484        int flag;
 485        if (default_remote_name) /* did this already */
 486                return;
 487        default_remote_name = "origin";
 488        current_branch = NULL;
 489        head_ref = resolve_ref_unsafe("HEAD", sha1, 0, &flag);
 490        if (head_ref && (flag & REF_ISSYMREF) &&
 491            !prefixcmp(head_ref, "refs/heads/")) {
 492                current_branch =
 493                        make_branch(head_ref + strlen("refs/heads/"), 0);
 494        }
 495        git_config(handle_config, NULL);
 496        if (branch_pushremote_name) {
 497                free((char *)pushremote_name);
 498                pushremote_name = branch_pushremote_name;
 499        }
 500        alias_all_urls();
 501}
 502
 503/*
 504 * This function frees a refspec array.
 505 * Warning: code paths should be checked to ensure that the src
 506 *          and dst pointers are always freeable pointers as well
 507 *          as the refspec pointer itself.
 508 */
 509static void free_refspecs(struct refspec *refspec, int nr_refspec)
 510{
 511        int i;
 512
 513        if (!refspec)
 514                return;
 515
 516        for (i = 0; i < nr_refspec; i++) {
 517                free(refspec[i].src);
 518                free(refspec[i].dst);
 519        }
 520        free(refspec);
 521}
 522
 523static struct refspec *parse_refspec_internal(int nr_refspec, const char **refspec, int fetch, int verify)
 524{
 525        int i;
 526        struct refspec *rs = xcalloc(sizeof(*rs), nr_refspec);
 527
 528        for (i = 0; i < nr_refspec; i++) {
 529                size_t llen;
 530                int is_glob;
 531                const char *lhs, *rhs;
 532                int flags;
 533
 534                is_glob = 0;
 535
 536                lhs = refspec[i];
 537                if (*lhs == '+') {
 538                        rs[i].force = 1;
 539                        lhs++;
 540                }
 541
 542                rhs = strrchr(lhs, ':');
 543
 544                /*
 545                 * Before going on, special case ":" (or "+:") as a refspec
 546                 * for pushing matching refs.
 547                 */
 548                if (!fetch && rhs == lhs && rhs[1] == '\0') {
 549                        rs[i].matching = 1;
 550                        continue;
 551                }
 552
 553                if (rhs) {
 554                        size_t rlen = strlen(++rhs);
 555                        is_glob = (1 <= rlen && strchr(rhs, '*'));
 556                        rs[i].dst = xstrndup(rhs, rlen);
 557                }
 558
 559                llen = (rhs ? (rhs - lhs - 1) : strlen(lhs));
 560                if (1 <= llen && memchr(lhs, '*', llen)) {
 561                        if ((rhs && !is_glob) || (!rhs && fetch))
 562                                goto invalid;
 563                        is_glob = 1;
 564                } else if (rhs && is_glob) {
 565                        goto invalid;
 566                }
 567
 568                rs[i].pattern = is_glob;
 569                rs[i].src = xstrndup(lhs, llen);
 570                flags = REFNAME_ALLOW_ONELEVEL | (is_glob ? REFNAME_REFSPEC_PATTERN : 0);
 571
 572                if (fetch) {
 573                        unsigned char unused[40];
 574
 575                        /* LHS */
 576                        if (!*rs[i].src)
 577                                ; /* empty is ok; it means "HEAD" */
 578                        else if (llen == 40 && !get_sha1_hex(rs[i].src, unused))
 579                                rs[i].exact_sha1 = 1; /* ok */
 580                        else if (!check_refname_format(rs[i].src, flags))
 581                                ; /* valid looking ref is ok */
 582                        else
 583                                goto invalid;
 584                        /* RHS */
 585                        if (!rs[i].dst)
 586                                ; /* missing is ok; it is the same as empty */
 587                        else if (!*rs[i].dst)
 588                                ; /* empty is ok; it means "do not store" */
 589                        else if (!check_refname_format(rs[i].dst, flags))
 590                                ; /* valid looking ref is ok */
 591                        else
 592                                goto invalid;
 593                } else {
 594                        /*
 595                         * LHS
 596                         * - empty is allowed; it means delete.
 597                         * - when wildcarded, it must be a valid looking ref.
 598                         * - otherwise, it must be an extended SHA-1, but
 599                         *   there is no existing way to validate this.
 600                         */
 601                        if (!*rs[i].src)
 602                                ; /* empty is ok */
 603                        else if (is_glob) {
 604                                if (check_refname_format(rs[i].src, flags))
 605                                        goto invalid;
 606                        }
 607                        else
 608                                ; /* anything goes, for now */
 609                        /*
 610                         * RHS
 611                         * - missing is allowed, but LHS then must be a
 612                         *   valid looking ref.
 613                         * - empty is not allowed.
 614                         * - otherwise it must be a valid looking ref.
 615                         */
 616                        if (!rs[i].dst) {
 617                                if (check_refname_format(rs[i].src, flags))
 618                                        goto invalid;
 619                        } else if (!*rs[i].dst) {
 620                                goto invalid;
 621                        } else {
 622                                if (check_refname_format(rs[i].dst, flags))
 623                                        goto invalid;
 624                        }
 625                }
 626        }
 627        return rs;
 628
 629 invalid:
 630        if (verify) {
 631                /*
 632                 * nr_refspec must be greater than zero and i must be valid
 633                 * since it is only possible to reach this point from within
 634                 * the for loop above.
 635                 */
 636                free_refspecs(rs, i+1);
 637                return NULL;
 638        }
 639        die("Invalid refspec '%s'", refspec[i]);
 640}
 641
 642int valid_fetch_refspec(const char *fetch_refspec_str)
 643{
 644        struct refspec *refspec;
 645
 646        refspec = parse_refspec_internal(1, &fetch_refspec_str, 1, 1);
 647        free_refspecs(refspec, 1);
 648        return !!refspec;
 649}
 650
 651struct refspec *parse_fetch_refspec(int nr_refspec, const char **refspec)
 652{
 653        return parse_refspec_internal(nr_refspec, refspec, 1, 0);
 654}
 655
 656static struct refspec *parse_push_refspec(int nr_refspec, const char **refspec)
 657{
 658        return parse_refspec_internal(nr_refspec, refspec, 0, 0);
 659}
 660
 661void free_refspec(int nr_refspec, struct refspec *refspec)
 662{
 663        int i;
 664        for (i = 0; i < nr_refspec; i++) {
 665                free(refspec[i].src);
 666                free(refspec[i].dst);
 667        }
 668        free(refspec);
 669}
 670
 671static int valid_remote_nick(const char *name)
 672{
 673        if (!name[0] || is_dot_or_dotdot(name))
 674                return 0;
 675        return !strchr(name, '/'); /* no slash */
 676}
 677
 678static struct remote *remote_get_1(const char *name, const char *pushremote_name)
 679{
 680        struct remote *ret;
 681        int name_given = 0;
 682
 683        if (name)
 684                name_given = 1;
 685        else {
 686                if (pushremote_name) {
 687                        name = pushremote_name;
 688                        name_given = 1;
 689                } else {
 690                        name = default_remote_name;
 691                        name_given = explicit_default_remote_name;
 692                }
 693        }
 694
 695        ret = make_remote(name, 0);
 696        if (valid_remote_nick(name)) {
 697                if (!valid_remote(ret))
 698                        read_remotes_file(ret);
 699                if (!valid_remote(ret))
 700                        read_branches_file(ret);
 701        }
 702        if (name_given && !valid_remote(ret))
 703                add_url_alias(ret, name);
 704        if (!valid_remote(ret))
 705                return NULL;
 706        ret->fetch = parse_fetch_refspec(ret->fetch_refspec_nr, ret->fetch_refspec);
 707        ret->push = parse_push_refspec(ret->push_refspec_nr, ret->push_refspec);
 708        return ret;
 709}
 710
 711struct remote *remote_get(const char *name)
 712{
 713        read_config();
 714        return remote_get_1(name, NULL);
 715}
 716
 717struct remote *pushremote_get(const char *name)
 718{
 719        read_config();
 720        return remote_get_1(name, pushremote_name);
 721}
 722
 723int remote_is_configured(const char *name)
 724{
 725        int i;
 726        read_config();
 727
 728        for (i = 0; i < remotes_nr; i++)
 729                if (!strcmp(name, remotes[i]->name))
 730                        return 1;
 731        return 0;
 732}
 733
 734int for_each_remote(each_remote_fn fn, void *priv)
 735{
 736        int i, result = 0;
 737        read_config();
 738        for (i = 0; i < remotes_nr && !result; i++) {
 739                struct remote *r = remotes[i];
 740                if (!r)
 741                        continue;
 742                if (!r->fetch)
 743                        r->fetch = parse_fetch_refspec(r->fetch_refspec_nr,
 744                                                       r->fetch_refspec);
 745                if (!r->push)
 746                        r->push = parse_push_refspec(r->push_refspec_nr,
 747                                                     r->push_refspec);
 748                result = fn(r, priv);
 749        }
 750        return result;
 751}
 752
 753void ref_remove_duplicates(struct ref *ref_map)
 754{
 755        struct string_list refs = STRING_LIST_INIT_NODUP;
 756        struct string_list_item *item = NULL;
 757        struct ref *prev = NULL, *next = NULL;
 758        for (; ref_map; prev = ref_map, ref_map = next) {
 759                next = ref_map->next;
 760                if (!ref_map->peer_ref)
 761                        continue;
 762
 763                item = string_list_lookup(&refs, ref_map->peer_ref->name);
 764                if (item) {
 765                        if (strcmp(((struct ref *)item->util)->name,
 766                                   ref_map->name))
 767                                die("%s tracks both %s and %s",
 768                                    ref_map->peer_ref->name,
 769                                    ((struct ref *)item->util)->name,
 770                                    ref_map->name);
 771                        prev->next = ref_map->next;
 772                        free(ref_map->peer_ref);
 773                        free(ref_map);
 774                        ref_map = prev; /* skip this; we freed it */
 775                        continue;
 776                }
 777
 778                item = string_list_insert(&refs, ref_map->peer_ref->name);
 779                item->util = ref_map;
 780        }
 781        string_list_clear(&refs, 0);
 782}
 783
 784int remote_has_url(struct remote *remote, const char *url)
 785{
 786        int i;
 787        for (i = 0; i < remote->url_nr; i++) {
 788                if (!strcmp(remote->url[i], url))
 789                        return 1;
 790        }
 791        return 0;
 792}
 793
 794static int match_name_with_pattern(const char *key, const char *name,
 795                                   const char *value, char **result)
 796{
 797        const char *kstar = strchr(key, '*');
 798        size_t klen;
 799        size_t ksuffixlen;
 800        size_t namelen;
 801        int ret;
 802        if (!kstar)
 803                die("Key '%s' of pattern had no '*'", key);
 804        klen = kstar - key;
 805        ksuffixlen = strlen(kstar + 1);
 806        namelen = strlen(name);
 807        ret = !strncmp(name, key, klen) && namelen >= klen + ksuffixlen &&
 808                !memcmp(name + namelen - ksuffixlen, kstar + 1, ksuffixlen);
 809        if (ret && value) {
 810                const char *vstar = strchr(value, '*');
 811                size_t vlen;
 812                size_t vsuffixlen;
 813                if (!vstar)
 814                        die("Value '%s' of pattern has no '*'", value);
 815                vlen = vstar - value;
 816                vsuffixlen = strlen(vstar + 1);
 817                *result = xmalloc(vlen + vsuffixlen +
 818                                  strlen(name) -
 819                                  klen - ksuffixlen + 1);
 820                strncpy(*result, value, vlen);
 821                strncpy(*result + vlen,
 822                        name + klen, namelen - klen - ksuffixlen);
 823                strcpy(*result + vlen + namelen - klen - ksuffixlen,
 824                       vstar + 1);
 825        }
 826        return ret;
 827}
 828
 829static int query_refspecs(struct refspec *refs, int ref_count, struct refspec *query)
 830{
 831        int i;
 832        int find_src = !query->src;
 833
 834        if (find_src && !query->dst)
 835                return error("query_refspecs: need either src or dst");
 836
 837        for (i = 0; i < ref_count; i++) {
 838                struct refspec *refspec = &refs[i];
 839                const char *key = find_src ? refspec->dst : refspec->src;
 840                const char *value = find_src ? refspec->src : refspec->dst;
 841                const char *needle = find_src ? query->dst : query->src;
 842                char **result = find_src ? &query->src : &query->dst;
 843
 844                if (!refspec->dst)
 845                        continue;
 846                if (refspec->pattern) {
 847                        if (match_name_with_pattern(key, needle, value, result)) {
 848                                query->force = refspec->force;
 849                                return 0;
 850                        }
 851                } else if (!strcmp(needle, key)) {
 852                        *result = xstrdup(value);
 853                        query->force = refspec->force;
 854                        return 0;
 855                }
 856        }
 857        return -1;
 858}
 859
 860char *apply_refspecs(struct refspec *refspecs, int nr_refspec,
 861                     const char *name)
 862{
 863        struct refspec query;
 864
 865        memset(&query, 0, sizeof(struct refspec));
 866        query.src = (char *)name;
 867
 868        if (query_refspecs(refspecs, nr_refspec, &query))
 869                return NULL;
 870
 871        return query.dst;
 872}
 873
 874int remote_find_tracking(struct remote *remote, struct refspec *refspec)
 875{
 876        return query_refspecs(remote->fetch, remote->fetch_refspec_nr, refspec);
 877}
 878
 879static struct ref *alloc_ref_with_prefix(const char *prefix, size_t prefixlen,
 880                const char *name)
 881{
 882        size_t len = strlen(name);
 883        struct ref *ref = xcalloc(1, sizeof(struct ref) + prefixlen + len + 1);
 884        memcpy(ref->name, prefix, prefixlen);
 885        memcpy(ref->name + prefixlen, name, len);
 886        return ref;
 887}
 888
 889struct ref *alloc_ref(const char *name)
 890{
 891        return alloc_ref_with_prefix("", 0, name);
 892}
 893
 894struct ref *copy_ref(const struct ref *ref)
 895{
 896        struct ref *cpy;
 897        size_t len;
 898        if (!ref)
 899                return NULL;
 900        len = strlen(ref->name);
 901        cpy = xmalloc(sizeof(struct ref) + len + 1);
 902        memcpy(cpy, ref, sizeof(struct ref) + len + 1);
 903        cpy->next = NULL;
 904        cpy->symref = ref->symref ? xstrdup(ref->symref) : NULL;
 905        cpy->remote_status = ref->remote_status ? xstrdup(ref->remote_status) : NULL;
 906        cpy->peer_ref = copy_ref(ref->peer_ref);
 907        return cpy;
 908}
 909
 910struct ref *copy_ref_list(const struct ref *ref)
 911{
 912        struct ref *ret = NULL;
 913        struct ref **tail = &ret;
 914        while (ref) {
 915                *tail = copy_ref(ref);
 916                ref = ref->next;
 917                tail = &((*tail)->next);
 918        }
 919        return ret;
 920}
 921
 922static void free_ref(struct ref *ref)
 923{
 924        if (!ref)
 925                return;
 926        free_ref(ref->peer_ref);
 927        free(ref->remote_status);
 928        free(ref->symref);
 929        free(ref);
 930}
 931
 932void free_refs(struct ref *ref)
 933{
 934        struct ref *next;
 935        while (ref) {
 936                next = ref->next;
 937                free_ref(ref);
 938                ref = next;
 939        }
 940}
 941
 942int ref_compare_name(const void *va, const void *vb)
 943{
 944        const struct ref *a = va, *b = vb;
 945        return strcmp(a->name, b->name);
 946}
 947
 948static void *ref_list_get_next(const void *a)
 949{
 950        return ((const struct ref *)a)->next;
 951}
 952
 953static void ref_list_set_next(void *a, void *next)
 954{
 955        ((struct ref *)a)->next = next;
 956}
 957
 958void sort_ref_list(struct ref **l, int (*cmp)(const void *, const void *))
 959{
 960        *l = llist_mergesort(*l, ref_list_get_next, ref_list_set_next, cmp);
 961}
 962
 963static int count_refspec_match(const char *pattern,
 964                               struct ref *refs,
 965                               struct ref **matched_ref)
 966{
 967        int patlen = strlen(pattern);
 968        struct ref *matched_weak = NULL;
 969        struct ref *matched = NULL;
 970        int weak_match = 0;
 971        int match = 0;
 972
 973        for (weak_match = match = 0; refs; refs = refs->next) {
 974                char *name = refs->name;
 975                int namelen = strlen(name);
 976
 977                if (!refname_match(pattern, name, ref_rev_parse_rules))
 978                        continue;
 979
 980                /* A match is "weak" if it is with refs outside
 981                 * heads or tags, and did not specify the pattern
 982                 * in full (e.g. "refs/remotes/origin/master") or at
 983                 * least from the toplevel (e.g. "remotes/origin/master");
 984                 * otherwise "git push $URL master" would result in
 985                 * ambiguity between remotes/origin/master and heads/master
 986                 * at the remote site.
 987                 */
 988                if (namelen != patlen &&
 989                    patlen != namelen - 5 &&
 990                    prefixcmp(name, "refs/heads/") &&
 991                    prefixcmp(name, "refs/tags/")) {
 992                        /* We want to catch the case where only weak
 993                         * matches are found and there are multiple
 994                         * matches, and where more than one strong
 995                         * matches are found, as ambiguous.  One
 996                         * strong match with zero or more weak matches
 997                         * are acceptable as a unique match.
 998                         */
 999                        matched_weak = refs;
1000                        weak_match++;
1001                }
1002                else {
1003                        matched = refs;
1004                        match++;
1005                }
1006        }
1007        if (!matched) {
1008                *matched_ref = matched_weak;
1009                return weak_match;
1010        }
1011        else {
1012                *matched_ref = matched;
1013                return match;
1014        }
1015}
1016
1017static void tail_link_ref(struct ref *ref, struct ref ***tail)
1018{
1019        **tail = ref;
1020        while (ref->next)
1021                ref = ref->next;
1022        *tail = &ref->next;
1023}
1024
1025static struct ref *alloc_delete_ref(void)
1026{
1027        struct ref *ref = alloc_ref("(delete)");
1028        hashclr(ref->new_sha1);
1029        return ref;
1030}
1031
1032static struct ref *try_explicit_object_name(const char *name)
1033{
1034        unsigned char sha1[20];
1035        struct ref *ref;
1036
1037        if (!*name)
1038                return alloc_delete_ref();
1039        if (get_sha1(name, sha1))
1040                return NULL;
1041        ref = alloc_ref(name);
1042        hashcpy(ref->new_sha1, sha1);
1043        return ref;
1044}
1045
1046static struct ref *make_linked_ref(const char *name, struct ref ***tail)
1047{
1048        struct ref *ret = alloc_ref(name);
1049        tail_link_ref(ret, tail);
1050        return ret;
1051}
1052
1053static char *guess_ref(const char *name, struct ref *peer)
1054{
1055        struct strbuf buf = STRBUF_INIT;
1056        unsigned char sha1[20];
1057
1058        const char *r = resolve_ref_unsafe(peer->name, sha1, 1, NULL);
1059        if (!r)
1060                return NULL;
1061
1062        if (!prefixcmp(r, "refs/heads/"))
1063                strbuf_addstr(&buf, "refs/heads/");
1064        else if (!prefixcmp(r, "refs/tags/"))
1065                strbuf_addstr(&buf, "refs/tags/");
1066        else
1067                return NULL;
1068
1069        strbuf_addstr(&buf, name);
1070        return strbuf_detach(&buf, NULL);
1071}
1072
1073static int match_explicit(struct ref *src, struct ref *dst,
1074                          struct ref ***dst_tail,
1075                          struct refspec *rs)
1076{
1077        struct ref *matched_src, *matched_dst;
1078        int copy_src;
1079
1080        const char *dst_value = rs->dst;
1081        char *dst_guess;
1082
1083        if (rs->pattern || rs->matching)
1084                return 0;
1085
1086        matched_src = matched_dst = NULL;
1087        switch (count_refspec_match(rs->src, src, &matched_src)) {
1088        case 1:
1089                copy_src = 1;
1090                break;
1091        case 0:
1092                /* The source could be in the get_sha1() format
1093                 * not a reference name.  :refs/other is a
1094                 * way to delete 'other' ref at the remote end.
1095                 */
1096                matched_src = try_explicit_object_name(rs->src);
1097                if (!matched_src)
1098                        return error("src refspec %s does not match any.", rs->src);
1099                copy_src = 0;
1100                break;
1101        default:
1102                return error("src refspec %s matches more than one.", rs->src);
1103        }
1104
1105        if (!dst_value) {
1106                unsigned char sha1[20];
1107                int flag;
1108
1109                dst_value = resolve_ref_unsafe(matched_src->name, sha1, 1, &flag);
1110                if (!dst_value ||
1111                    ((flag & REF_ISSYMREF) &&
1112                     prefixcmp(dst_value, "refs/heads/")))
1113                        die("%s cannot be resolved to branch.",
1114                            matched_src->name);
1115        }
1116
1117        switch (count_refspec_match(dst_value, dst, &matched_dst)) {
1118        case 1:
1119                break;
1120        case 0:
1121                if (!memcmp(dst_value, "refs/", 5))
1122                        matched_dst = make_linked_ref(dst_value, dst_tail);
1123                else if (is_null_sha1(matched_src->new_sha1))
1124                        error("unable to delete '%s': remote ref does not exist",
1125                              dst_value);
1126                else if ((dst_guess = guess_ref(dst_value, matched_src)))
1127                        matched_dst = make_linked_ref(dst_guess, dst_tail);
1128                else
1129                        error("unable to push to unqualified destination: %s\n"
1130                              "The destination refspec neither matches an "
1131                              "existing ref on the remote nor\n"
1132                              "begins with refs/, and we are unable to "
1133                              "guess a prefix based on the source ref.",
1134                              dst_value);
1135                break;
1136        default:
1137                matched_dst = NULL;
1138                error("dst refspec %s matches more than one.",
1139                      dst_value);
1140                break;
1141        }
1142        if (!matched_dst)
1143                return -1;
1144        if (matched_dst->peer_ref)
1145                return error("dst ref %s receives from more than one src.",
1146                      matched_dst->name);
1147        else {
1148                matched_dst->peer_ref = copy_src ? copy_ref(matched_src) : matched_src;
1149                matched_dst->force = rs->force;
1150        }
1151        return 0;
1152}
1153
1154static int match_explicit_refs(struct ref *src, struct ref *dst,
1155                               struct ref ***dst_tail, struct refspec *rs,
1156                               int rs_nr)
1157{
1158        int i, errs;
1159        for (i = errs = 0; i < rs_nr; i++)
1160                errs += match_explicit(src, dst, dst_tail, &rs[i]);
1161        return errs;
1162}
1163
1164static char *get_ref_match(const struct refspec *rs, int rs_nr, const struct ref *ref,
1165                int send_mirror, int direction, const struct refspec **ret_pat)
1166{
1167        const struct refspec *pat;
1168        char *name;
1169        int i;
1170        int matching_refs = -1;
1171        for (i = 0; i < rs_nr; i++) {
1172                if (rs[i].matching &&
1173                    (matching_refs == -1 || rs[i].force)) {
1174                        matching_refs = i;
1175                        continue;
1176                }
1177
1178                if (rs[i].pattern) {
1179                        const char *dst_side = rs[i].dst ? rs[i].dst : rs[i].src;
1180                        int match;
1181                        if (direction == FROM_SRC)
1182                                match = match_name_with_pattern(rs[i].src, ref->name, dst_side, &name);
1183                        else
1184                                match = match_name_with_pattern(dst_side, ref->name, rs[i].src, &name);
1185                        if (match) {
1186                                matching_refs = i;
1187                                break;
1188                        }
1189                }
1190        }
1191        if (matching_refs == -1)
1192                return NULL;
1193
1194        pat = rs + matching_refs;
1195        if (pat->matching) {
1196                /*
1197                 * "matching refs"; traditionally we pushed everything
1198                 * including refs outside refs/heads/ hierarchy, but
1199                 * that does not make much sense these days.
1200                 */
1201                if (!send_mirror && prefixcmp(ref->name, "refs/heads/"))
1202                        return NULL;
1203                name = xstrdup(ref->name);
1204        }
1205        if (ret_pat)
1206                *ret_pat = pat;
1207        return name;
1208}
1209
1210static struct ref **tail_ref(struct ref **head)
1211{
1212        struct ref **tail = head;
1213        while (*tail)
1214                tail = &((*tail)->next);
1215        return tail;
1216}
1217
1218struct tips {
1219        struct commit **tip;
1220        int nr, alloc;
1221};
1222
1223static void add_to_tips(struct tips *tips, const unsigned char *sha1)
1224{
1225        struct commit *commit;
1226
1227        if (is_null_sha1(sha1))
1228                return;
1229        commit = lookup_commit_reference_gently(sha1, 1);
1230        if (!commit || (commit->object.flags & TMP_MARK))
1231                return;
1232        commit->object.flags |= TMP_MARK;
1233        ALLOC_GROW(tips->tip, tips->nr + 1, tips->alloc);
1234        tips->tip[tips->nr++] = commit;
1235}
1236
1237static void add_missing_tags(struct ref *src, struct ref **dst, struct ref ***dst_tail)
1238{
1239        struct string_list dst_tag = STRING_LIST_INIT_NODUP;
1240        struct string_list src_tag = STRING_LIST_INIT_NODUP;
1241        struct string_list_item *item;
1242        struct ref *ref;
1243        struct tips sent_tips;
1244
1245        /*
1246         * Collect everything we know they would have at the end of
1247         * this push, and collect all tags they have.
1248         */
1249        memset(&sent_tips, 0, sizeof(sent_tips));
1250        for (ref = *dst; ref; ref = ref->next) {
1251                if (ref->peer_ref &&
1252                    !is_null_sha1(ref->peer_ref->new_sha1))
1253                        add_to_tips(&sent_tips, ref->peer_ref->new_sha1);
1254                else
1255                        add_to_tips(&sent_tips, ref->old_sha1);
1256                if (!prefixcmp(ref->name, "refs/tags/"))
1257                        string_list_append(&dst_tag, ref->name);
1258        }
1259        clear_commit_marks_many(sent_tips.nr, sent_tips.tip, TMP_MARK);
1260
1261        sort_string_list(&dst_tag);
1262
1263        /* Collect tags they do not have. */
1264        for (ref = src; ref; ref = ref->next) {
1265                if (prefixcmp(ref->name, "refs/tags/"))
1266                        continue; /* not a tag */
1267                if (string_list_has_string(&dst_tag, ref->name))
1268                        continue; /* they already have it */
1269                if (sha1_object_info(ref->new_sha1, NULL) != OBJ_TAG)
1270                        continue; /* be conservative */
1271                item = string_list_append(&src_tag, ref->name);
1272                item->util = ref;
1273        }
1274        string_list_clear(&dst_tag, 0);
1275
1276        /*
1277         * At this point, src_tag lists tags that are missing from
1278         * dst, and sent_tips lists the tips we are pushing or those
1279         * that we know they already have. An element in the src_tag
1280         * that is an ancestor of any of the sent_tips needs to be
1281         * sent to the other side.
1282         */
1283        if (sent_tips.nr) {
1284                for_each_string_list_item(item, &src_tag) {
1285                        struct ref *ref = item->util;
1286                        struct ref *dst_ref;
1287                        struct commit *commit;
1288
1289                        if (is_null_sha1(ref->new_sha1))
1290                                continue;
1291                        commit = lookup_commit_reference_gently(ref->new_sha1, 1);
1292                        if (!commit)
1293                                /* not pushing a commit, which is not an error */
1294                                continue;
1295
1296                        /*
1297                         * Is this tag, which they do not have, reachable from
1298                         * any of the commits we are sending?
1299                         */
1300                        if (!in_merge_bases_many(commit, sent_tips.nr, sent_tips.tip))
1301                                continue;
1302
1303                        /* Add it in */
1304                        dst_ref = make_linked_ref(ref->name, dst_tail);
1305                        hashcpy(dst_ref->new_sha1, ref->new_sha1);
1306                        dst_ref->peer_ref = copy_ref(ref);
1307                }
1308        }
1309        string_list_clear(&src_tag, 0);
1310        free(sent_tips.tip);
1311}
1312
1313struct ref *find_ref_by_name(const struct ref *list, const char *name)
1314{
1315        for ( ; list; list = list->next)
1316                if (!strcmp(list->name, name))
1317                        return (struct ref *)list;
1318        return NULL;
1319}
1320
1321static void prepare_ref_index(struct string_list *ref_index, struct ref *ref)
1322{
1323        for ( ; ref; ref = ref->next)
1324                string_list_append_nodup(ref_index, ref->name)->util = ref;
1325
1326        sort_string_list(ref_index);
1327}
1328
1329/*
1330 * Given the set of refs the local repository has, the set of refs the
1331 * remote repository has, and the refspec used for push, determine
1332 * what remote refs we will update and with what value by setting
1333 * peer_ref (which object is being pushed) and force (if the push is
1334 * forced) in elements of "dst". The function may add new elements to
1335 * dst (e.g. pushing to a new branch, done in match_explicit_refs).
1336 */
1337int match_push_refs(struct ref *src, struct ref **dst,
1338                    int nr_refspec, const char **refspec, int flags)
1339{
1340        struct refspec *rs;
1341        int send_all = flags & MATCH_REFS_ALL;
1342        int send_mirror = flags & MATCH_REFS_MIRROR;
1343        int send_prune = flags & MATCH_REFS_PRUNE;
1344        int errs;
1345        static const char *default_refspec[] = { ":", NULL };
1346        struct ref *ref, **dst_tail = tail_ref(dst);
1347        struct string_list dst_ref_index = STRING_LIST_INIT_NODUP;
1348
1349        if (!nr_refspec) {
1350                nr_refspec = 1;
1351                refspec = default_refspec;
1352        }
1353        rs = parse_push_refspec(nr_refspec, (const char **) refspec);
1354        errs = match_explicit_refs(src, *dst, &dst_tail, rs, nr_refspec);
1355
1356        /* pick the remainder */
1357        for (ref = src; ref; ref = ref->next) {
1358                struct string_list_item *dst_item;
1359                struct ref *dst_peer;
1360                const struct refspec *pat = NULL;
1361                char *dst_name;
1362
1363                dst_name = get_ref_match(rs, nr_refspec, ref, send_mirror, FROM_SRC, &pat);
1364                if (!dst_name)
1365                        continue;
1366
1367                if (!dst_ref_index.nr)
1368                        prepare_ref_index(&dst_ref_index, *dst);
1369
1370                dst_item = string_list_lookup(&dst_ref_index, dst_name);
1371                dst_peer = dst_item ? dst_item->util : NULL;
1372                if (dst_peer) {
1373                        if (dst_peer->peer_ref)
1374                                /* We're already sending something to this ref. */
1375                                goto free_name;
1376                } else {
1377                        if (pat->matching && !(send_all || send_mirror))
1378                                /*
1379                                 * Remote doesn't have it, and we have no
1380                                 * explicit pattern, and we don't have
1381                                 * --all nor --mirror.
1382                                 */
1383                                goto free_name;
1384
1385                        /* Create a new one and link it */
1386                        dst_peer = make_linked_ref(dst_name, &dst_tail);
1387                        hashcpy(dst_peer->new_sha1, ref->new_sha1);
1388                        string_list_insert(&dst_ref_index,
1389                                dst_peer->name)->util = dst_peer;
1390                }
1391                dst_peer->peer_ref = copy_ref(ref);
1392                dst_peer->force = pat->force;
1393        free_name:
1394                free(dst_name);
1395        }
1396
1397        string_list_clear(&dst_ref_index, 0);
1398
1399        if (flags & MATCH_REFS_FOLLOW_TAGS)
1400                add_missing_tags(src, dst, &dst_tail);
1401
1402        if (send_prune) {
1403                struct string_list src_ref_index = STRING_LIST_INIT_NODUP;
1404                /* check for missing refs on the remote */
1405                for (ref = *dst; ref; ref = ref->next) {
1406                        char *src_name;
1407
1408                        if (ref->peer_ref)
1409                                /* We're already sending something to this ref. */
1410                                continue;
1411
1412                        src_name = get_ref_match(rs, nr_refspec, ref, send_mirror, FROM_DST, NULL);
1413                        if (src_name) {
1414                                if (!src_ref_index.nr)
1415                                        prepare_ref_index(&src_ref_index, src);
1416                                if (!string_list_has_string(&src_ref_index,
1417                                            src_name))
1418                                        ref->peer_ref = alloc_delete_ref();
1419                                free(src_name);
1420                        }
1421                }
1422                string_list_clear(&src_ref_index, 0);
1423        }
1424        if (errs)
1425                return -1;
1426        return 0;
1427}
1428
1429void set_ref_status_for_push(struct ref *remote_refs, int send_mirror,
1430                             int force_update)
1431{
1432        struct ref *ref;
1433
1434        for (ref = remote_refs; ref; ref = ref->next) {
1435                int force_ref_update = ref->force || force_update;
1436                int reject_reason = 0;
1437
1438                if (ref->peer_ref)
1439                        hashcpy(ref->new_sha1, ref->peer_ref->new_sha1);
1440                else if (!send_mirror)
1441                        continue;
1442
1443                ref->deletion = is_null_sha1(ref->new_sha1);
1444                if (!ref->deletion &&
1445                        !hashcmp(ref->old_sha1, ref->new_sha1)) {
1446                        ref->status = REF_STATUS_UPTODATE;
1447                        continue;
1448                }
1449
1450                /*
1451                 * Bypass the usual "must fast-forward" check but
1452                 * replace it with a weaker "the old value must be
1453                 * this value we observed".  If the remote ref has
1454                 * moved and is now different from what we expect,
1455                 * reject any push.
1456                 *
1457                 * It also is an error if the user told us to check
1458                 * with the remote-tracking branch to find the value
1459                 * to expect, but we did not have such a tracking
1460                 * branch.
1461                 */
1462                if (ref->expect_old_sha1) {
1463                        if (ref->expect_old_no_trackback ||
1464                            hashcmp(ref->old_sha1, ref->old_sha1_expect))
1465                                reject_reason = REF_STATUS_REJECT_STALE;
1466                }
1467
1468                /*
1469                 * The usual "must fast-forward" rules.
1470                 *
1471                 * Decide whether an individual refspec A:B can be
1472                 * pushed.  The push will succeed if any of the
1473                 * following are true:
1474                 *
1475                 * (1) the remote reference B does not exist
1476                 *
1477                 * (2) the remote reference B is being removed (i.e.,
1478                 *     pushing :B where no source is specified)
1479                 *
1480                 * (3) the destination is not under refs/tags/, and
1481                 *     if the old and new value is a commit, the new
1482                 *     is a descendant of the old.
1483                 *
1484                 * (4) it is forced using the +A:B notation, or by
1485                 *     passing the --force argument
1486                 */
1487
1488                else if (!ref->deletion && !is_null_sha1(ref->old_sha1)) {
1489                        if (!prefixcmp(ref->name, "refs/tags/"))
1490                                reject_reason = REF_STATUS_REJECT_ALREADY_EXISTS;
1491                        else if (!has_sha1_file(ref->old_sha1))
1492                                reject_reason = REF_STATUS_REJECT_FETCH_FIRST;
1493                        else if (!lookup_commit_reference_gently(ref->old_sha1, 1) ||
1494                                 !lookup_commit_reference_gently(ref->new_sha1, 1))
1495                                reject_reason = REF_STATUS_REJECT_NEEDS_FORCE;
1496                        else if (!ref_newer(ref->new_sha1, ref->old_sha1))
1497                                reject_reason = REF_STATUS_REJECT_NONFASTFORWARD;
1498                }
1499
1500                /*
1501                 * "--force" will defeat any rejection implemented
1502                 * by the rules above.
1503                 */
1504                if (!force_ref_update)
1505                        ref->status = reject_reason;
1506                else if (reject_reason)
1507                        ref->forced_update = 1;
1508        }
1509}
1510
1511struct branch *branch_get(const char *name)
1512{
1513        struct branch *ret;
1514
1515        read_config();
1516        if (!name || !*name || !strcmp(name, "HEAD"))
1517                ret = current_branch;
1518        else
1519                ret = make_branch(name, 0);
1520        if (ret && ret->remote_name) {
1521                ret->remote = remote_get(ret->remote_name);
1522                if (ret->merge_nr) {
1523                        int i;
1524                        ret->merge = xcalloc(ret->merge_nr, sizeof(*ret->merge));
1525                        for (i = 0; i < ret->merge_nr; i++) {
1526                                ret->merge[i] = xcalloc(1, sizeof(**ret->merge));
1527                                ret->merge[i]->src = xstrdup(ret->merge_name[i]);
1528                                if (remote_find_tracking(ret->remote, ret->merge[i])
1529                                    && !strcmp(ret->remote_name, "."))
1530                                        ret->merge[i]->dst = xstrdup(ret->merge_name[i]);
1531                        }
1532                }
1533        }
1534        return ret;
1535}
1536
1537int branch_has_merge_config(struct branch *branch)
1538{
1539        return branch && !!branch->merge;
1540}
1541
1542int branch_merge_matches(struct branch *branch,
1543                                 int i,
1544                                 const char *refname)
1545{
1546        if (!branch || i < 0 || i >= branch->merge_nr)
1547                return 0;
1548        return refname_match(branch->merge[i]->src, refname, ref_fetch_rules);
1549}
1550
1551static int ignore_symref_update(const char *refname)
1552{
1553        unsigned char sha1[20];
1554        int flag;
1555
1556        if (!resolve_ref_unsafe(refname, sha1, 0, &flag))
1557                return 0; /* non-existing refs are OK */
1558        return (flag & REF_ISSYMREF);
1559}
1560
1561static struct ref *get_expanded_map(const struct ref *remote_refs,
1562                                    const struct refspec *refspec)
1563{
1564        const struct ref *ref;
1565        struct ref *ret = NULL;
1566        struct ref **tail = &ret;
1567
1568        char *expn_name;
1569
1570        for (ref = remote_refs; ref; ref = ref->next) {
1571                if (strchr(ref->name, '^'))
1572                        continue; /* a dereference item */
1573                if (match_name_with_pattern(refspec->src, ref->name,
1574                                            refspec->dst, &expn_name) &&
1575                    !ignore_symref_update(expn_name)) {
1576                        struct ref *cpy = copy_ref(ref);
1577
1578                        cpy->peer_ref = alloc_ref(expn_name);
1579                        free(expn_name);
1580                        if (refspec->force)
1581                                cpy->peer_ref->force = 1;
1582                        *tail = cpy;
1583                        tail = &cpy->next;
1584                }
1585        }
1586
1587        return ret;
1588}
1589
1590static const struct ref *find_ref_by_name_abbrev(const struct ref *refs, const char *name)
1591{
1592        const struct ref *ref;
1593        for (ref = refs; ref; ref = ref->next) {
1594                if (refname_match(name, ref->name, ref_fetch_rules))
1595                        return ref;
1596        }
1597        return NULL;
1598}
1599
1600struct ref *get_remote_ref(const struct ref *remote_refs, const char *name)
1601{
1602        const struct ref *ref = find_ref_by_name_abbrev(remote_refs, name);
1603
1604        if (!ref)
1605                return NULL;
1606
1607        return copy_ref(ref);
1608}
1609
1610static struct ref *get_local_ref(const char *name)
1611{
1612        if (!name || name[0] == '\0')
1613                return NULL;
1614
1615        if (!prefixcmp(name, "refs/"))
1616                return alloc_ref(name);
1617
1618        if (!prefixcmp(name, "heads/") ||
1619            !prefixcmp(name, "tags/") ||
1620            !prefixcmp(name, "remotes/"))
1621                return alloc_ref_with_prefix("refs/", 5, name);
1622
1623        return alloc_ref_with_prefix("refs/heads/", 11, name);
1624}
1625
1626int get_fetch_map(const struct ref *remote_refs,
1627                  const struct refspec *refspec,
1628                  struct ref ***tail,
1629                  int missing_ok)
1630{
1631        struct ref *ref_map, **rmp;
1632
1633        if (refspec->pattern) {
1634                ref_map = get_expanded_map(remote_refs, refspec);
1635        } else {
1636                const char *name = refspec->src[0] ? refspec->src : "HEAD";
1637
1638                if (refspec->exact_sha1) {
1639                        ref_map = alloc_ref(name);
1640                        get_sha1_hex(name, ref_map->old_sha1);
1641                } else {
1642                        ref_map = get_remote_ref(remote_refs, name);
1643                }
1644                if (!missing_ok && !ref_map)
1645                        die("Couldn't find remote ref %s", name);
1646                if (ref_map) {
1647                        ref_map->peer_ref = get_local_ref(refspec->dst);
1648                        if (ref_map->peer_ref && refspec->force)
1649                                ref_map->peer_ref->force = 1;
1650                }
1651        }
1652
1653        for (rmp = &ref_map; *rmp; ) {
1654                if ((*rmp)->peer_ref) {
1655                        if (prefixcmp((*rmp)->peer_ref->name, "refs/") ||
1656                            check_refname_format((*rmp)->peer_ref->name, 0)) {
1657                                struct ref *ignore = *rmp;
1658                                error("* Ignoring funny ref '%s' locally",
1659                                      (*rmp)->peer_ref->name);
1660                                *rmp = (*rmp)->next;
1661                                free(ignore->peer_ref);
1662                                free(ignore);
1663                                continue;
1664                        }
1665                }
1666                rmp = &((*rmp)->next);
1667        }
1668
1669        if (ref_map)
1670                tail_link_ref(ref_map, tail);
1671
1672        return 0;
1673}
1674
1675int resolve_remote_symref(struct ref *ref, struct ref *list)
1676{
1677        if (!ref->symref)
1678                return 0;
1679        for (; list; list = list->next)
1680                if (!strcmp(ref->symref, list->name)) {
1681                        hashcpy(ref->old_sha1, list->old_sha1);
1682                        return 0;
1683                }
1684        return 1;
1685}
1686
1687static void unmark_and_free(struct commit_list *list, unsigned int mark)
1688{
1689        while (list) {
1690                struct commit_list *temp = list;
1691                temp->item->object.flags &= ~mark;
1692                list = temp->next;
1693                free(temp);
1694        }
1695}
1696
1697int ref_newer(const unsigned char *new_sha1, const unsigned char *old_sha1)
1698{
1699        struct object *o;
1700        struct commit *old, *new;
1701        struct commit_list *list, *used;
1702        int found = 0;
1703
1704        /*
1705         * Both new and old must be commit-ish and new is descendant of
1706         * old.  Otherwise we require --force.
1707         */
1708        o = deref_tag(parse_object(old_sha1), NULL, 0);
1709        if (!o || o->type != OBJ_COMMIT)
1710                return 0;
1711        old = (struct commit *) o;
1712
1713        o = deref_tag(parse_object(new_sha1), NULL, 0);
1714        if (!o || o->type != OBJ_COMMIT)
1715                return 0;
1716        new = (struct commit *) o;
1717
1718        if (parse_commit(new) < 0)
1719                return 0;
1720
1721        used = list = NULL;
1722        commit_list_insert(new, &list);
1723        while (list) {
1724                new = pop_most_recent_commit(&list, TMP_MARK);
1725                commit_list_insert(new, &used);
1726                if (new == old) {
1727                        found = 1;
1728                        break;
1729                }
1730        }
1731        unmark_and_free(list, TMP_MARK);
1732        unmark_and_free(used, TMP_MARK);
1733        return found;
1734}
1735
1736/*
1737 * Compare a branch with its upstream, and save their differences (number
1738 * of commits) in *num_ours and *num_theirs.
1739 *
1740 * Return 0 if branch has no upstream (no base), -1 if upstream is missing
1741 * (with "gone" base), otherwise 1 (with base).
1742 */
1743int stat_tracking_info(struct branch *branch, int *num_ours, int *num_theirs)
1744{
1745        unsigned char sha1[20];
1746        struct commit *ours, *theirs;
1747        char symmetric[84];
1748        struct rev_info revs;
1749        const char *rev_argv[10], *base;
1750        int rev_argc;
1751
1752        /* Cannot stat unless we are marked to build on top of somebody else. */
1753        if (!branch ||
1754            !branch->merge || !branch->merge[0] || !branch->merge[0]->dst)
1755                return 0;
1756
1757        /* Cannot stat if what we used to build on no longer exists */
1758        base = branch->merge[0]->dst;
1759        if (read_ref(base, sha1))
1760                return -1;
1761        theirs = lookup_commit_reference(sha1);
1762        if (!theirs)
1763                return -1;
1764
1765        if (read_ref(branch->refname, sha1))
1766                return -1;
1767        ours = lookup_commit_reference(sha1);
1768        if (!ours)
1769                return -1;
1770
1771        /* are we the same? */
1772        if (theirs == ours) {
1773                *num_theirs = *num_ours = 0;
1774                return 1;
1775        }
1776
1777        /* Run "rev-list --left-right ours...theirs" internally... */
1778        rev_argc = 0;
1779        rev_argv[rev_argc++] = NULL;
1780        rev_argv[rev_argc++] = "--left-right";
1781        rev_argv[rev_argc++] = symmetric;
1782        rev_argv[rev_argc++] = "--";
1783        rev_argv[rev_argc] = NULL;
1784
1785        strcpy(symmetric, sha1_to_hex(ours->object.sha1));
1786        strcpy(symmetric + 40, "...");
1787        strcpy(symmetric + 43, sha1_to_hex(theirs->object.sha1));
1788
1789        init_revisions(&revs, NULL);
1790        setup_revisions(rev_argc, rev_argv, &revs, NULL);
1791        prepare_revision_walk(&revs);
1792
1793        /* ... and count the commits on each side. */
1794        *num_ours = 0;
1795        *num_theirs = 0;
1796        while (1) {
1797                struct commit *c = get_revision(&revs);
1798                if (!c)
1799                        break;
1800                if (c->object.flags & SYMMETRIC_LEFT)
1801                        (*num_ours)++;
1802                else
1803                        (*num_theirs)++;
1804        }
1805
1806        /* clear object flags smudged by the above traversal */
1807        clear_commit_marks(ours, ALL_REV_FLAGS);
1808        clear_commit_marks(theirs, ALL_REV_FLAGS);
1809        return 1;
1810}
1811
1812/*
1813 * Return true when there is anything to report, otherwise false.
1814 */
1815int format_tracking_info(struct branch *branch, struct strbuf *sb)
1816{
1817        int ours, theirs;
1818        const char *base;
1819        int upstream_is_gone = 0;
1820
1821        switch (stat_tracking_info(branch, &ours, &theirs)) {
1822        case 0:
1823                /* no base */
1824                return 0;
1825        case -1:
1826                /* with "gone" base */
1827                upstream_is_gone = 1;
1828                break;
1829        default:
1830                /* with base */
1831                break;
1832        }
1833
1834        base = branch->merge[0]->dst;
1835        base = shorten_unambiguous_ref(base, 0);
1836        if (upstream_is_gone) {
1837                strbuf_addf(sb,
1838                        _("Your branch is based on '%s', but the upstream is gone.\n"),
1839                        base);
1840                if (advice_status_hints)
1841                        strbuf_addf(sb,
1842                                _("  (use \"git branch --unset-upstream\" to fixup)\n"));
1843        } else if (!ours && !theirs) {
1844                strbuf_addf(sb,
1845                        _("Your branch is up-to-date with '%s'.\n"),
1846                        base);
1847        } else if (!theirs) {
1848                strbuf_addf(sb,
1849                        Q_("Your branch is ahead of '%s' by %d commit.\n",
1850                           "Your branch is ahead of '%s' by %d commits.\n",
1851                           ours),
1852                        base, ours);
1853                if (advice_status_hints)
1854                        strbuf_addf(sb,
1855                                _("  (use \"git push\" to publish your local commits)\n"));
1856        } else if (!ours) {
1857                strbuf_addf(sb,
1858                        Q_("Your branch is behind '%s' by %d commit, "
1859                               "and can be fast-forwarded.\n",
1860                           "Your branch is behind '%s' by %d commits, "
1861                               "and can be fast-forwarded.\n",
1862                           theirs),
1863                        base, theirs);
1864                if (advice_status_hints)
1865                        strbuf_addf(sb,
1866                                _("  (use \"git pull\" to update your local branch)\n"));
1867        } else {
1868                strbuf_addf(sb,
1869                        Q_("Your branch and '%s' have diverged,\n"
1870                               "and have %d and %d different commit each, "
1871                               "respectively.\n",
1872                           "Your branch and '%s' have diverged,\n"
1873                               "and have %d and %d different commits each, "
1874                               "respectively.\n",
1875                           theirs),
1876                        base, ours, theirs);
1877                if (advice_status_hints)
1878                        strbuf_addf(sb,
1879                                _("  (use \"git pull\" to merge the remote branch into yours)\n"));
1880        }
1881        return 1;
1882}
1883
1884static int one_local_ref(const char *refname, const unsigned char *sha1, int flag, void *cb_data)
1885{
1886        struct ref ***local_tail = cb_data;
1887        struct ref *ref;
1888        int len;
1889
1890        /* we already know it starts with refs/ to get here */
1891        if (check_refname_format(refname + 5, 0))
1892                return 0;
1893
1894        len = strlen(refname) + 1;
1895        ref = xcalloc(1, sizeof(*ref) + len);
1896        hashcpy(ref->new_sha1, sha1);
1897        memcpy(ref->name, refname, len);
1898        **local_tail = ref;
1899        *local_tail = &ref->next;
1900        return 0;
1901}
1902
1903struct ref *get_local_heads(void)
1904{
1905        struct ref *local_refs = NULL, **local_tail = &local_refs;
1906        for_each_ref(one_local_ref, &local_tail);
1907        return local_refs;
1908}
1909
1910struct ref *guess_remote_head(const struct ref *head,
1911                              const struct ref *refs,
1912                              int all)
1913{
1914        const struct ref *r;
1915        struct ref *list = NULL;
1916        struct ref **tail = &list;
1917
1918        if (!head)
1919                return NULL;
1920
1921        /*
1922         * Some transports support directly peeking at
1923         * where HEAD points; if that is the case, then
1924         * we don't have to guess.
1925         */
1926        if (head->symref)
1927                return copy_ref(find_ref_by_name(refs, head->symref));
1928
1929        /* If refs/heads/master could be right, it is. */
1930        if (!all) {
1931                r = find_ref_by_name(refs, "refs/heads/master");
1932                if (r && !hashcmp(r->old_sha1, head->old_sha1))
1933                        return copy_ref(r);
1934        }
1935
1936        /* Look for another ref that points there */
1937        for (r = refs; r; r = r->next) {
1938                if (r != head &&
1939                    !prefixcmp(r->name, "refs/heads/") &&
1940                    !hashcmp(r->old_sha1, head->old_sha1)) {
1941                        *tail = copy_ref(r);
1942                        tail = &((*tail)->next);
1943                        if (!all)
1944                                break;
1945                }
1946        }
1947
1948        return list;
1949}
1950
1951struct stale_heads_info {
1952        struct string_list *ref_names;
1953        struct ref **stale_refs_tail;
1954        struct refspec *refs;
1955        int ref_count;
1956};
1957
1958static int get_stale_heads_cb(const char *refname,
1959        const unsigned char *sha1, int flags, void *cb_data)
1960{
1961        struct stale_heads_info *info = cb_data;
1962        struct refspec query;
1963        memset(&query, 0, sizeof(struct refspec));
1964        query.dst = (char *)refname;
1965
1966        if (query_refspecs(info->refs, info->ref_count, &query))
1967                return 0; /* No matches */
1968
1969        /*
1970         * If we did find a suitable refspec and it's not a symref and
1971         * it's not in the list of refs that currently exist in that
1972         * remote we consider it to be stale.
1973         */
1974        if (!((flags & REF_ISSYMREF) ||
1975              string_list_has_string(info->ref_names, query.src))) {
1976                struct ref *ref = make_linked_ref(refname, &info->stale_refs_tail);
1977                hashcpy(ref->new_sha1, sha1);
1978        }
1979
1980        free(query.src);
1981        return 0;
1982}
1983
1984struct ref *get_stale_heads(struct refspec *refs, int ref_count, struct ref *fetch_map)
1985{
1986        struct ref *ref, *stale_refs = NULL;
1987        struct string_list ref_names = STRING_LIST_INIT_NODUP;
1988        struct stale_heads_info info;
1989        info.ref_names = &ref_names;
1990        info.stale_refs_tail = &stale_refs;
1991        info.refs = refs;
1992        info.ref_count = ref_count;
1993        for (ref = fetch_map; ref; ref = ref->next)
1994                string_list_append(&ref_names, ref->name);
1995        sort_string_list(&ref_names);
1996        for_each_ref(get_stale_heads_cb, &info);
1997        string_list_clear(&ref_names, 0);
1998        return stale_refs;
1999}
2000
2001/*
2002 * Compare-and-swap
2003 */
2004void clear_cas_option(struct push_cas_option *cas)
2005{
2006        int i;
2007
2008        for (i = 0; i < cas->nr; i++)
2009                free(cas->entry[i].refname);
2010        free(cas->entry);
2011        memset(cas, 0, sizeof(*cas));
2012}
2013
2014static struct push_cas *add_cas_entry(struct push_cas_option *cas,
2015                                      const char *refname,
2016                                      size_t refnamelen)
2017{
2018        struct push_cas *entry;
2019        ALLOC_GROW(cas->entry, cas->nr + 1, cas->alloc);
2020        entry = &cas->entry[cas->nr++];
2021        memset(entry, 0, sizeof(*entry));
2022        entry->refname = xmemdupz(refname, refnamelen);
2023        return entry;
2024}
2025
2026int parse_push_cas_option(struct push_cas_option *cas, const char *arg, int unset)
2027{
2028        const char *colon;
2029        struct push_cas *entry;
2030
2031        if (unset) {
2032                /* "--no-<option>" */
2033                clear_cas_option(cas);
2034                return 0;
2035        }
2036
2037        if (!arg) {
2038                /* just "--<option>" */
2039                cas->use_tracking_for_rest = 1;
2040                return 0;
2041        }
2042
2043        /* "--<option>=refname" or "--<option>=refname:value" */
2044        colon = strchrnul(arg, ':');
2045        entry = add_cas_entry(cas, arg, colon - arg);
2046        if (!*colon)
2047                entry->use_tracking = 1;
2048        else if (get_sha1(colon + 1, entry->expect))
2049                return error("cannot parse expected object name '%s'", colon + 1);
2050        return 0;
2051}
2052
2053int parseopt_push_cas_option(const struct option *opt, const char *arg, int unset)
2054{
2055        return parse_push_cas_option(opt->value, arg, unset);
2056}
2057
2058int is_empty_cas(const struct push_cas_option *cas)
2059{
2060        return !cas->use_tracking_for_rest && !cas->nr;
2061}
2062
2063/*
2064 * Look at remote.fetch refspec and see if we have a remote
2065 * tracking branch for the refname there.  Fill its current
2066 * value in sha1[].
2067 * If we cannot do so, return negative to signal an error.
2068 */
2069static int remote_tracking(struct remote *remote, const char *refname,
2070                           unsigned char sha1[20])
2071{
2072        char *dst;
2073
2074        dst = apply_refspecs(remote->fetch, remote->fetch_refspec_nr, refname);
2075        if (!dst)
2076                return -1; /* no tracking ref for refname at remote */
2077        if (read_ref(dst, sha1))
2078                return -1; /* we know what the tracking ref is but we cannot read it */
2079        return 0;
2080}
2081
2082static void apply_cas(struct push_cas_option *cas,
2083                      struct remote *remote,
2084                      struct ref *ref)
2085{
2086        int i;
2087
2088        /* Find an explicit --<option>=<name>[:<value>] entry */
2089        for (i = 0; i < cas->nr; i++) {
2090                struct push_cas *entry = &cas->entry[i];
2091                if (!refname_match(entry->refname, ref->name, ref_rev_parse_rules))
2092                        continue;
2093                ref->expect_old_sha1 = 1;
2094                if (!entry->use_tracking)
2095                        hashcpy(ref->old_sha1_expect, cas->entry[i].expect);
2096                else if (remote_tracking(remote, ref->name, ref->old_sha1_expect))
2097                        ref->expect_old_no_trackback = 1;
2098                return;
2099        }
2100
2101        /* Are we using "--<option>" to cover all? */
2102        if (!cas->use_tracking_for_rest)
2103                return;
2104
2105        ref->expect_old_sha1 = 1;
2106        if (remote_tracking(remote, ref->name, ref->old_sha1_expect))
2107                ref->expect_old_no_trackback = 1;
2108}
2109
2110void apply_push_cas(struct push_cas_option *cas,
2111                    struct remote *remote,
2112                    struct ref *remote_refs)
2113{
2114        struct ref *ref;
2115        for (ref = remote_refs; ref; ref = ref->next)
2116                apply_cas(cas, remote, ref);
2117}