builtin/push.c

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