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 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
 182 static 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
 189 static 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
 223 static 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
 233 static 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
 239 static 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
 273 static 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
 279 static 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
 285 static 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
 292 static const char message_advice_ref_already_exists[] =
 293         N_("Updates were rejected because the tag already exists in the remote.");
 294
 295 static 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
 300 static 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
 307 static 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
 314 static 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
 321 static 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
 328 static 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
 335 static 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
 385 static 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
 441 static 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
 456 static 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
 474 static 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
 539 int 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 }