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