builtin/push.c

   1 /*
   2  * "git push"
   3  */
   4 #include "cache.h"
   5 #include "advice.h"
   6 #include "branch.h"
   7 #include "config.h"
   8 #include "environment.h"
   9 #include "gettext.h"
  10 #include "refs.h"
  11 #include "refspec.h"
  12 #include "run-command.h"
  13 #include "builtin.h"
  14 #include "remote.h"
  15 #include "transport.h"
  16 #include "parse-options.h"
  17 #include "pkt-line.h"
  18 #include "repository.h"
  19 #include "submodule.h"
  20 #include "submodule-config.h"
  21 #include "send-pack.h"
  22 #include "trace2.h"
  23 #include "color.h"
  24
  25 static const char * const push_usage[] = {
  26         N_("git push [<options>] [<repository> [<refspec>...]]"),
  27         NULL,
  28 };
  29
  30 static int push_use_color = -1;
  31 static char push_colors[][COLOR_MAXLEN] = {
  32         GIT_COLOR_RESET,
  33         GIT_COLOR_RED,  /* ERROR */
  34 };
  35
  36 enum color_push {
  37         PUSH_COLOR_RESET = 0,
  38         PUSH_COLOR_ERROR = 1
  39 };
  40
  41 static int parse_push_color_slot(const char *slot)
  42 {
  43         if (!strcasecmp(slot, "reset"))
  44                 return PUSH_COLOR_RESET;
  45         if (!strcasecmp(slot, "error"))
  46                 return PUSH_COLOR_ERROR;
  47         return -1;
  48 }
  49
  50 static const char *push_get_color(enum color_push ix)
  51 {
  52         if (want_color_stderr(push_use_color))
  53                 return push_colors[ix];
  54         return "";
  55 }
  56
  57 static int thin = 1;
  58 static int deleterefs;
  59 static const char *receivepack;
  60 static int verbosity;
  61 static int progress = -1;
  62 static int recurse_submodules = RECURSE_SUBMODULES_DEFAULT;
  63 static enum transport_family family;
  64
  65 static struct push_cas_option cas;
  66
  67 static struct refspec rs = REFSPEC_INIT_PUSH;
  68
  69 static struct string_list push_options_config = STRING_LIST_INIT_DUP;
  70
  71 static void refspec_append_mapped(struct refspec *refspec, const char *ref,
  72                                   struct remote *remote, struct ref *matched)
  73 {
  74         const char *branch_name;
  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                         struct ref *matched = NULL;
 123
 124                         /* lazily grab local_refs */
 125                         if (!local_refs)
 126                                 local_refs = get_local_heads();
 127
 128                         /* Does "ref" uniquely name our ref? */
 129                         if (count_refspec_match(ref, local_refs, &matched) != 1) {
 130                                 refspec_append(&rs, ref);
 131                         } else {
 132                                 /* lazily grab remote */
 133                                 if (!remote)
 134                                         remote = remote_get(repo);
 135                                 if (!remote)
 136                                         BUG("must get a remote for repo '%s'", repo);
 137
 138                                 refspec_append_mapped(&rs, ref, remote, matched);
 139                         }
 140                 } else
 141                         refspec_append(&rs, ref);
 142         }
 143         free_refs(local_refs);
 144 }
 145
 146 static int push_url_of_remote(struct remote *remote, const char ***url_p)
 147 {
 148         if (remote->pushurl_nr) {
 149                 *url_p = remote->pushurl;
 150                 return remote->pushurl_nr;
 151         }
 152         *url_p = remote->url;
 153         return remote->url_nr;
 154 }
 155
 156 static NORETURN void die_push_simple(struct branch *branch,
 157                                      struct remote *remote)
 158 {
 159         /*
 160          * There's no point in using shorten_unambiguous_ref here,
 161          * as the ambiguity would be on the remote side, not what
 162          * we have locally. Plus, this is supposed to be the simple
 163          * mode. If the user is doing something crazy like setting
 164          * upstream to a non-branch, we should probably be showing
 165          * them the big ugly fully qualified ref.
 166          */
 167         const char *advice_pushdefault_maybe = "";
 168         const char *advice_automergesimple_maybe = "";
 169         const char *short_upstream = branch->merge[0]->src;
 170
 171         skip_prefix(short_upstream, "refs/heads/", &short_upstream);
 172
 173         /*
 174          * Don't show advice for people who explicitly set
 175          * push.default.
 176          */
 177         if (push_default == PUSH_DEFAULT_UNSPECIFIED)
 178                 advice_pushdefault_maybe = _("\n"
 179                                  "To choose either option permanently, "
 180                                  "see push.default in 'git help config'.\n");
 181         if (git_branch_track != BRANCH_TRACK_SIMPLE)
 182                 advice_automergesimple_maybe = _("\n"
 183                                  "To avoid automatically configuring "
 184                                  "an upstream branch when its name\n"
 185                                  "won't match the local branch, see option "
 186                                  "'simple' of branch.autoSetupMerge\n"
 187                                  "in 'git help config'.\n");
 188         die(_("The upstream branch of your current branch does not match\n"
 189               "the name of your current branch.  To push to the upstream branch\n"
 190               "on the remote, use\n"
 191               "\n"
 192               "    git push %s HEAD:%s\n"
 193               "\n"
 194               "To push to the branch of the same name on the remote, use\n"
 195               "\n"
 196               "    git push %s HEAD\n"
 197               "%s%s"),
 198             remote->name, short_upstream,
 199             remote->name, advice_pushdefault_maybe,
 200             advice_automergesimple_maybe);
 201 }
 202
 203 static const char message_detached_head_die[] =
 204         N_("You are not currently on a branch.\n"
 205            "To push the history leading to the current (detached HEAD)\n"
 206            "state now, use\n"
 207            "\n"
 208            "    git push %s HEAD:<name-of-remote-branch>\n");
 209
 210 static const char *get_upstream_ref(int flags, struct branch *branch, const char *remote_name)
 211 {
 212         if (branch->merge_nr == 0 && (flags & TRANSPORT_PUSH_AUTO_UPSTREAM)) {
 213                 /* if missing, assume same; set_upstream will be defined later */
 214                 return branch->refname;
 215         }
 216
 217         if (!branch->merge_nr || !branch->merge || !branch->remote_name) {
 218                 const char *advice_autosetup_maybe = "";
 219                 if (!(flags & TRANSPORT_PUSH_AUTO_UPSTREAM)) {
 220                         advice_autosetup_maybe = _("\n"
 221                                            "To have this happen automatically for "
 222                                            "branches without a tracking\n"
 223                                            "upstream, see 'push.autoSetupRemote' "
 224                                            "in 'git help config'.\n");
 225                 }
 226                 die(_("The current branch %s has no upstream branch.\n"
 227                     "To push the current branch and set the remote as upstream, use\n"
 228                     "\n"
 229                     "    git push --set-upstream %s %s\n"
 230                     "%s"),
 231                     branch->name,
 232                     remote_name,
 233                     branch->name,
 234                     advice_autosetup_maybe);
 235         }
 236         if (branch->merge_nr != 1)
 237                 die(_("The current branch %s has multiple upstream branches, "
 238                     "refusing to push."), branch->name);
 239
 240         return branch->merge[0]->src;
 241 }
 242
 243 static void setup_default_push_refspecs(int *flags, struct remote *remote)
 244 {
 245         struct branch *branch;
 246         const char *dst;
 247         int same_remote;
 248
 249         switch (push_default) {
 250         case PUSH_DEFAULT_MATCHING:
 251                 refspec_append(&rs, ":");
 252                 return;
 253
 254         case PUSH_DEFAULT_NOTHING:
 255                 die(_("You didn't specify any refspecs to push, and "
 256                     "push.default is \"nothing\"."));
 257                 return;
 258         default:
 259                 break;
 260         }
 261
 262         branch = branch_get(NULL);
 263         if (!branch)
 264                 die(_(message_detached_head_die), remote->name);
 265
 266         dst = branch->refname;
 267         same_remote = !strcmp(remote->name, remote_for_branch(branch, NULL));
 268
 269         switch (push_default) {
 270         default:
 271         case PUSH_DEFAULT_UNSPECIFIED:
 272         case PUSH_DEFAULT_SIMPLE:
 273                 if (!same_remote)
 274                         break;
 275                 if (strcmp(branch->refname, get_upstream_ref(*flags, branch, remote->name)))
 276                         die_push_simple(branch, remote);
 277                 break;
 278
 279         case PUSH_DEFAULT_UPSTREAM:
 280                 if (!same_remote)
 281                         die(_("You are pushing to remote '%s', which is not the upstream of\n"
 282                               "your current branch '%s', without telling me what to push\n"
 283                               "to update which remote branch."),
 284                             remote->name, branch->name);
 285                 dst = get_upstream_ref(*flags, branch, remote->name);
 286                 break;
 287
 288         case PUSH_DEFAULT_CURRENT:
 289                 break;
 290         }
 291
 292         /*
 293          * this is a default push - if auto-upstream is enabled and there is
 294          * no upstream defined, then set it (with options 'simple', 'upstream',
 295          * and 'current').
 296          */
 297         if ((*flags & TRANSPORT_PUSH_AUTO_UPSTREAM) && branch->merge_nr == 0)
 298                 *flags |= TRANSPORT_PUSH_SET_UPSTREAM;
 299
 300         refspec_appendf(&rs, "%s:%s", branch->refname, dst);
 301 }
 302
 303 static const char message_advice_pull_before_push[] =
 304         N_("Updates were rejected because the tip of your current branch is behind\n"
 305            "its remote counterpart. Integrate the remote changes (e.g.\n"
 306            "'git pull ...') before pushing again.\n"
 307            "See the 'Note about fast-forwards' in 'git push --help' for details.");
 308
 309 static const char message_advice_checkout_pull_push[] =
 310         N_("Updates were rejected because a pushed branch tip is behind its remote\n"
 311            "counterpart. Check out this branch and integrate the remote changes\n"
 312            "(e.g. 'git pull ...') before pushing again.\n"
 313            "See the 'Note about fast-forwards' in 'git push --help' for details.");
 314
 315 static const char message_advice_ref_fetch_first[] =
 316         N_("Updates were rejected because the remote contains work that you do\n"
 317            "not have locally. This is usually caused by another repository pushing\n"
 318            "to the same ref. You may want to first integrate the remote changes\n"
 319            "(e.g., 'git pull ...') before pushing again.\n"
 320            "See the 'Note about fast-forwards' in 'git push --help' for details.");
 321
 322 static const char message_advice_ref_already_exists[] =
 323         N_("Updates were rejected because the tag already exists in the remote.");
 324
 325 static const char message_advice_ref_needs_force[] =
 326         N_("You cannot update a remote ref that points at a non-commit object,\n"
 327            "or update a remote ref to make it point at a non-commit object,\n"
 328            "without using the '--force' option.\n");
 329
 330 static const char message_advice_ref_needs_update[] =
 331         N_("Updates were rejected because the tip of the remote-tracking\n"
 332            "branch has been updated since the last checkout. You may want\n"
 333            "to integrate those changes locally (e.g., 'git pull ...')\n"
 334            "before forcing an update.\n");
 335
 336 static void advise_pull_before_push(void)
 337 {
 338         if (!advice_enabled(ADVICE_PUSH_NON_FF_CURRENT) || !advice_enabled(ADVICE_PUSH_UPDATE_REJECTED))
 339                 return;
 340         advise(_(message_advice_pull_before_push));
 341 }
 342
 343 static void advise_checkout_pull_push(void)
 344 {
 345         if (!advice_enabled(ADVICE_PUSH_NON_FF_MATCHING) || !advice_enabled(ADVICE_PUSH_UPDATE_REJECTED))
 346                 return;
 347         advise(_(message_advice_checkout_pull_push));
 348 }
 349
 350 static void advise_ref_already_exists(void)
 351 {
 352         if (!advice_enabled(ADVICE_PUSH_ALREADY_EXISTS) || !advice_enabled(ADVICE_PUSH_UPDATE_REJECTED))
 353                 return;
 354         advise(_(message_advice_ref_already_exists));
 355 }
 356
 357 static void advise_ref_fetch_first(void)
 358 {
 359         if (!advice_enabled(ADVICE_PUSH_FETCH_FIRST) || !advice_enabled(ADVICE_PUSH_UPDATE_REJECTED))
 360                 return;
 361         advise(_(message_advice_ref_fetch_first));
 362 }
 363
 364 static void advise_ref_needs_force(void)
 365 {
 366         if (!advice_enabled(ADVICE_PUSH_NEEDS_FORCE) || !advice_enabled(ADVICE_PUSH_UPDATE_REJECTED))
 367                 return;
 368         advise(_(message_advice_ref_needs_force));
 369 }
 370
 371 static void advise_ref_needs_update(void)
 372 {
 373         if (!advice_enabled(ADVICE_PUSH_REF_NEEDS_UPDATE) || !advice_enabled(ADVICE_PUSH_UPDATE_REJECTED))
 374                 return;
 375         advise(_(message_advice_ref_needs_update));
 376 }
 377
 378 static int push_with_options(struct transport *transport, struct refspec *rs,
 379                              int flags)
 380 {
 381         int err;
 382         unsigned int reject_reasons;
 383         char *anon_url = transport_anonymize_url(transport->url);
 384
 385         transport_set_verbosity(transport, verbosity, progress);
 386         transport->family = family;
 387
 388         if (receivepack)
 389                 transport_set_option(transport,
 390                                      TRANS_OPT_RECEIVEPACK, receivepack);
 391         transport_set_option(transport, TRANS_OPT_THIN, thin ? "yes" : NULL);
 392
 393         if (!is_empty_cas(&cas)) {
 394                 if (!transport->smart_options)
 395                         die("underlying transport does not support --%s option",
 396                             CAS_OPT_NAME);
 397                 transport->smart_options->cas = &cas;
 398         }
 399
 400         if (verbosity > 0)
 401                 fprintf(stderr, _("Pushing to %s\n"), anon_url);
 402         trace2_region_enter("push", "transport_push", the_repository);
 403         err = transport_push(the_repository, transport,
 404                              rs, flags, &reject_reasons);
 405         trace2_region_leave("push", "transport_push", the_repository);
 406         if (err != 0) {
 407                 fprintf(stderr, "%s", push_get_color(PUSH_COLOR_ERROR));
 408                 error(_("failed to push some refs to '%s'"), anon_url);
 409                 fprintf(stderr, "%s", push_get_color(PUSH_COLOR_RESET));
 410         }
 411
 412         err |= transport_disconnect(transport);
 413         free(anon_url);
 414         if (!err)
 415                 return 0;
 416
 417         if (reject_reasons & REJECT_NON_FF_HEAD) {
 418                 advise_pull_before_push();
 419         } else if (reject_reasons & REJECT_NON_FF_OTHER) {
 420                 advise_checkout_pull_push();
 421         } else if (reject_reasons & REJECT_ALREADY_EXISTS) {
 422                 advise_ref_already_exists();
 423         } else if (reject_reasons & REJECT_FETCH_FIRST) {
 424                 advise_ref_fetch_first();
 425         } else if (reject_reasons & REJECT_NEEDS_FORCE) {
 426                 advise_ref_needs_force();
 427         } else if (reject_reasons & REJECT_REF_NEEDS_UPDATE) {
 428                 advise_ref_needs_update();
 429         }
 430
 431         return 1;
 432 }
 433
 434 static int do_push(int flags,
 435                    const struct string_list *push_options,
 436                    struct remote *remote)
 437 {
 438         int i, errs;
 439         const char **url;
 440         int url_nr;
 441         struct refspec *push_refspec = &rs;
 442
 443         if (push_options->nr)
 444                 flags |= TRANSPORT_PUSH_OPTIONS;
 445
 446         if (!push_refspec->nr && !(flags & TRANSPORT_PUSH_ALL)) {
 447                 if (remote->push.nr) {
 448                         push_refspec = &remote->push;
 449                 } else if (!(flags & TRANSPORT_PUSH_MIRROR))
 450                         setup_default_push_refspecs(&flags, remote);
 451         }
 452         errs = 0;
 453         url_nr = push_url_of_remote(remote, &url);
 454         if (url_nr) {
 455                 for (i = 0; i < url_nr; i++) {
 456                         struct transport *transport =
 457                                 transport_get(remote, url[i]);
 458                         if (flags & TRANSPORT_PUSH_OPTIONS)
 459                                 transport->push_options = push_options;
 460                         if (push_with_options(transport, push_refspec, flags))
 461                                 errs++;
 462                 }
 463         } else {
 464                 struct transport *transport =
 465                         transport_get(remote, NULL);
 466                 if (flags & TRANSPORT_PUSH_OPTIONS)
 467                         transport->push_options = push_options;
 468                 if (push_with_options(transport, push_refspec, flags))
 469                         errs++;
 470         }
 471         return !!errs;
 472 }
 473
 474 static int option_parse_recurse_submodules(const struct option *opt,
 475                                    const char *arg, int unset)
 476 {
 477         int *recurse_submodules = opt->value;
 478
 479         if (unset)
 480                 *recurse_submodules = RECURSE_SUBMODULES_OFF;
 481         else {
 482                 if (!strcmp(arg, "only-is-on-demand")) {
 483                         if (*recurse_submodules == RECURSE_SUBMODULES_ONLY) {
 484                                 warning(_("recursing into submodule with push.recurseSubmodules=only; using on-demand instead"));
 485                                 *recurse_submodules = RECURSE_SUBMODULES_ON_DEMAND;
 486                         }
 487                 } else {
 488                         *recurse_submodules = parse_push_recurse_submodules_arg(opt->long_name, arg);
 489                 }
 490         }
 491
 492         return 0;
 493 }
 494
 495 static void set_push_cert_flags(int *flags, int v)
 496 {
 497         switch (v) {
 498         case SEND_PACK_PUSH_CERT_NEVER:
 499                 *flags &= ~(TRANSPORT_PUSH_CERT_ALWAYS | TRANSPORT_PUSH_CERT_IF_ASKED);
 500                 break;
 501         case SEND_PACK_PUSH_CERT_ALWAYS:
 502                 *flags |= TRANSPORT_PUSH_CERT_ALWAYS;
 503                 *flags &= ~TRANSPORT_PUSH_CERT_IF_ASKED;
 504                 break;
 505         case SEND_PACK_PUSH_CERT_IF_ASKED:
 506                 *flags |= TRANSPORT_PUSH_CERT_IF_ASKED;
 507                 *flags &= ~TRANSPORT_PUSH_CERT_ALWAYS;
 508                 break;
 509         }
 510 }
 511
 512
 513 static int git_push_config(const char *k, const char *v, void *cb)
 514 {
 515         const char *slot_name;
 516         int *flags = cb;
 517
 518         if (!strcmp(k, "push.followtags")) {
 519                 if (git_config_bool(k, v))
 520                         *flags |= TRANSPORT_PUSH_FOLLOW_TAGS;
 521                 else
 522                         *flags &= ~TRANSPORT_PUSH_FOLLOW_TAGS;
 523                 return 0;
 524         } else if (!strcmp(k, "push.autosetupremote")) {
 525                 if (git_config_bool(k, v))
 526                         *flags |= TRANSPORT_PUSH_AUTO_UPSTREAM;
 527                 return 0;
 528         } else if (!strcmp(k, "push.gpgsign")) {
 529                 const char *value;
 530                 if (!git_config_get_value("push.gpgsign", &value)) {
 531                         switch (git_parse_maybe_bool(value)) {
 532                         case 0:
 533                                 set_push_cert_flags(flags, SEND_PACK_PUSH_CERT_NEVER);
 534                                 break;
 535                         case 1:
 536                                 set_push_cert_flags(flags, SEND_PACK_PUSH_CERT_ALWAYS);
 537                                 break;
 538                         default:
 539                                 if (value && !strcasecmp(value, "if-asked"))
 540                                         set_push_cert_flags(flags, SEND_PACK_PUSH_CERT_IF_ASKED);
 541                                 else
 542                                         return error(_("invalid value for '%s'"), k);
 543                         }
 544                 }
 545         } else if (!strcmp(k, "push.recursesubmodules")) {
 546                 const char *value;
 547                 if (!git_config_get_value("push.recursesubmodules", &value))
 548                         recurse_submodules = parse_push_recurse_submodules_arg(k, value);
 549         } else if (!strcmp(k, "submodule.recurse")) {
 550                 int val = git_config_bool(k, v) ?
 551                         RECURSE_SUBMODULES_ON_DEMAND : RECURSE_SUBMODULES_OFF;
 552                 recurse_submodules = val;
 553         } else if (!strcmp(k, "push.pushoption")) {
 554                 if (!v)
 555                         return config_error_nonbool(k);
 556                 else
 557                         if (!*v)
 558                                 string_list_clear(&push_options_config, 0);
 559                         else
 560                                 string_list_append(&push_options_config, v);
 561                 return 0;
 562         } else if (!strcmp(k, "color.push")) {
 563                 push_use_color = git_config_colorbool(k, v);
 564                 return 0;
 565         } else if (skip_prefix(k, "color.push.", &slot_name)) {
 566                 int slot = parse_push_color_slot(slot_name);
 567                 if (slot < 0)
 568                         return 0;
 569                 if (!v)
 570                         return config_error_nonbool(k);
 571                 return color_parse(v, push_colors[slot]);
 572         } else if (!strcmp(k, "push.useforceifincludes")) {
 573                 if (git_config_bool(k, v))
 574                         *flags |= TRANSPORT_PUSH_FORCE_IF_INCLUDES;
 575                 else
 576                         *flags &= ~TRANSPORT_PUSH_FORCE_IF_INCLUDES;
 577                 return 0;
 578         }
 579
 580         return git_default_config(k, v, NULL);
 581 }
 582
 583 int cmd_push(int argc, const char **argv, const char *prefix)
 584 {
 585         int flags = 0;
 586         int tags = 0;
 587         int push_cert = -1;
 588         int rc;
 589         const char *repo = NULL;        /* default repository */
 590         struct string_list push_options_cmdline = STRING_LIST_INIT_DUP;
 591         struct string_list *push_options;
 592         const struct string_list_item *item;
 593         struct remote *remote;
 594
 595         struct option options[] = {
 596                 OPT__VERBOSITY(&verbosity),
 597                 OPT_STRING( 0 , "repo", &repo, N_("repository"), N_("repository")),
 598                 OPT_BIT( 0 , "all", &flags, N_("push all refs"), TRANSPORT_PUSH_ALL),
 599                 OPT_BIT( 0 , "mirror", &flags, N_("mirror all refs"),
 600                             (TRANSPORT_PUSH_MIRROR|TRANSPORT_PUSH_FORCE)),
 601                 OPT_BOOL('d', "delete", &deleterefs, N_("delete refs")),
 602                 OPT_BOOL( 0 , "tags", &tags, N_("push tags (can't be used with --all or --mirror)")),
 603                 OPT_BIT('n' , "dry-run", &flags, N_("dry run"), TRANSPORT_PUSH_DRY_RUN),
 604                 OPT_BIT( 0,  "porcelain", &flags, N_("machine-readable output"), TRANSPORT_PUSH_PORCELAIN),
 605                 OPT_BIT('f', "force", &flags, N_("force updates"), TRANSPORT_PUSH_FORCE),
 606                 OPT_CALLBACK_F(0, CAS_OPT_NAME, &cas, N_("<refname>:<expect>"),
 607                                N_("require old value of ref to be at this value"),
 608                                PARSE_OPT_OPTARG | PARSE_OPT_LITERAL_ARGHELP, parseopt_push_cas_option),
 609                 OPT_BIT(0, TRANS_OPT_FORCE_IF_INCLUDES, &flags,
 610                         N_("require remote updates to be integrated locally"),
 611                         TRANSPORT_PUSH_FORCE_IF_INCLUDES),
 612                 OPT_CALLBACK(0, "recurse-submodules", &recurse_submodules, "(check|on-demand|no)",
 613                              N_("control recursive pushing of submodules"), option_parse_recurse_submodules),
 614                 OPT_BOOL_F( 0 , "thin", &thin, N_("use thin pack"), PARSE_OPT_NOCOMPLETE),
 615                 OPT_STRING( 0 , "receive-pack", &receivepack, "receive-pack", N_("receive pack program")),
 616                 OPT_STRING( 0 , "exec", &receivepack, "receive-pack", N_("receive pack program")),
 617                 OPT_BIT('u', "set-upstream", &flags, N_("set upstream for git pull/status"),
 618                         TRANSPORT_PUSH_SET_UPSTREAM),
 619                 OPT_BOOL(0, "progress", &progress, N_("force progress reporting")),
 620                 OPT_BIT(0, "prune", &flags, N_("prune locally removed refs"),
 621                         TRANSPORT_PUSH_PRUNE),
 622                 OPT_BIT(0, "no-verify", &flags, N_("bypass pre-push hook"), TRANSPORT_PUSH_NO_HOOK),
 623                 OPT_BIT(0, "follow-tags", &flags, N_("push missing but relevant tags"),
 624                         TRANSPORT_PUSH_FOLLOW_TAGS),
 625                 OPT_CALLBACK_F(0, "signed", &push_cert, "(yes|no|if-asked)", N_("GPG sign the push"),
 626                                 PARSE_OPT_OPTARG, option_parse_push_signed),
 627                 OPT_BIT(0, "atomic", &flags, N_("request atomic transaction on remote side"), TRANSPORT_PUSH_ATOMIC),
 628                 OPT_STRING_LIST('o', "push-option", &push_options_cmdline, N_("server-specific"), N_("option to transmit")),
 629                 OPT_SET_INT('4', "ipv4", &family, N_("use IPv4 addresses only"),
 630                                 TRANSPORT_FAMILY_IPV4),
 631                 OPT_SET_INT('6', "ipv6", &family, N_("use IPv6 addresses only"),
 632                                 TRANSPORT_FAMILY_IPV6),
 633                 OPT_END()
 634         };
 635
 636         packet_trace_identity("push");
 637         git_config(git_push_config, &flags);
 638         argc = parse_options(argc, argv, prefix, options, push_usage, 0);
 639         push_options = (push_options_cmdline.nr
 640                 ? &push_options_cmdline
 641                 : &push_options_config);
 642         set_push_cert_flags(&flags, push_cert);
 643
 644         if (deleterefs && (tags || (flags & (TRANSPORT_PUSH_ALL | TRANSPORT_PUSH_MIRROR))))
 645                 die(_("options '%s' and '%s' cannot be used together"), "--delete", "--all/--mirror/--tags");
 646         if (deleterefs && argc < 2)
 647                 die(_("--delete doesn't make sense without any refs"));
 648
 649         if (recurse_submodules == RECURSE_SUBMODULES_CHECK)
 650                 flags |= TRANSPORT_RECURSE_SUBMODULES_CHECK;
 651         else if (recurse_submodules == RECURSE_SUBMODULES_ON_DEMAND)
 652                 flags |= TRANSPORT_RECURSE_SUBMODULES_ON_DEMAND;
 653         else if (recurse_submodules == RECURSE_SUBMODULES_ONLY)
 654                 flags |= TRANSPORT_RECURSE_SUBMODULES_ONLY;
 655
 656         if (tags)
 657                 refspec_append(&rs, "refs/tags/*");
 658
 659         if (argc > 0) {
 660                 repo = argv[0];
 661                 set_refspecs(argv + 1, argc - 1, repo);
 662         }
 663
 664         remote = pushremote_get(repo);
 665         if (!remote) {
 666                 if (repo)
 667                         die(_("bad repository '%s'"), repo);
 668                 die(_("No configured push destination.\n"
 669                     "Either specify the URL from the command-line or configure a remote repository using\n"
 670                     "\n"
 671                     "    git remote add <name> <url>\n"
 672                     "\n"
 673                     "and then push using the remote name\n"
 674                     "\n"
 675                     "    git push <name>\n"));
 676         }
 677
 678         if (remote->mirror)
 679                 flags |= (TRANSPORT_PUSH_MIRROR|TRANSPORT_PUSH_FORCE);
 680
 681         if (flags & TRANSPORT_PUSH_ALL) {
 682                 if (tags)
 683                         die(_("options '%s' and '%s' cannot be used together"), "--all", "--tags");
 684                 if (argc >= 2)
 685                         die(_("--all can't be combined with refspecs"));
 686         }
 687         if (flags & TRANSPORT_PUSH_MIRROR) {
 688                 if (tags)
 689                         die(_("options '%s' and '%s' cannot be used together"), "--mirror", "--tags");
 690                 if (argc >= 2)
 691                         die(_("--mirror can't be combined with refspecs"));
 692         }
 693         if ((flags & TRANSPORT_PUSH_ALL) && (flags & TRANSPORT_PUSH_MIRROR))
 694                 die(_("options '%s' and '%s' cannot be used together"), "--all", "--mirror");
 695
 696         if (!is_empty_cas(&cas) && (flags & TRANSPORT_PUSH_FORCE_IF_INCLUDES))
 697                 cas.use_force_if_includes = 1;
 698
 699         for_each_string_list_item(item, push_options)
 700                 if (strchr(item->string, '\n'))
 701                         die(_("push options must not have new line characters"));
 702
 703         rc = do_push(flags, push_options, remote);
 704         string_list_clear(&push_options_cmdline, 0);
 705         string_list_clear(&push_options_config, 0);
 706         if (rc == -1)
 707                 usage_with_options(push_usage, options);
 708         else
 709                 return rc;
 710 }