Andrew's git / gitweb.git / builtin/push.c
?
builtin / push.con commit fsck: detect trailing garbage in all object types (cce044d)
   1/*
   2 * "git push"
   3 */
   4#include "cache.h"
   5#include "refs.h"
   6#include "run-command.h"
   7#include "builtin.h"
   8#include "remote.h"
   9#include "transport.h"
  10#include "parse-options.h"
  11#include "submodule.h"
  12#include "submodule-config.h"
  13#include "send-pack.h"
  14
  15static const char * const push_usage[] = {
  16        N_("git push [<options>] [<repository> [<refspec>...]]"),
  17        NULL,
  18};
  19
  20static int thin = 1;
  21static int deleterefs;
  22static const char *receivepack;
  23static int verbosity;
  24static int progress = -1;
  25static int recurse_submodules = RECURSE_SUBMODULES_DEFAULT;
  26static enum transport_family family;
  27
  28static struct push_cas_option cas;
  29
  30static const char **refspec;
  31static int refspec_nr;
  32static int refspec_alloc;
  33
  34static void add_refspec(const char *ref)
  35{
  36        refspec_nr++;
  37        ALLOC_GROW(refspec, refspec_nr, refspec_alloc);
  38        refspec[refspec_nr-1] = ref;
  39}
  40
  41static const char *map_refspec(const char *ref,
  42                               struct remote *remote, struct ref *local_refs)
  43{
  44        struct ref *matched = NULL;
  45
  46        /* Does "ref" uniquely name our ref? */
  47        if (count_refspec_match(ref, local_refs, &matched) != 1)
  48                return ref;
  49
  50        if (remote->push) {
  51                struct refspec query;
  52                memset(&query, 0, sizeof(struct refspec));
  53                query.src = matched->name;
  54                if (!query_refspecs(remote->push, remote->push_refspec_nr, &query) &&
  55                    query.dst) {
  56                        struct strbuf buf = STRBUF_INIT;
  57                        strbuf_addf(&buf, "%s%s:%s",
  58                                    query.force ? "+" : "",
  59                                    query.src, query.dst);
  60                        return strbuf_detach(&buf, NULL);
  61                }
  62        }
  63
  64        if (push_default == PUSH_DEFAULT_UPSTREAM &&
  65            starts_with(matched->name, "refs/heads/")) {
  66                struct branch *branch = branch_get(matched->name + 11);
  67                if (branch->merge_nr == 1 && branch->merge[0]->src) {
  68                        struct strbuf buf = STRBUF_INIT;
  69                        strbuf_addf(&buf, "%s:%s",
  70                                    ref, branch->merge[0]->src);
  71                        return strbuf_detach(&buf, NULL);
  72                }
  73        }
  74
  75        return ref;
  76}
  77
  78static void set_refspecs(const char **refs, int nr, const char *repo)
  79{
  80        struct remote *remote = NULL;
  81        struct ref *local_refs = NULL;
  82        int i;
  83
  84        for (i = 0; i < nr; i++) {
  85                const char *ref = refs[i];
  86                if (!strcmp("tag", ref)) {
  87                        struct strbuf tagref = STRBUF_INIT;
  88                        if (nr <= ++i)
  89                                die(_("tag shorthand without <tag>"));
  90                        ref = refs[i];
  91                        if (deleterefs)
  92                                strbuf_addf(&tagref, ":refs/tags/%s", ref);
  93                        else
  94                                strbuf_addf(&tagref, "refs/tags/%s", ref);
  95                        ref = strbuf_detach(&tagref, NULL);
  96                } else if (deleterefs) {
  97                        struct strbuf delref = STRBUF_INIT;
  98                        if (strchr(ref, ':'))
  99                                die(_("--delete only accepts plain target ref names"));
 100                        strbuf_addf(&delref, ":%s", ref);
 101                        ref = strbuf_detach(&delref, NULL);
 102                } else if (!strchr(ref, ':')) {
 103                        if (!remote) {
 104                                /* lazily grab remote and local_refs */
 105                                remote = remote_get(repo);
 106                                local_refs = get_local_heads();
 107                        }
 108                        ref = map_refspec(ref, remote, local_refs);
 109                }
 110                add_refspec(ref);
 111        }
 112}
 113
 114static int push_url_of_remote(struct remote *remote, const char ***url_p)
 115{
 116        if (remote->pushurl_nr) {
 117                *url_p = remote->pushurl;
 118                return remote->pushurl_nr;
 119        }
 120        *url_p = remote->url;
 121        return remote->url_nr;
 122}
 123
 124static NORETURN int die_push_simple(struct branch *branch, struct remote *remote) {
 125        /*
 126         * There's no point in using shorten_unambiguous_ref here,
 127         * as the ambiguity would be on the remote side, not what
 128         * we have locally. Plus, this is supposed to be the simple
 129         * mode. If the user is doing something crazy like setting
 130         * upstream to a non-branch, we should probably be showing
 131         * them the big ugly fully qualified ref.
 132         */
 133        const char *advice_maybe = "";
 134        const char *short_upstream = branch->merge[0]->src;
 135
 136        skip_prefix(short_upstream, "refs/heads/", &short_upstream);
 137
 138        /*
 139         * Don't show advice for people who explicitly set
 140         * push.default.
 141         */
 142        if (push_default == PUSH_DEFAULT_UNSPECIFIED)
 143                advice_maybe = _("\n"
 144                                 "To choose either option permanently, "
 145                                 "see push.default in 'git help config'.");
 146        die(_("The upstream branch of your current branch does not match\n"
 147              "the name of your current branch.  To push to the upstream branch\n"
 148              "on the remote, use\n"
 149              "\n"
 150              "    git push %s HEAD:%s\n"
 151              "\n"
 152              "To push to the branch of the same name on the remote, use\n"
 153              "\n"
 154              "    git push %s %s\n"
 155              "%s"),
 156            remote->name, short_upstream,
 157            remote->name, branch->name, advice_maybe);
 158}
 159
 160static const char message_detached_head_die[] =
 161        N_("You are not currently on a branch.\n"
 162           "To push the history leading to the current (detached HEAD)\n"
 163           "state now, use\n"
 164           "\n"
 165           "    git push %s HEAD:<name-of-remote-branch>\n");
 166
 167static void setup_push_upstream(struct remote *remote, struct branch *branch,
 168                                int triangular, int simple)
 169{
 170        struct strbuf refspec = STRBUF_INIT;
 171
 172        if (!branch)
 173                die(_(message_detached_head_die), remote->name);
 174        if (!branch->merge_nr || !branch->merge || !branch->remote_name)
 175                die(_("The current branch %s has no upstream branch.\n"
 176                    "To push the current branch and set the remote as upstream, use\n"
 177                    "\n"
 178                    "    git push --set-upstream %s %s\n"),
 179                    branch->name,
 180                    remote->name,
 181                    branch->name);
 182        if (branch->merge_nr != 1)
 183                die(_("The current branch %s has multiple upstream branches, "
 184                    "refusing to push."), branch->name);
 185        if (triangular)
 186                die(_("You are pushing to remote '%s', which is not the upstream of\n"
 187                      "your current branch '%s', without telling me what to push\n"
 188                      "to update which remote branch."),
 189                    remote->name, branch->name);
 190
 191        if (simple) {
 192                /* Additional safety */
 193                if (strcmp(branch->refname, branch->merge[0]->src))
 194                        die_push_simple(branch, remote);
 195        }
 196
 197        strbuf_addf(&refspec, "%s:%s", branch->name, branch->merge[0]->src);
 198        add_refspec(refspec.buf);
 199}
 200
 201static void setup_push_current(struct remote *remote, struct branch *branch)
 202{
 203        if (!branch)
 204                die(_(message_detached_head_die), remote->name);
 205        add_refspec(branch->name);
 206}
 207
 208static int is_workflow_triangular(struct remote *remote)
 209{
 210        struct remote *fetch_remote = remote_get(NULL);
 211        return (fetch_remote && fetch_remote != remote);
 212}
 213
 214static void setup_default_push_refspecs(struct remote *remote)
 215{
 216        struct branch *branch = branch_get(NULL);
 217        int triangular = is_workflow_triangular(remote);
 218
 219        switch (push_default) {
 220        default:
 221        case PUSH_DEFAULT_MATCHING:
 222                add_refspec(":");
 223                break;
 224
 225        case PUSH_DEFAULT_UNSPECIFIED:
 226        case PUSH_DEFAULT_SIMPLE:
 227                if (triangular)
 228                        setup_push_current(remote, branch);
 229                else
 230                        setup_push_upstream(remote, branch, triangular, 1);
 231                break;
 232
 233        case PUSH_DEFAULT_UPSTREAM:
 234                setup_push_upstream(remote, branch, triangular, 0);
 235                break;
 236
 237        case PUSH_DEFAULT_CURRENT:
 238                setup_push_current(remote, branch);
 239                break;
 240
 241        case PUSH_DEFAULT_NOTHING:
 242                die(_("You didn't specify any refspecs to push, and "
 243                    "push.default is \"nothing\"."));
 244                break;
 245        }
 246}
 247
 248static const char message_advice_pull_before_push[] =
 249        N_("Updates were rejected because the tip of your current branch is behind\n"
 250           "its remote counterpart. Integrate the remote changes (e.g.\n"
 251           "'git pull ...') before pushing again.\n"
 252           "See the 'Note about fast-forwards' in 'git push --help' for details.");
 253
 254static const char message_advice_checkout_pull_push[] =
 255        N_("Updates were rejected because a pushed branch tip is behind its remote\n"
 256           "counterpart. Check out this branch and integrate the remote changes\n"
 257           "(e.g. 'git pull ...') before pushing again.\n"
 258           "See the 'Note about fast-forwards' in 'git push --help' for details.");
 259
 260static const char message_advice_ref_fetch_first[] =
 261        N_("Updates were rejected because the remote contains work that you do\n"
 262           "not have locally. This is usually caused by another repository pushing\n"
 263           "to the same ref. You may want to first integrate the remote changes\n"
 264           "(e.g., 'git pull ...') before pushing again.\n"
 265           "See the 'Note about fast-forwards' in 'git push --help' for details.");
 266
 267static const char message_advice_ref_already_exists[] =
 268        N_("Updates were rejected because the tag already exists in the remote.");
 269
 270static const char message_advice_ref_needs_force[] =
 271        N_("You cannot update a remote ref that points at a non-commit object,\n"
 272           "or update a remote ref to make it point at a non-commit object,\n"
 273           "without using the '--force' option.\n");
 274
 275static void advise_pull_before_push(void)
 276{
 277        if (!advice_push_non_ff_current || !advice_push_update_rejected)
 278                return;
 279        advise(_(message_advice_pull_before_push));
 280}
 281
 282static void advise_checkout_pull_push(void)
 283{
 284        if (!advice_push_non_ff_matching || !advice_push_update_rejected)
 285                return;
 286        advise(_(message_advice_checkout_pull_push));
 287}
 288
 289static void advise_ref_already_exists(void)
 290{
 291        if (!advice_push_already_exists || !advice_push_update_rejected)
 292                return;
 293        advise(_(message_advice_ref_already_exists));
 294}
 295
 296static void advise_ref_fetch_first(void)
 297{
 298        if (!advice_push_fetch_first || !advice_push_update_rejected)
 299                return;
 300        advise(_(message_advice_ref_fetch_first));
 301}
 302
 303static void advise_ref_needs_force(void)
 304{
 305        if (!advice_push_needs_force || !advice_push_update_rejected)
 306                return;
 307        advise(_(message_advice_ref_needs_force));
 308}
 309
 310static int push_with_options(struct transport *transport, int flags)
 311{
 312        int err;
 313        unsigned int reject_reasons;
 314
 315        transport_set_verbosity(transport, verbosity, progress);
 316        transport->family = family;
 317
 318        if (receivepack)
 319                transport_set_option(transport,
 320                                     TRANS_OPT_RECEIVEPACK, receivepack);
 321        transport_set_option(transport, TRANS_OPT_THIN, thin ? "yes" : NULL);
 322
 323        if (!is_empty_cas(&cas)) {
 324                if (!transport->smart_options)
 325                        die("underlying transport does not support --%s option",
 326                            CAS_OPT_NAME);
 327                transport->smart_options->cas = &cas;
 328        }
 329
 330        if (verbosity > 0)
 331                fprintf(stderr, _("Pushing to %s\n"), transport->url);
 332        err = transport_push(transport, refspec_nr, refspec, flags,
 333                             &reject_reasons);
 334        if (err != 0)
 335                error(_("failed to push some refs to '%s'"), transport->url);
 336
 337        err |= transport_disconnect(transport);
 338        if (!err)
 339                return 0;
 340
 341        if (reject_reasons & REJECT_NON_FF_HEAD) {
 342                advise_pull_before_push();
 343        } else if (reject_reasons & REJECT_NON_FF_OTHER) {
 344                advise_checkout_pull_push();
 345        } else if (reject_reasons & REJECT_ALREADY_EXISTS) {
 346                advise_ref_already_exists();
 347        } else if (reject_reasons & REJECT_FETCH_FIRST) {
 348                advise_ref_fetch_first();
 349        } else if (reject_reasons & REJECT_NEEDS_FORCE) {
 350                advise_ref_needs_force();
 351        }
 352
 353        return 1;
 354}
 355
 356static int do_push(const char *repo, int flags,
 357                   const struct string_list *push_options)
 358{
 359        int i, errs;
 360        struct remote *remote = pushremote_get(repo);
 361        const char **url;
 362        int url_nr;
 363
 364        if (!remote) {
 365                if (repo)
 366                        die(_("bad repository '%s'"), repo);
 367                die(_("No configured push destination.\n"
 368                    "Either specify the URL from the command-line or configure a remote repository using\n"
 369                    "\n"
 370                    "    git remote add <name> <url>\n"
 371                    "\n"
 372                    "and then push using the remote name\n"
 373                    "\n"
 374                    "    git push <name>\n"));
 375        }
 376
 377        if (remote->mirror)
 378                flags |= (TRANSPORT_PUSH_MIRROR|TRANSPORT_PUSH_FORCE);
 379
 380        if (push_options->nr)
 381                flags |= TRANSPORT_PUSH_OPTIONS;
 382
 383        if ((flags & TRANSPORT_PUSH_ALL) && refspec) {
 384                if (!strcmp(*refspec, "refs/tags/*"))
 385                        return error(_("--all and --tags are incompatible"));
 386                return error(_("--all can't be combined with refspecs"));
 387        }
 388
 389        if ((flags & TRANSPORT_PUSH_MIRROR) && refspec) {
 390                if (!strcmp(*refspec, "refs/tags/*"))
 391                        return error(_("--mirror and --tags are incompatible"));
 392                return error(_("--mirror can't be combined with refspecs"));
 393        }
 394
 395        if ((flags & (TRANSPORT_PUSH_ALL|TRANSPORT_PUSH_MIRROR)) ==
 396                                (TRANSPORT_PUSH_ALL|TRANSPORT_PUSH_MIRROR)) {
 397                return error(_("--all and --mirror are incompatible"));
 398        }
 399
 400        if (!refspec && !(flags & TRANSPORT_PUSH_ALL)) {
 401                if (remote->push_refspec_nr) {
 402                        refspec = remote->push_refspec;
 403                        refspec_nr = remote->push_refspec_nr;
 404                } else if (!(flags & TRANSPORT_PUSH_MIRROR))
 405                        setup_default_push_refspecs(remote);
 406        }
 407        errs = 0;
 408        url_nr = push_url_of_remote(remote, &url);
 409        if (url_nr) {
 410                for (i = 0; i < url_nr; i++) {
 411                        struct transport *transport =
 412                                transport_get(remote, url[i]);
 413                        if (flags & TRANSPORT_PUSH_OPTIONS)
 414                                transport->push_options = push_options;
 415                        if (push_with_options(transport, flags))
 416                                errs++;
 417                }
 418        } else {
 419                struct transport *transport =
 420                        transport_get(remote, NULL);
 421                if (flags & TRANSPORT_PUSH_OPTIONS)
 422                        transport->push_options = push_options;
 423                if (push_with_options(transport, flags))
 424                        errs++;
 425        }
 426        return !!errs;
 427}
 428
 429static int option_parse_recurse_submodules(const struct option *opt,
 430                                   const char *arg, int unset)
 431{
 432        int *recurse_submodules = opt->value;
 433
 434        if (unset)
 435                *recurse_submodules = RECURSE_SUBMODULES_OFF;
 436        else if (arg)
 437                *recurse_submodules = parse_push_recurse_submodules_arg(opt->long_name, arg);
 438        else
 439                die("%s missing parameter", opt->long_name);
 440
 441        return 0;
 442}
 443
 444static void set_push_cert_flags(int *flags, int v)
 445{
 446        switch (v) {
 447        case SEND_PACK_PUSH_CERT_NEVER:
 448                *flags &= ~(TRANSPORT_PUSH_CERT_ALWAYS | TRANSPORT_PUSH_CERT_IF_ASKED);
 449                break;
 450        case SEND_PACK_PUSH_CERT_ALWAYS:
 451                *flags |= TRANSPORT_PUSH_CERT_ALWAYS;
 452                *flags &= ~TRANSPORT_PUSH_CERT_IF_ASKED;
 453                break;
 454        case SEND_PACK_PUSH_CERT_IF_ASKED:
 455                *flags |= TRANSPORT_PUSH_CERT_IF_ASKED;
 456                *flags &= ~TRANSPORT_PUSH_CERT_ALWAYS;
 457                break;
 458        }
 459}
 460
 461
 462static int git_push_config(const char *k, const char *v, void *cb)
 463{
 464        int *flags = cb;
 465        int status;
 466
 467        status = git_gpg_config(k, v, NULL);
 468        if (status)
 469                return status;
 470
 471        if (!strcmp(k, "push.followtags")) {
 472                if (git_config_bool(k, v))
 473                        *flags |= TRANSPORT_PUSH_FOLLOW_TAGS;
 474                else
 475                        *flags &= ~TRANSPORT_PUSH_FOLLOW_TAGS;
 476                return 0;
 477        } else if (!strcmp(k, "push.gpgsign")) {
 478                const char *value;
 479                if (!git_config_get_value("push.gpgsign", &value)) {
 480                        switch (git_config_maybe_bool("push.gpgsign", value)) {
 481                        case 0:
 482                                set_push_cert_flags(flags, SEND_PACK_PUSH_CERT_NEVER);
 483                                break;
 484                        case 1:
 485                                set_push_cert_flags(flags, SEND_PACK_PUSH_CERT_ALWAYS);
 486                                break;
 487                        default:
 488                                if (value && !strcasecmp(value, "if-asked"))
 489                                        set_push_cert_flags(flags, SEND_PACK_PUSH_CERT_IF_ASKED);
 490                                else
 491                                        return error("Invalid value for '%s'", k);
 492                        }
 493                }
 494        } else if (!strcmp(k, "push.recursesubmodules")) {
 495                const char *value;
 496                if (!git_config_get_value("push.recursesubmodules", &value))
 497                        recurse_submodules = parse_push_recurse_submodules_arg(k, value);
 498        }
 499
 500        return git_default_config(k, v, NULL);
 501}
 502
 503int cmd_push(int argc, const char **argv, const char *prefix)
 504{
 505        int flags = 0;
 506        int tags = 0;
 507        int push_cert = -1;
 508        int rc;
 509        const char *repo = NULL;        /* default repository */
 510        static struct string_list push_options = STRING_LIST_INIT_DUP;
 511        static struct string_list_item *item;
 512
 513        struct option options[] = {
 514                OPT__VERBOSITY(&verbosity),
 515                OPT_STRING( 0 , "repo", &repo, N_("repository"), N_("repository")),
 516                OPT_BIT( 0 , "all", &flags, N_("push all refs"), TRANSPORT_PUSH_ALL),
 517                OPT_BIT( 0 , "mirror", &flags, N_("mirror all refs"),
 518                            (TRANSPORT_PUSH_MIRROR|TRANSPORT_PUSH_FORCE)),
 519                OPT_BOOL('d', "delete", &deleterefs, N_("delete refs")),
 520                OPT_BOOL( 0 , "tags", &tags, N_("push tags (can't be used with --all or --mirror)")),
 521                OPT_BIT('n' , "dry-run", &flags, N_("dry run"), TRANSPORT_PUSH_DRY_RUN),
 522                OPT_BIT( 0,  "porcelain", &flags, N_("machine-readable output"), TRANSPORT_PUSH_PORCELAIN),
 523                OPT_BIT('f', "force", &flags, N_("force updates"), TRANSPORT_PUSH_FORCE),
 524                { OPTION_CALLBACK,
 525                  0, CAS_OPT_NAME, &cas, N_("refname>:<expect"),
 526                  N_("require old value of ref to be at this value"),
 527                  PARSE_OPT_OPTARG, parseopt_push_cas_option },
 528                { OPTION_CALLBACK, 0, "recurse-submodules", &recurse_submodules, "check|on-demand|no",
 529                        N_("control recursive pushing of submodules"),
 530                        PARSE_OPT_OPTARG, option_parse_recurse_submodules },
 531                OPT_BOOL( 0 , "thin", &thin, N_("use thin pack")),
 532                OPT_STRING( 0 , "receive-pack", &receivepack, "receive-pack", N_("receive pack program")),
 533                OPT_STRING( 0 , "exec", &receivepack, "receive-pack", N_("receive pack program")),
 534                OPT_BIT('u', "set-upstream", &flags, N_("set upstream for git pull/status"),
 535                        TRANSPORT_PUSH_SET_UPSTREAM),
 536                OPT_BOOL(0, "progress", &progress, N_("force progress reporting")),
 537                OPT_BIT(0, "prune", &flags, N_("prune locally removed refs"),
 538                        TRANSPORT_PUSH_PRUNE),
 539                OPT_BIT(0, "no-verify", &flags, N_("bypass pre-push hook"), TRANSPORT_PUSH_NO_HOOK),
 540                OPT_BIT(0, "follow-tags", &flags, N_("push missing but relevant tags"),
 541                        TRANSPORT_PUSH_FOLLOW_TAGS),
 542                { OPTION_CALLBACK,
 543                  0, "signed", &push_cert, "yes|no|if-asked", N_("GPG sign the push"),
 544                  PARSE_OPT_OPTARG, option_parse_push_signed },
 545                OPT_BIT(0, "atomic", &flags, N_("request atomic transaction on remote side"), TRANSPORT_PUSH_ATOMIC),
 546                OPT_STRING_LIST('o', "push-option", &push_options, N_("server-specific"), N_("option to transmit")),
 547                OPT_SET_INT('4', "ipv4", &family, N_("use IPv4 addresses only"),
 548                                TRANSPORT_FAMILY_IPV4),
 549                OPT_SET_INT('6', "ipv6", &family, N_("use IPv6 addresses only"),
 550                                TRANSPORT_FAMILY_IPV6),
 551                OPT_END()
 552        };
 553
 554        packet_trace_identity("push");
 555        git_config(git_push_config, &flags);
 556        argc = parse_options(argc, argv, prefix, options, push_usage, 0);
 557        set_push_cert_flags(&flags, push_cert);
 558
 559        if (deleterefs && (tags || (flags & (TRANSPORT_PUSH_ALL | TRANSPORT_PUSH_MIRROR))))
 560                die(_("--delete is incompatible with --all, --mirror and --tags"));
 561        if (deleterefs && argc < 2)
 562                die(_("--delete doesn't make sense without any refs"));
 563
 564        if (recurse_submodules == RECURSE_SUBMODULES_CHECK)
 565                flags |= TRANSPORT_RECURSE_SUBMODULES_CHECK;
 566        else if (recurse_submodules == RECURSE_SUBMODULES_ON_DEMAND)
 567                flags |= TRANSPORT_RECURSE_SUBMODULES_ON_DEMAND;
 568
 569        if (tags)
 570                add_refspec("refs/tags/*");
 571
 572        if (argc > 0) {
 573                repo = argv[0];
 574                set_refspecs(argv + 1, argc - 1, repo);
 575        }
 576
 577        for_each_string_list_item(item, &push_options)
 578                if (strchr(item->string, '\n'))
 579                        die(_("push options must not have new line characters"));
 580
 581        rc = do_push(repo, flags, &push_options);
 582        if (rc == -1)
 583                usage_with_options(push_usage, options);
 584        else
 585                return rc;
 586}