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