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                 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, ctx, 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 branches"), TRANSPORT_PUSH_ALL),
 599                 OPT_ALIAS( 0 , "branches", "all"),
 600                 OPT_BIT( 0 , "mirror", &flags, N_("mirror all refs"),
 601                             (TRANSPORT_PUSH_MIRROR|TRANSPORT_PUSH_FORCE)),
 602                 OPT_BOOL('d', "delete", &deleterefs, N_("delete refs")),
 603                 OPT_BOOL( 0 , "tags", &tags, N_("push tags (can't be used with --all or --branches or --mirror)")),
 604                 OPT_BIT('n' , "dry-run", &flags, N_("dry run"), TRANSPORT_PUSH_DRY_RUN),
 605                 OPT_BIT( 0,  "porcelain", &flags, N_("machine-readable output"), TRANSPORT_PUSH_PORCELAIN),
 606                 OPT_BIT('f', "force", &flags, N_("force updates"), TRANSPORT_PUSH_FORCE),
 607                 OPT_CALLBACK_F(0, CAS_OPT_NAME, &cas, N_("<refname>:<expect>"),
 608                                N_("require old value of ref to be at this value"),
 609                                PARSE_OPT_OPTARG | PARSE_OPT_LITERAL_ARGHELP, parseopt_push_cas_option),
 610                 OPT_BIT(0, TRANS_OPT_FORCE_IF_INCLUDES, &flags,
 611                         N_("require remote updates to be integrated locally"),
 612                         TRANSPORT_PUSH_FORCE_IF_INCLUDES),
 613                 OPT_CALLBACK(0, "recurse-submodules", &recurse_submodules, "(check|on-demand|no)",
 614                              N_("control recursive pushing of submodules"), option_parse_recurse_submodules),
 615                 OPT_BOOL_F( 0 , "thin", &thin, N_("use thin pack"), PARSE_OPT_NOCOMPLETE),
 616                 OPT_STRING( 0 , "receive-pack", &receivepack, "receive-pack", N_("receive pack program")),
 617                 OPT_STRING( 0 , "exec", &receivepack, "receive-pack", N_("receive pack program")),
 618                 OPT_BIT('u', "set-upstream", &flags, N_("set upstream for git pull/status"),
 619                         TRANSPORT_PUSH_SET_UPSTREAM),
 620                 OPT_BOOL(0, "progress", &progress, N_("force progress reporting")),
 621                 OPT_BIT(0, "prune", &flags, N_("prune locally removed refs"),
 622                         TRANSPORT_PUSH_PRUNE),
 623                 OPT_BIT(0, "no-verify", &flags, N_("bypass pre-push hook"), TRANSPORT_PUSH_NO_HOOK),
 624                 OPT_BIT(0, "follow-tags", &flags, N_("push missing but relevant tags"),
 625                         TRANSPORT_PUSH_FOLLOW_TAGS),
 626                 OPT_CALLBACK_F(0, "signed", &push_cert, "(yes|no|if-asked)", N_("GPG sign the push"),
 627                                 PARSE_OPT_OPTARG, option_parse_push_signed),
 628                 OPT_BIT(0, "atomic", &flags, N_("request atomic transaction on remote side"), TRANSPORT_PUSH_ATOMIC),
 629                 OPT_STRING_LIST('o', "push-option", &push_options_cmdline, N_("server-specific"), N_("option to transmit")),
 630                 OPT_SET_INT('4', "ipv4", &family, N_("use IPv4 addresses only"),
 631                                 TRANSPORT_FAMILY_IPV4),
 632                 OPT_SET_INT('6', "ipv6", &family, N_("use IPv6 addresses only"),
 633                                 TRANSPORT_FAMILY_IPV6),
 634                 OPT_END()
 635         };
 636
 637         packet_trace_identity("push");
 638         git_config(git_push_config, &flags);
 639         argc = parse_options(argc, argv, prefix, options, push_usage, 0);
 640         push_options = (push_options_cmdline.nr
 641                 ? &push_options_cmdline
 642                 : &push_options_config);
 643         set_push_cert_flags(&flags, push_cert);
 644
 645         if (deleterefs && (tags || (flags & (TRANSPORT_PUSH_ALL | TRANSPORT_PUSH_MIRROR))))
 646                 die(_("options '%s' and '%s' cannot be used together"), "--delete", "--all/--branches/--mirror/--tags");
 647         if (deleterefs && argc < 2)
 648                 die(_("--delete doesn't make sense without any refs"));
 649
 650         if (recurse_submodules == RECURSE_SUBMODULES_CHECK)
 651                 flags |= TRANSPORT_RECURSE_SUBMODULES_CHECK;
 652         else if (recurse_submodules == RECURSE_SUBMODULES_ON_DEMAND)
 653                 flags |= TRANSPORT_RECURSE_SUBMODULES_ON_DEMAND;
 654         else if (recurse_submodules == RECURSE_SUBMODULES_ONLY)
 655                 flags |= TRANSPORT_RECURSE_SUBMODULES_ONLY;
 656
 657         if (tags)
 658                 refspec_append(&rs, "refs/tags/*");
 659
 660         if (argc > 0) {
 661                 repo = argv[0];
 662                 set_refspecs(argv + 1, argc - 1, repo);
 663         }
 664
 665         remote = pushremote_get(repo);
 666         if (!remote) {
 667                 if (repo)
 668                         die(_("bad repository '%s'"), repo);
 669                 die(_("No configured push destination.\n"
 670                     "Either specify the URL from the command-line or configure a remote repository using\n"
 671                     "\n"
 672                     "    git remote add <name> <url>\n"
 673                     "\n"
 674                     "and then push using the remote name\n"
 675                     "\n"
 676                     "    git push <name>\n"));
 677         }
 678
 679         if (remote->mirror)
 680                 flags |= (TRANSPORT_PUSH_MIRROR|TRANSPORT_PUSH_FORCE);
 681
 682         if (flags & TRANSPORT_PUSH_ALL) {
 683                 if (tags)
 684                         die(_("options '%s' and '%s' cannot be used together"), "--all", "--tags");
 685                 if (argc >= 2)
 686                         die(_("--all can't be combined with refspecs"));
 687         }
 688         if (flags & TRANSPORT_PUSH_MIRROR) {
 689                 if (tags)
 690                         die(_("options '%s' and '%s' cannot be used together"), "--mirror", "--tags");
 691                 if (argc >= 2)
 692                         die(_("--mirror can't be combined with refspecs"));
 693         }
 694         if ((flags & TRANSPORT_PUSH_ALL) && (flags & TRANSPORT_PUSH_MIRROR))
 695                 die(_("options '%s' and '%s' cannot be used together"), "--all", "--mirror");
 696
 697         if (!is_empty_cas(&cas) && (flags & TRANSPORT_PUSH_FORCE_IF_INCLUDES))
 698                 cas.use_force_if_includes = 1;
 699
 700         for_each_string_list_item(item, push_options)
 701                 if (strchr(item->string, '\n'))
 702                         die(_("push options must not have new line characters"));
 703
 704         rc = do_push(flags, push_options, remote);
 705         string_list_clear(&push_options_cmdline, 0);
 706         string_list_clear(&push_options_config, 0);
 707         if (rc == -1)
 708                 usage_with_options(push_usage, options);
 709         else
 710                 return rc;
 711 }