Andrew's git / gitweb.git / builtin/push.c
?
builtin / push.con commit diff.c: convert -U|--unified (d473e2e)
   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(the_repository, transport,
 361                             rs, flags, &reject_reasons);
 362        if (err != 0) {
 363                fprintf(stderr, "%s", push_get_color(PUSH_COLOR_ERROR));
 364                error(_("failed to push some refs to '%s'"), transport->url);
 365                fprintf(stderr, "%s", push_get_color(PUSH_COLOR_RESET));
 366        }
 367
 368        err |= transport_disconnect(transport);
 369        if (!err)
 370                return 0;
 371
 372        if (reject_reasons & REJECT_NON_FF_HEAD) {
 373                advise_pull_before_push();
 374        } else if (reject_reasons & REJECT_NON_FF_OTHER) {
 375                advise_checkout_pull_push();
 376        } else if (reject_reasons & REJECT_ALREADY_EXISTS) {
 377                advise_ref_already_exists();
 378        } else if (reject_reasons & REJECT_FETCH_FIRST) {
 379                advise_ref_fetch_first();
 380        } else if (reject_reasons & REJECT_NEEDS_FORCE) {
 381                advise_ref_needs_force();
 382        }
 383
 384        return 1;
 385}
 386
 387static int do_push(const char *repo, int flags,
 388                   const struct string_list *push_options)
 389{
 390        int i, errs;
 391        struct remote *remote = pushremote_get(repo);
 392        const char **url;
 393        int url_nr;
 394        struct refspec *push_refspec = &rs;
 395
 396        if (!remote) {
 397                if (repo)
 398                        die(_("bad repository '%s'"), repo);
 399                die(_("No configured push destination.\n"
 400                    "Either specify the URL from the command-line or configure a remote repository using\n"
 401                    "\n"
 402                    "    git remote add <name> <url>\n"
 403                    "\n"
 404                    "and then push using the remote name\n"
 405                    "\n"
 406                    "    git push <name>\n"));
 407        }
 408
 409        if (remote->mirror)
 410                flags |= (TRANSPORT_PUSH_MIRROR|TRANSPORT_PUSH_FORCE);
 411
 412        if (push_options->nr)
 413                flags |= TRANSPORT_PUSH_OPTIONS;
 414
 415        if (!push_refspec->nr && !(flags & TRANSPORT_PUSH_ALL)) {
 416                if (remote->push.nr) {
 417                        push_refspec = &remote->push;
 418                } else if (!(flags & TRANSPORT_PUSH_MIRROR))
 419                        setup_default_push_refspecs(remote);
 420        }
 421        errs = 0;
 422        url_nr = push_url_of_remote(remote, &url);
 423        if (url_nr) {
 424                for (i = 0; i < url_nr; i++) {
 425                        struct transport *transport =
 426                                transport_get(remote, url[i]);
 427                        if (flags & TRANSPORT_PUSH_OPTIONS)
 428                                transport->push_options = push_options;
 429                        if (push_with_options(transport, push_refspec, flags))
 430                                errs++;
 431                }
 432        } else {
 433                struct transport *transport =
 434                        transport_get(remote, NULL);
 435                if (flags & TRANSPORT_PUSH_OPTIONS)
 436                        transport->push_options = push_options;
 437                if (push_with_options(transport, push_refspec, flags))
 438                        errs++;
 439        }
 440        return !!errs;
 441}
 442
 443static int option_parse_recurse_submodules(const struct option *opt,
 444                                   const char *arg, int unset)
 445{
 446        int *recurse_submodules = opt->value;
 447
 448        if (unset)
 449                *recurse_submodules = RECURSE_SUBMODULES_OFF;
 450        else if (arg)
 451                *recurse_submodules = parse_push_recurse_submodules_arg(opt->long_name, arg);
 452        else
 453                die("%s missing parameter", opt->long_name);
 454
 455        return 0;
 456}
 457
 458static void set_push_cert_flags(int *flags, int v)
 459{
 460        switch (v) {
 461        case SEND_PACK_PUSH_CERT_NEVER:
 462                *flags &= ~(TRANSPORT_PUSH_CERT_ALWAYS | TRANSPORT_PUSH_CERT_IF_ASKED);
 463                break;
 464        case SEND_PACK_PUSH_CERT_ALWAYS:
 465                *flags |= TRANSPORT_PUSH_CERT_ALWAYS;
 466                *flags &= ~TRANSPORT_PUSH_CERT_IF_ASKED;
 467                break;
 468        case SEND_PACK_PUSH_CERT_IF_ASKED:
 469                *flags |= TRANSPORT_PUSH_CERT_IF_ASKED;
 470                *flags &= ~TRANSPORT_PUSH_CERT_ALWAYS;
 471                break;
 472        }
 473}
 474
 475
 476static int git_push_config(const char *k, const char *v, void *cb)
 477{
 478        const char *slot_name;
 479        int *flags = cb;
 480        int status;
 481
 482        status = git_gpg_config(k, v, NULL);
 483        if (status)
 484                return status;
 485
 486        if (!strcmp(k, "push.followtags")) {
 487                if (git_config_bool(k, v))
 488                        *flags |= TRANSPORT_PUSH_FOLLOW_TAGS;
 489                else
 490                        *flags &= ~TRANSPORT_PUSH_FOLLOW_TAGS;
 491                return 0;
 492        } else if (!strcmp(k, "push.gpgsign")) {
 493                const char *value;
 494                if (!git_config_get_value("push.gpgsign", &value)) {
 495                        switch (git_parse_maybe_bool(value)) {
 496                        case 0:
 497                                set_push_cert_flags(flags, SEND_PACK_PUSH_CERT_NEVER);
 498                                break;
 499                        case 1:
 500                                set_push_cert_flags(flags, SEND_PACK_PUSH_CERT_ALWAYS);
 501                                break;
 502                        default:
 503                                if (value && !strcasecmp(value, "if-asked"))
 504                                        set_push_cert_flags(flags, SEND_PACK_PUSH_CERT_IF_ASKED);
 505                                else
 506                                        return error("Invalid value for '%s'", k);
 507                        }
 508                }
 509        } else if (!strcmp(k, "push.recursesubmodules")) {
 510                const char *value;
 511                if (!git_config_get_value("push.recursesubmodules", &value))
 512                        recurse_submodules = parse_push_recurse_submodules_arg(k, value);
 513        } else if (!strcmp(k, "submodule.recurse")) {
 514                int val = git_config_bool(k, v) ?
 515                        RECURSE_SUBMODULES_ON_DEMAND : RECURSE_SUBMODULES_OFF;
 516                recurse_submodules = val;
 517        } else if (!strcmp(k, "push.pushoption")) {
 518                if (!v)
 519                        return config_error_nonbool(k);
 520                else
 521                        if (!*v)
 522                                string_list_clear(&push_options_config, 0);
 523                        else
 524                                string_list_append(&push_options_config, v);
 525                return 0;
 526        } else if (!strcmp(k, "color.push")) {
 527                push_use_color = git_config_colorbool(k, v);
 528                return 0;
 529        } else if (skip_prefix(k, "color.push.", &slot_name)) {
 530                int slot = parse_push_color_slot(slot_name);
 531                if (slot < 0)
 532                        return 0;
 533                if (!v)
 534                        return config_error_nonbool(k);
 535                return color_parse(v, push_colors[slot]);
 536        }
 537
 538        return git_default_config(k, v, NULL);
 539}
 540
 541int cmd_push(int argc, const char **argv, const char *prefix)
 542{
 543        int flags = 0;
 544        int tags = 0;
 545        int push_cert = -1;
 546        int rc;
 547        const char *repo = NULL;        /* default repository */
 548        struct string_list push_options_cmdline = STRING_LIST_INIT_DUP;
 549        struct string_list *push_options;
 550        const struct string_list_item *item;
 551
 552        struct option options[] = {
 553                OPT__VERBOSITY(&verbosity),
 554                OPT_STRING( 0 , "repo", &repo, N_("repository"), N_("repository")),
 555                OPT_BIT( 0 , "all", &flags, N_("push all refs"), TRANSPORT_PUSH_ALL),
 556                OPT_BIT( 0 , "mirror", &flags, N_("mirror all refs"),
 557                            (TRANSPORT_PUSH_MIRROR|TRANSPORT_PUSH_FORCE)),
 558                OPT_BOOL('d', "delete", &deleterefs, N_("delete refs")),
 559                OPT_BOOL( 0 , "tags", &tags, N_("push tags (can't be used with --all or --mirror)")),
 560                OPT_BIT('n' , "dry-run", &flags, N_("dry run"), TRANSPORT_PUSH_DRY_RUN),
 561                OPT_BIT( 0,  "porcelain", &flags, N_("machine-readable output"), TRANSPORT_PUSH_PORCELAIN),
 562                OPT_BIT('f', "force", &flags, N_("force updates"), TRANSPORT_PUSH_FORCE),
 563                { OPTION_CALLBACK,
 564                  0, CAS_OPT_NAME, &cas, N_("<refname>:<expect>"),
 565                  N_("require old value of ref to be at this value"),
 566                  PARSE_OPT_OPTARG | PARSE_OPT_LITERAL_ARGHELP, parseopt_push_cas_option },
 567                { OPTION_CALLBACK, 0, "recurse-submodules", &recurse_submodules, "(check|on-demand|no)",
 568                        N_("control recursive pushing of submodules"),
 569                        PARSE_OPT_OPTARG, option_parse_recurse_submodules },
 570                OPT_BOOL_F( 0 , "thin", &thin, N_("use thin pack"), PARSE_OPT_NOCOMPLETE),
 571                OPT_STRING( 0 , "receive-pack", &receivepack, "receive-pack", N_("receive pack program")),
 572                OPT_STRING( 0 , "exec", &receivepack, "receive-pack", N_("receive pack program")),
 573                OPT_BIT('u', "set-upstream", &flags, N_("set upstream for git pull/status"),
 574                        TRANSPORT_PUSH_SET_UPSTREAM),
 575                OPT_BOOL(0, "progress", &progress, N_("force progress reporting")),
 576                OPT_BIT(0, "prune", &flags, N_("prune locally removed refs"),
 577                        TRANSPORT_PUSH_PRUNE),
 578                OPT_BIT(0, "no-verify", &flags, N_("bypass pre-push hook"), TRANSPORT_PUSH_NO_HOOK),
 579                OPT_BIT(0, "follow-tags", &flags, N_("push missing but relevant tags"),
 580                        TRANSPORT_PUSH_FOLLOW_TAGS),
 581                { OPTION_CALLBACK,
 582                  0, "signed", &push_cert, "(yes|no|if-asked)", N_("GPG sign the push"),
 583                  PARSE_OPT_OPTARG, option_parse_push_signed },
 584                OPT_BIT(0, "atomic", &flags, N_("request atomic transaction on remote side"), TRANSPORT_PUSH_ATOMIC),
 585                OPT_STRING_LIST('o', "push-option", &push_options_cmdline, N_("server-specific"), N_("option to transmit")),
 586                OPT_SET_INT('4', "ipv4", &family, N_("use IPv4 addresses only"),
 587                                TRANSPORT_FAMILY_IPV4),
 588                OPT_SET_INT('6', "ipv6", &family, N_("use IPv6 addresses only"),
 589                                TRANSPORT_FAMILY_IPV6),
 590                OPT_END()
 591        };
 592
 593        packet_trace_identity("push");
 594        git_config(git_push_config, &flags);
 595        argc = parse_options(argc, argv, prefix, options, push_usage, 0);
 596        push_options = (push_options_cmdline.nr
 597                ? &push_options_cmdline
 598                : &push_options_config);
 599        set_push_cert_flags(&flags, push_cert);
 600
 601        if (deleterefs && (tags || (flags & (TRANSPORT_PUSH_ALL | TRANSPORT_PUSH_MIRROR))))
 602                die(_("--delete is incompatible with --all, --mirror and --tags"));
 603        if (deleterefs && argc < 2)
 604                die(_("--delete doesn't make sense without any refs"));
 605        if (flags & TRANSPORT_PUSH_ALL) {
 606                if (tags)
 607                        die(_("--all and --tags are incompatible"));
 608                if (argc >= 2)
 609                        die(_("--all can't be combined with refspecs"));
 610        }
 611        if (flags & TRANSPORT_PUSH_MIRROR) {
 612                if (tags)
 613                        die(_("--mirror and --tags are incompatible"));
 614                if (argc >= 2)
 615                        die(_("--mirror can't be combined with refspecs"));
 616        }
 617        if ((flags & TRANSPORT_PUSH_ALL) && (flags & TRANSPORT_PUSH_MIRROR))
 618                die(_("--all and --mirror are incompatible"));
 619
 620        if (recurse_submodules == RECURSE_SUBMODULES_CHECK)
 621                flags |= TRANSPORT_RECURSE_SUBMODULES_CHECK;
 622        else if (recurse_submodules == RECURSE_SUBMODULES_ON_DEMAND)
 623                flags |= TRANSPORT_RECURSE_SUBMODULES_ON_DEMAND;
 624        else if (recurse_submodules == RECURSE_SUBMODULES_ONLY)
 625                flags |= TRANSPORT_RECURSE_SUBMODULES_ONLY;
 626
 627        if (tags)
 628                refspec_append(&rs, "refs/tags/*");
 629
 630        if (argc > 0) {
 631                repo = argv[0];
 632                set_refspecs(argv + 1, argc - 1, repo);
 633        }
 634
 635        for_each_string_list_item(item, push_options)
 636                if (strchr(item->string, '\n'))
 637                        die(_("push options must not have new line characters"));
 638
 639        rc = do_push(repo, flags, push_options);
 640        string_list_clear(&push_options_cmdline, 0);
 641        string_list_clear(&push_options_config, 0);
 642        if (rc == -1)
 643                usage_with_options(push_usage, options);
 644        else
 645                return rc;
 646}