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