builtin/push.c

   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
  18 static const char * const push_usage[] = {
  19         N_("git push [<options>] [<repository> [<refspec>...]]"),
  20         NULL,
  21 };
  22
  23 static int push_use_color = -1;
  24 static char push_colors[][COLOR_MAXLEN] = {
  25         GIT_COLOR_RESET,
  26         GIT_COLOR_RED,  /* ERROR */
  27 };
  28
  29 enum color_push {
  30         PUSH_COLOR_RESET = 0,
  31         PUSH_COLOR_ERROR = 1
  32 };
  33
  34 static 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
  43 static 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
  50 static int thin = 1;
  51 static int deleterefs;
  52 static const char *receivepack;
  53 static int verbosity;
  54 static int progress = -1;
  55 static int recurse_submodules = RECURSE_SUBMODULES_DEFAULT;
  56 static enum transport_family family;
  57
  58 static struct push_cas_option cas;
  59
  60 static struct refspec rs = REFSPEC_INIT_PUSH;
  61
  62 static struct string_list push_options_config = STRING_LIST_INIT_DUP;
  63
  64 static 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
 100 static 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
 136 static 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
 146 static NORETURN void 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
 184 static 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
 191 static 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
 225 static 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
 235 static 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
 241 static 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
 275 static 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
 281 static 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
 287 static 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
 294 static const char message_advice_ref_already_exists[] =
 295         N_("Updates were rejected because the tag already exists in the remote.");
 296
 297 static 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
 302 static 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
 309 static 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
 316 static 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
 323 static 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
 330 static 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
 337 static 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         trace2_region_enter("push", "transport_push", the_repository);
 361         err = transport_push(the_repository, transport,
 362                              rs, flags, &reject_reasons);
 363         trace2_region_leave("push", "transport_push", the_repository);
 364         if (err != 0) {
 365                 fprintf(stderr, "%s", push_get_color(PUSH_COLOR_ERROR));
 366                 error(_("failed to push some refs to '%s'"), transport->url);
 367                 fprintf(stderr, "%s", push_get_color(PUSH_COLOR_RESET));
 368         }
 369
 370         err |= transport_disconnect(transport);
 371         if (!err)
 372                 return 0;
 373
 374         if (reject_reasons & REJECT_NON_FF_HEAD) {
 375                 advise_pull_before_push();
 376         } else if (reject_reasons & REJECT_NON_FF_OTHER) {
 377                 advise_checkout_pull_push();
 378         } else if (reject_reasons & REJECT_ALREADY_EXISTS) {
 379                 advise_ref_already_exists();
 380         } else if (reject_reasons & REJECT_FETCH_FIRST) {
 381                 advise_ref_fetch_first();
 382         } else if (reject_reasons & REJECT_NEEDS_FORCE) {
 383                 advise_ref_needs_force();
 384         }
 385
 386         return 1;
 387 }
 388
 389 static int do_push(const char *repo, int flags,
 390                    const struct string_list *push_options,
 391                    struct remote *remote)
 392 {
 393         int i, errs;
 394         const char **url;
 395         int url_nr;
 396         struct refspec *push_refspec = &rs;
 397
 398         if (push_options->nr)
 399                 flags |= TRANSPORT_PUSH_OPTIONS;
 400
 401         if (!push_refspec->nr && !(flags & TRANSPORT_PUSH_ALL)) {
 402                 if (remote->push.nr) {
 403                         push_refspec = &remote->push;
 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, push_refspec, 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, push_refspec, flags))
 424                         errs++;
 425         }
 426         return !!errs;
 427 }
 428
 429 static 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
 444 static 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
 462 static int git_push_config(const char *k, const char *v, void *cb)
 463 {
 464         const char *slot_name;
 465         int *flags = cb;
 466         int status;
 467
 468         status = git_gpg_config(k, v, NULL);
 469         if (status)
 470                 return status;
 471
 472         if (!strcmp(k, "push.followtags")) {
 473                 if (git_config_bool(k, v))
 474                         *flags |= TRANSPORT_PUSH_FOLLOW_TAGS;
 475                 else
 476                         *flags &= ~TRANSPORT_PUSH_FOLLOW_TAGS;
 477                 return 0;
 478         } else if (!strcmp(k, "push.gpgsign")) {
 479                 const char *value;
 480                 if (!git_config_get_value("push.gpgsign", &value)) {
 481                         switch (git_parse_maybe_bool(value)) {
 482                         case 0:
 483                                 set_push_cert_flags(flags, SEND_PACK_PUSH_CERT_NEVER);
 484                                 break;
 485                         case 1:
 486                                 set_push_cert_flags(flags, SEND_PACK_PUSH_CERT_ALWAYS);
 487                                 break;
 488                         default:
 489                                 if (value && !strcasecmp(value, "if-asked"))
 490                                         set_push_cert_flags(flags, SEND_PACK_PUSH_CERT_IF_ASKED);
 491                                 else
 492                                         return error("Invalid value for '%s'", k);
 493                         }
 494                 }
 495         } else if (!strcmp(k, "push.recursesubmodules")) {
 496                 const char *value;
 497                 if (!git_config_get_value("push.recursesubmodules", &value))
 498                         recurse_submodules = parse_push_recurse_submodules_arg(k, value);
 499         } else if (!strcmp(k, "submodule.recurse")) {
 500                 int val = git_config_bool(k, v) ?
 501                         RECURSE_SUBMODULES_ON_DEMAND : RECURSE_SUBMODULES_OFF;
 502                 recurse_submodules = val;
 503         } else if (!strcmp(k, "push.pushoption")) {
 504                 if (!v)
 505                         return config_error_nonbool(k);
 506                 else
 507                         if (!*v)
 508                                 string_list_clear(&push_options_config, 0);
 509                         else
 510                                 string_list_append(&push_options_config, v);
 511                 return 0;
 512         } else if (!strcmp(k, "color.push")) {
 513                 push_use_color = git_config_colorbool(k, v);
 514                 return 0;
 515         } else if (skip_prefix(k, "color.push.", &slot_name)) {
 516                 int slot = parse_push_color_slot(slot_name);
 517                 if (slot < 0)
 518                         return 0;
 519                 if (!v)
 520                         return config_error_nonbool(k);
 521                 return color_parse(v, push_colors[slot]);
 522         }
 523
 524         return git_default_config(k, v, NULL);
 525 }
 526
 527 int cmd_push(int argc, const char **argv, const char *prefix)
 528 {
 529         int flags = 0;
 530         int tags = 0;
 531         int push_cert = -1;
 532         int rc;
 533         const char *repo = NULL;        /* default repository */
 534         struct string_list push_options_cmdline = STRING_LIST_INIT_DUP;
 535         struct string_list *push_options;
 536         const struct string_list_item *item;
 537         struct remote *remote;
 538
 539         struct option options[] = {
 540                 OPT__VERBOSITY(&verbosity),
 541                 OPT_STRING( 0 , "repo", &repo, N_("repository"), N_("repository")),
 542                 OPT_BIT( 0 , "all", &flags, N_("push all refs"), TRANSPORT_PUSH_ALL),
 543                 OPT_BIT( 0 , "mirror", &flags, N_("mirror all refs"),
 544                             (TRANSPORT_PUSH_MIRROR|TRANSPORT_PUSH_FORCE)),
 545                 OPT_BOOL('d', "delete", &deleterefs, N_("delete refs")),
 546                 OPT_BOOL( 0 , "tags", &tags, N_("push tags (can't be used with --all or --mirror)")),
 547                 OPT_BIT('n' , "dry-run", &flags, N_("dry run"), TRANSPORT_PUSH_DRY_RUN),
 548                 OPT_BIT( 0,  "porcelain", &flags, N_("machine-readable output"), TRANSPORT_PUSH_PORCELAIN),
 549                 OPT_BIT('f', "force", &flags, N_("force updates"), TRANSPORT_PUSH_FORCE),
 550                 { OPTION_CALLBACK,
 551                   0, CAS_OPT_NAME, &cas, N_("<refname>:<expect>"),
 552                   N_("require old value of ref to be at this value"),
 553                   PARSE_OPT_OPTARG | PARSE_OPT_LITERAL_ARGHELP, parseopt_push_cas_option },
 554                 { OPTION_CALLBACK, 0, "recurse-submodules", &recurse_submodules, "(check|on-demand|no)",
 555                         N_("control recursive pushing of submodules"),
 556                         PARSE_OPT_OPTARG, option_parse_recurse_submodules },
 557                 OPT_BOOL_F( 0 , "thin", &thin, N_("use thin pack"), PARSE_OPT_NOCOMPLETE),
 558                 OPT_STRING( 0 , "receive-pack", &receivepack, "receive-pack", N_("receive pack program")),
 559                 OPT_STRING( 0 , "exec", &receivepack, "receive-pack", N_("receive pack program")),
 560                 OPT_BIT('u', "set-upstream", &flags, N_("set upstream for git pull/status"),
 561                         TRANSPORT_PUSH_SET_UPSTREAM),
 562                 OPT_BOOL(0, "progress", &progress, N_("force progress reporting")),
 563                 OPT_BIT(0, "prune", &flags, N_("prune locally removed refs"),
 564                         TRANSPORT_PUSH_PRUNE),
 565                 OPT_BIT(0, "no-verify", &flags, N_("bypass pre-push hook"), TRANSPORT_PUSH_NO_HOOK),
 566                 OPT_BIT(0, "follow-tags", &flags, N_("push missing but relevant tags"),
 567                         TRANSPORT_PUSH_FOLLOW_TAGS),
 568                 { OPTION_CALLBACK,
 569                   0, "signed", &push_cert, "(yes|no|if-asked)", N_("GPG sign the push"),
 570                   PARSE_OPT_OPTARG, option_parse_push_signed },
 571                 OPT_BIT(0, "atomic", &flags, N_("request atomic transaction on remote side"), TRANSPORT_PUSH_ATOMIC),
 572                 OPT_STRING_LIST('o', "push-option", &push_options_cmdline, N_("server-specific"), N_("option to transmit")),
 573                 OPT_SET_INT('4', "ipv4", &family, N_("use IPv4 addresses only"),
 574                                 TRANSPORT_FAMILY_IPV4),
 575                 OPT_SET_INT('6', "ipv6", &family, N_("use IPv6 addresses only"),
 576                                 TRANSPORT_FAMILY_IPV6),
 577                 OPT_END()
 578         };
 579
 580         packet_trace_identity("push");
 581         git_config(git_push_config, &flags);
 582         argc = parse_options(argc, argv, prefix, options, push_usage, 0);
 583         push_options = (push_options_cmdline.nr
 584                 ? &push_options_cmdline
 585                 : &push_options_config);
 586         set_push_cert_flags(&flags, push_cert);
 587
 588         if (deleterefs && (tags || (flags & (TRANSPORT_PUSH_ALL | TRANSPORT_PUSH_MIRROR))))
 589                 die(_("--delete is incompatible with --all, --mirror and --tags"));
 590         if (deleterefs && argc < 2)
 591                 die(_("--delete doesn't make sense without any refs"));
 592
 593         if (recurse_submodules == RECURSE_SUBMODULES_CHECK)
 594                 flags |= TRANSPORT_RECURSE_SUBMODULES_CHECK;
 595         else if (recurse_submodules == RECURSE_SUBMODULES_ON_DEMAND)
 596                 flags |= TRANSPORT_RECURSE_SUBMODULES_ON_DEMAND;
 597         else if (recurse_submodules == RECURSE_SUBMODULES_ONLY)
 598                 flags |= TRANSPORT_RECURSE_SUBMODULES_ONLY;
 599
 600         if (tags)
 601                 refspec_append(&rs, "refs/tags/*");
 602
 603         if (argc > 0) {
 604                 repo = argv[0];
 605                 set_refspecs(argv + 1, argc - 1, repo);
 606         }
 607
 608         remote = pushremote_get(repo);
 609         if (!remote) {
 610                 if (repo)
 611                         die(_("bad repository '%s'"), repo);
 612                 die(_("No configured push destination.\n"
 613                     "Either specify the URL from the command-line or configure a remote repository using\n"
 614                     "\n"
 615                     "    git remote add <name> <url>\n"
 616                     "\n"
 617                     "and then push using the remote name\n"
 618                     "\n"
 619                     "    git push <name>\n"));
 620         }
 621
 622         if (remote->mirror)
 623                 flags |= (TRANSPORT_PUSH_MIRROR|TRANSPORT_PUSH_FORCE);
 624
 625         if (flags & TRANSPORT_PUSH_ALL) {
 626                 if (tags)
 627                         die(_("--all and --tags are incompatible"));
 628                 if (argc >= 2)
 629                         die(_("--all can't be combined with refspecs"));
 630         }
 631         if (flags & TRANSPORT_PUSH_MIRROR) {
 632                 if (tags)
 633                         die(_("--mirror and --tags are incompatible"));
 634                 if (argc >= 2)
 635                         die(_("--mirror can't be combined with refspecs"));
 636         }
 637         if ((flags & TRANSPORT_PUSH_ALL) && (flags & TRANSPORT_PUSH_MIRROR))
 638                 die(_("--all and --mirror are incompatible"));
 639
 640         for_each_string_list_item(item, push_options)
 641                 if (strchr(item->string, '\n'))
 642                         die(_("push options must not have new line characters"));
 643
 644         rc = do_push(repo, flags, push_options, remote);
 645         string_list_clear(&push_options_cmdline, 0);
 646         string_list_clear(&push_options_config, 0);
 647         if (rc == -1)
 648                 usage_with_options(push_usage, options);
 649         else
 650                 return rc;
 651 }