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