git.oblomov.eu Git - git/blob - builtin/push.c

   1 /*
   2  * "git push"
   3  */
   4 #include "cache.h"
   5 #include "refs.h"
   6 #include "run-command.h"
   7 #include "builtin.h"
   8 #include "remote.h"
   9 #include "transport.h"
  10 #include "parse-options.h"
  11 #include "submodule.h"
  12 #include "submodule-config.h"
  13 #include "send-pack.h"
  14
  15 static const char * const push_usage[] = {
  16         N_("git push [<options>] [<repository> [<refspec>...]]"),
  17         NULL,
  18 };
  19
  20 static int thin = 1;
  21 static int deleterefs;
  22 static const char *receivepack;
  23 static int verbosity;
  24 static int progress = -1;
  25 static int recurse_submodules = RECURSE_SUBMODULES_DEFAULT;
  26
  27 static struct push_cas_option cas;
  28
  29 static const char **refspec;
  30 static int refspec_nr;
  31 static int refspec_alloc;
  32
  33 static void add_refspec(const char *ref)
  34 {
  35         refspec_nr++;
  36         ALLOC_GROW(refspec, refspec_nr, refspec_alloc);
  37         refspec[refspec_nr-1] = ref;
  38 }
  39
  40 static const char *map_refspec(const char *ref,
  41                                struct remote *remote, struct ref *local_refs)
  42 {
  43         struct ref *matched = NULL;
  44
  45         /* Does "ref" uniquely name our ref? */
  46         if (count_refspec_match(ref, local_refs, &matched) != 1)
  47                 return ref;
  48
  49         if (remote->push) {
  50                 struct refspec query;
  51                 memset(&query, 0, sizeof(struct refspec));
  52                 query.src = matched->name;
  53                 if (!query_refspecs(remote->push, remote->push_refspec_nr, &query) &&
  54                     query.dst) {
  55                         struct strbuf buf = STRBUF_INIT;
  56                         strbuf_addf(&buf, "%s%s:%s",
  57                                     query.force ? "+" : "",
  58                                     query.src, query.dst);
  59                         return strbuf_detach(&buf, NULL);
  60                 }
  61         }
  62
  63         if (push_default == PUSH_DEFAULT_UPSTREAM &&
  64             starts_with(matched->name, "refs/heads/")) {
  65                 struct branch *branch = branch_get(matched->name + 11);
  66                 if (branch->merge_nr == 1 && branch->merge[0]->src) {
  67                         struct strbuf buf = STRBUF_INIT;
  68                         strbuf_addf(&buf, "%s:%s",
  69                                     ref, branch->merge[0]->src);
  70                         return strbuf_detach(&buf, NULL);
  71                 }
  72         }
  73
  74         return ref;
  75 }
  76
  77 static void set_refspecs(const char **refs, int nr, const char *repo)
  78 {
  79         struct remote *remote = NULL;
  80         struct ref *local_refs = NULL;
  81         int i;
  82
  83         for (i = 0; i < nr; i++) {
  84                 const char *ref = refs[i];
  85                 if (!strcmp("tag", ref)) {
  86                         struct strbuf tagref = STRBUF_INIT;
  87                         if (nr <= ++i)
  88                                 die(_("tag shorthand without <tag>"));
  89                         ref = refs[i];
  90                         if (deleterefs)
  91                                 strbuf_addf(&tagref, ":refs/tags/%s", ref);
  92                         else
  93                                 strbuf_addf(&tagref, "refs/tags/%s", ref);
  94                         ref = strbuf_detach(&tagref, NULL);
  95                 } else if (deleterefs) {
  96                         struct strbuf delref = STRBUF_INIT;
  97                         if (strchr(ref, ':'))
  98                                 die(_("--delete only accepts plain target ref names"));
  99                         strbuf_addf(&delref, ":%s", ref);
 100                         ref = strbuf_detach(&delref, NULL);
 101                 } else if (!strchr(ref, ':')) {
 102                         if (!remote) {
 103                                 /* lazily grab remote and local_refs */
 104                                 remote = remote_get(repo);
 105                                 local_refs = get_local_heads();
 106                         }
 107                         ref = map_refspec(ref, remote, local_refs);
 108                 }
 109                 add_refspec(ref);
 110         }
 111 }
 112
 113 static int push_url_of_remote(struct remote *remote, const char ***url_p)
 114 {
 115         if (remote->pushurl_nr) {
 116                 *url_p = remote->pushurl;
 117                 return remote->pushurl_nr;
 118         }
 119         *url_p = remote->url;
 120         return remote->url_nr;
 121 }
 122
 123 static NORETURN int die_push_simple(struct branch *branch, struct remote *remote) {
 124         /*
 125          * There's no point in using shorten_unambiguous_ref here,
 126          * as the ambiguity would be on the remote side, not what
 127          * we have locally. Plus, this is supposed to be the simple
 128          * mode. If the user is doing something crazy like setting
 129          * upstream to a non-branch, we should probably be showing
 130          * them the big ugly fully qualified ref.
 131          */
 132         const char *advice_maybe = "";
 133         const char *short_upstream = branch->merge[0]->src;
 134
 135         skip_prefix(short_upstream, "refs/heads/", &short_upstream);
 136
 137         /*
 138          * Don't show advice for people who explicitly set
 139          * push.default.
 140          */
 141         if (push_default == PUSH_DEFAULT_UNSPECIFIED)
 142                 advice_maybe = _("\n"
 143                                  "To choose either option permanently, "
 144                                  "see push.default in 'git help config'.");
 145         die(_("The upstream branch of your current branch does not match\n"
 146               "the name of your current branch.  To push to the upstream branch\n"
 147               "on the remote, use\n"
 148               "\n"
 149               "    git push %s HEAD:%s\n"
 150               "\n"
 151               "To push to the branch of the same name on the remote, use\n"
 152               "\n"
 153               "    git push %s %s\n"
 154               "%s"),
 155             remote->name, short_upstream,
 156             remote->name, branch->name, advice_maybe);
 157 }
 158
 159 static const char message_detached_head_die[] =
 160         N_("You are not currently on a branch.\n"
 161            "To push the history leading to the current (detached HEAD)\n"
 162            "state now, use\n"
 163            "\n"
 164            "    git push %s HEAD:<name-of-remote-branch>\n");
 165
 166 static void setup_push_upstream(struct remote *remote, struct branch *branch,
 167                                 int triangular, int simple)
 168 {
 169         struct strbuf refspec = STRBUF_INIT;
 170
 171         if (!branch)
 172                 die(_(message_detached_head_die), remote->name);
 173         if (!branch->merge_nr || !branch->merge || !branch->remote_name)
 174                 die(_("The current branch %s has no upstream branch.\n"
 175                     "To push the current branch and set the remote as upstream, use\n"
 176                     "\n"
 177                     "    git push --set-upstream %s %s\n"),
 178                     branch->name,
 179                     remote->name,
 180                     branch->name);
 181         if (branch->merge_nr != 1)
 182                 die(_("The current branch %s has multiple upstream branches, "
 183                     "refusing to push."), branch->name);
 184         if (triangular)
 185                 die(_("You are pushing to remote '%s', which is not the upstream of\n"
 186                       "your current branch '%s', without telling me what to push\n"
 187                       "to update which remote branch."),
 188                     remote->name, branch->name);
 189
 190         if (simple) {
 191                 /* Additional safety */
 192                 if (strcmp(branch->refname, branch->merge[0]->src))
 193                         die_push_simple(branch, remote);
 194         }
 195
 196         strbuf_addf(&refspec, "%s:%s", branch->name, branch->merge[0]->src);
 197         add_refspec(refspec.buf);
 198 }
 199
 200 static void setup_push_current(struct remote *remote, struct branch *branch)
 201 {
 202         if (!branch)
 203                 die(_(message_detached_head_die), remote->name);
 204         add_refspec(branch->name);
 205 }
 206
 207 static char warn_unspecified_push_default_msg[] =
 208 N_("push.default is unset; its implicit value has changed in\n"
 209    "Git 2.0 from 'matching' to 'simple'. To squelch this message\n"
 210    "and maintain the traditional behavior, use:\n"
 211    "\n"
 212    "  git config --global push.default matching\n"
 213    "\n"
 214    "To squelch this message and adopt the new behavior now, use:\n"
 215    "\n"
 216    "  git config --global push.default simple\n"
 217    "\n"
 218    "When push.default is set to 'matching', git will push local branches\n"
 219    "to the remote branches that already exist with the same name.\n"
 220    "\n"
 221    "Since Git 2.0, Git defaults to the more conservative 'simple'\n"
 222    "behavior, which only pushes the current branch to the corresponding\n"
 223    "remote branch that 'git pull' uses to update the current branch.\n"
 224    "\n"
 225    "See 'git help config' and search for 'push.default' for further information.\n"
 226    "(the 'simple' mode was introduced in Git 1.7.11. Use the similar mode\n"
 227    "'current' instead of 'simple' if you sometimes use older versions of Git)");
 228
 229 static void warn_unspecified_push_default_configuration(void)
 230 {
 231         static int warn_once;
 232
 233         if (warn_once++)
 234                 return;
 235         warning("%s\n", _(warn_unspecified_push_default_msg));
 236 }
 237
 238 static int is_workflow_triangular(struct remote *remote)
 239 {
 240         struct remote *fetch_remote = remote_get(NULL);
 241         return (fetch_remote && fetch_remote != remote);
 242 }
 243
 244 static void setup_default_push_refspecs(struct remote *remote)
 245 {
 246         struct branch *branch = branch_get(NULL);
 247         int triangular = is_workflow_triangular(remote);
 248
 249         switch (push_default) {
 250         default:
 251         case PUSH_DEFAULT_MATCHING:
 252                 add_refspec(":");
 253                 break;
 254
 255         case PUSH_DEFAULT_UNSPECIFIED:
 256                 warn_unspecified_push_default_configuration();
 257                 /* fallthru */
 258
 259         case PUSH_DEFAULT_SIMPLE:
 260                 if (triangular)
 261                         setup_push_current(remote, branch);
 262                 else
 263                         setup_push_upstream(remote, branch, triangular, 1);
 264                 break;
 265
 266         case PUSH_DEFAULT_UPSTREAM:
 267                 setup_push_upstream(remote, branch, triangular, 0);
 268                 break;
 269
 270         case PUSH_DEFAULT_CURRENT:
 271                 setup_push_current(remote, branch);
 272                 break;
 273
 274         case PUSH_DEFAULT_NOTHING:
 275                 die(_("You didn't specify any refspecs to push, and "
 276                     "push.default is \"nothing\"."));
 277                 break;
 278         }
 279 }
 280
 281 static const char message_advice_pull_before_push[] =
 282         N_("Updates were rejected because the tip of your current branch is behind\n"
 283            "its remote counterpart. Integrate the remote changes (e.g.\n"
 284            "'git pull ...') before pushing again.\n"
 285            "See the 'Note about fast-forwards' in 'git push --help' for details.");
 286
 287 static const char message_advice_checkout_pull_push[] =
 288         N_("Updates were rejected because a pushed branch tip is behind its remote\n"
 289            "counterpart. Check out this branch and integrate the remote changes\n"
 290            "(e.g. 'git pull ...') before pushing again.\n"
 291            "See the 'Note about fast-forwards' in 'git push --help' for details.");
 292
 293 static const char message_advice_ref_fetch_first[] =
 294         N_("Updates were rejected because the remote contains work that you do\n"
 295            "not have locally. This is usually caused by another repository pushing\n"
 296            "to the same ref. You may want to first integrate the remote changes\n"
 297            "(e.g., 'git pull ...') before pushing again.\n"
 298            "See the 'Note about fast-forwards' in 'git push --help' for details.");
 299
 300 static const char message_advice_ref_already_exists[] =
 301         N_("Updates were rejected because the tag already exists in the remote.");
 302
 303 static const char message_advice_ref_needs_force[] =
 304         N_("You cannot update a remote ref that points at a non-commit object,\n"
 305            "or update a remote ref to make it point at a non-commit object,\n"
 306            "without using the '--force' option.\n");
 307
 308 static void advise_pull_before_push(void)
 309 {
 310         if (!advice_push_non_ff_current || !advice_push_update_rejected)
 311                 return;
 312         advise(_(message_advice_pull_before_push));
 313 }
 314
 315 static void advise_checkout_pull_push(void)
 316 {
 317         if (!advice_push_non_ff_matching || !advice_push_update_rejected)
 318                 return;
 319         advise(_(message_advice_checkout_pull_push));
 320 }
 321
 322 static void advise_ref_already_exists(void)
 323 {
 324         if (!advice_push_already_exists || !advice_push_update_rejected)
 325                 return;
 326         advise(_(message_advice_ref_already_exists));
 327 }
 328
 329 static void advise_ref_fetch_first(void)
 330 {
 331         if (!advice_push_fetch_first || !advice_push_update_rejected)
 332                 return;
 333         advise(_(message_advice_ref_fetch_first));
 334 }
 335
 336 static void advise_ref_needs_force(void)
 337 {
 338         if (!advice_push_needs_force || !advice_push_update_rejected)
 339                 return;
 340         advise(_(message_advice_ref_needs_force));
 341 }
 342
 343 static int push_with_options(struct transport *transport, int flags)
 344 {
 345         int err;
 346         unsigned int reject_reasons;
 347
 348         transport_set_verbosity(transport, verbosity, progress);
 349
 350         if (receivepack)
 351                 transport_set_option(transport,
 352                                      TRANS_OPT_RECEIVEPACK, receivepack);
 353         transport_set_option(transport, TRANS_OPT_THIN, thin ? "yes" : NULL);
 354
 355         if (!is_empty_cas(&cas)) {
 356                 if (!transport->smart_options)
 357                         die("underlying transport does not support --%s option",
 358                             CAS_OPT_NAME);
 359                 transport->smart_options->cas = &cas;
 360         }
 361
 362         if (verbosity > 0)
 363                 fprintf(stderr, _("Pushing to %s\n"), transport->url);
 364         err = transport_push(transport, refspec_nr, refspec, flags,
 365                              &reject_reasons);
 366         if (err != 0)
 367                 error(_("failed to push some refs to '%s'"), transport->url);
 368
 369         err |= transport_disconnect(transport);
 370         if (!err)
 371                 return 0;
 372
 373         if (reject_reasons & REJECT_NON_FF_HEAD) {
 374                 advise_pull_before_push();
 375         } else if (reject_reasons & REJECT_NON_FF_OTHER) {
 376                 advise_checkout_pull_push();
 377         } else if (reject_reasons & REJECT_ALREADY_EXISTS) {
 378                 advise_ref_already_exists();
 379         } else if (reject_reasons & REJECT_FETCH_FIRST) {
 380                 advise_ref_fetch_first();
 381         } else if (reject_reasons & REJECT_NEEDS_FORCE) {
 382                 advise_ref_needs_force();
 383         }
 384
 385         return 1;
 386 }
 387
 388 static int do_push(const char *repo, int flags)
 389 {
 390         int i, errs;
 391         struct remote *remote = pushremote_get(repo);
 392         const char **url;
 393         int url_nr;
 394
 395         if (!remote) {
 396                 if (repo)
 397                         die(_("bad repository '%s'"), repo);
 398                 die(_("No configured push destination.\n"
 399                     "Either specify the URL from the command-line or configure a remote repository using\n"
 400                     "\n"
 401                     "    git remote add <name> <url>\n"
 402                     "\n"
 403                     "and then push using the remote name\n"
 404                     "\n"
 405                     "    git push <name>\n"));
 406         }
 407
 408         if (remote->mirror)
 409                 flags |= (TRANSPORT_PUSH_MIRROR|TRANSPORT_PUSH_FORCE);
 410
 411         if ((flags & TRANSPORT_PUSH_ALL) && refspec) {
 412                 if (!strcmp(*refspec, "refs/tags/*"))
 413                         return error(_("--all and --tags are incompatible"));
 414                 return error(_("--all can't be combined with refspecs"));
 415         }
 416
 417         if ((flags & TRANSPORT_PUSH_MIRROR) && refspec) {
 418                 if (!strcmp(*refspec, "refs/tags/*"))
 419                         return error(_("--mirror and --tags are incompatible"));
 420                 return error(_("--mirror can't be combined with refspecs"));
 421         }
 422
 423         if ((flags & (TRANSPORT_PUSH_ALL|TRANSPORT_PUSH_MIRROR)) ==
 424                                 (TRANSPORT_PUSH_ALL|TRANSPORT_PUSH_MIRROR)) {
 425                 return error(_("--all and --mirror are incompatible"));
 426         }
 427
 428         if (!refspec && !(flags & TRANSPORT_PUSH_ALL)) {
 429                 struct branch *branch = branch_get(NULL);
 430                 /* Is there a publish branch */
 431                 if (branch && branch->pushremote_name && !strcmp(remote->name, branch->pushremote_name) &&
 432                                 branch->push_name) {
 433                         struct strbuf refspec = STRBUF_INIT;
 434                         strbuf_addf(&refspec, "%s:%s", branch->name, branch->push_name);
 435                         add_refspec(refspec.buf);
 436                 } else if (remote->push_refspec_nr) {
 437                         refspec = remote->push_refspec;
 438                         refspec_nr = remote->push_refspec_nr;
 439                 } else if (!(flags & TRANSPORT_PUSH_MIRROR))
 440                         setup_default_push_refspecs(remote);
 441         }
 442         errs = 0;
 443         url_nr = push_url_of_remote(remote, &url);
 444         if (url_nr) {
 445                 for (i = 0; i < url_nr; i++) {
 446                         struct transport *transport =
 447                                 transport_get(remote, url[i]);
 448                         if (push_with_options(transport, flags))
 449                                 errs++;
 450                 }
 451         } else {
 452                 struct transport *transport =
 453                         transport_get(remote, NULL);
 454
 455                 if (push_with_options(transport, flags))
 456                         errs++;
 457         }
 458         return !!errs;
 459 }
 460
 461 static int option_parse_recurse_submodules(const struct option *opt,
 462                                    const char *arg, int unset)
 463 {
 464         int *recurse_submodules = opt->value;
 465
 466         if (unset)
 467                 *recurse_submodules = RECURSE_SUBMODULES_OFF;
 468         else if (arg)
 469                 *recurse_submodules = parse_push_recurse_submodules_arg(opt->long_name, arg);
 470         else
 471                 die("%s missing parameter", opt->long_name);
 472
 473         return 0;
 474 }
 475
 476 static void set_push_cert_flags(int *flags, int v)
 477 {
 478         switch (v) {
 479         case SEND_PACK_PUSH_CERT_NEVER:
 480                 *flags &= ~(TRANSPORT_PUSH_CERT_ALWAYS | TRANSPORT_PUSH_CERT_IF_ASKED);
 481                 break;
 482         case SEND_PACK_PUSH_CERT_ALWAYS:
 483                 *flags |= TRANSPORT_PUSH_CERT_ALWAYS;
 484                 *flags &= ~TRANSPORT_PUSH_CERT_IF_ASKED;
 485                 break;
 486         case SEND_PACK_PUSH_CERT_IF_ASKED:
 487                 *flags |= TRANSPORT_PUSH_CERT_IF_ASKED;
 488                 *flags &= ~TRANSPORT_PUSH_CERT_ALWAYS;
 489                 break;
 490         }
 491 }
 492
 493
 494 static int git_push_config(const char *k, const char *v, void *cb)
 495 {
 496         int *flags = cb;
 497         int status;
 498
 499         status = git_gpg_config(k, v, NULL);
 500         if (status)
 501                 return status;
 502
 503         if (!strcmp(k, "push.followtags")) {
 504                 if (git_config_bool(k, v))
 505                         *flags |= TRANSPORT_PUSH_FOLLOW_TAGS;
 506                 else
 507                         *flags &= ~TRANSPORT_PUSH_FOLLOW_TAGS;
 508                 return 0;
 509         } else if (!strcmp(k, "push.gpgsign")) {
 510                 const char *value;
 511                 if (!git_config_get_value("push.gpgsign", &value)) {
 512                         switch (git_config_maybe_bool("push.gpgsign", value)) {
 513                         case 0:
 514                                 set_push_cert_flags(flags, SEND_PACK_PUSH_CERT_NEVER);
 515                                 break;
 516                         case 1:
 517                                 set_push_cert_flags(flags, SEND_PACK_PUSH_CERT_ALWAYS);
 518                                 break;
 519                         default:
 520                                 if (value && !strcasecmp(value, "if-asked"))
 521                                         set_push_cert_flags(flags, SEND_PACK_PUSH_CERT_IF_ASKED);
 522                                 else
 523                                         return error("Invalid value for '%s'", k);
 524                         }
 525                 }
 526         } else if (!strcmp(k, "push.recursesubmodules")) {
 527                 const char *value;
 528                 if (!git_config_get_value("push.recursesubmodules", &value))
 529                         recurse_submodules = parse_push_recurse_submodules_arg(k, value);
 530         }
 531
 532         return git_default_config(k, v, NULL);
 533 }
 534
 535 int cmd_push(int argc, const char **argv, const char *prefix)
 536 {
 537         int flags = 0;
 538         int tags = 0;
 539         int push_cert = -1;
 540         int rc;
 541         const char *repo = NULL;        /* default repository */
 542         struct option options[] = {
 543                 OPT__VERBOSITY(&verbosity),
 544                 OPT_STRING( 0 , "repo", &repo, N_("repository"), N_("repository")),
 545                 OPT_BIT( 0 , "all", &flags, N_("push all refs"), TRANSPORT_PUSH_ALL),
 546                 OPT_BIT( 0 , "mirror", &flags, N_("mirror all refs"),
 547                             (TRANSPORT_PUSH_MIRROR|TRANSPORT_PUSH_FORCE)),
 548                 OPT_BOOL( 0, "delete", &deleterefs, N_("delete refs")),
 549                 OPT_BOOL( 0 , "tags", &tags, N_("push tags (can't be used with --all or --mirror)")),
 550                 OPT_BIT('n' , "dry-run", &flags, N_("dry run"), TRANSPORT_PUSH_DRY_RUN),
 551                 OPT_BIT( 0,  "porcelain", &flags, N_("machine-readable output"), TRANSPORT_PUSH_PORCELAIN),
 552                 OPT_BIT('f', "force", &flags, N_("force updates"), TRANSPORT_PUSH_FORCE),
 553                 { OPTION_CALLBACK,
 554                   0, CAS_OPT_NAME, &cas, N_("refname>:<expect"),
 555                   N_("require old value of ref to be at this value"),
 556                   PARSE_OPT_OPTARG, parseopt_push_cas_option },
 557                 { OPTION_CALLBACK, 0, "recurse-submodules", &recurse_submodules, "check|on-demand|no",
 558                         N_("control recursive pushing of submodules"),
 559                         PARSE_OPT_OPTARG, option_parse_recurse_submodules },
 560                 OPT_BOOL( 0 , "thin", &thin, N_("use thin pack")),
 561                 OPT_STRING( 0 , "receive-pack", &receivepack, "receive-pack", N_("receive pack program")),
 562                 OPT_STRING( 0 , "exec", &receivepack, "receive-pack", N_("receive pack program")),
 563                 OPT_BIT('u', "set-upstream", &flags, N_("set upstream for git pull/status"),
 564                         TRANSPORT_PUSH_SET_UPSTREAM),
 565                 OPT_BIT('p', "set-publish", &flags, N_("set publish for git pull/status"),
 566                         TRANSPORT_PUSH_SET_PUBLISH),
 567                 OPT_BOOL(0, "progress", &progress, N_("force progress reporting")),
 568                 OPT_BIT(0, "prune", &flags, N_("prune locally removed refs"),
 569                         TRANSPORT_PUSH_PRUNE),
 570                 OPT_BIT(0, "no-verify", &flags, N_("bypass pre-push hook"), TRANSPORT_PUSH_NO_HOOK),
 571                 OPT_BIT(0, "follow-tags", &flags, N_("push missing but relevant tags"),
 572                         TRANSPORT_PUSH_FOLLOW_TAGS),
 573                 { OPTION_CALLBACK,
 574                   0, "signed", &push_cert, "yes|no|if-asked", N_("GPG sign the push"),
 575                   PARSE_OPT_OPTARG, option_parse_push_signed },
 576                 OPT_BIT(0, "atomic", &flags, N_("request atomic transaction on remote side"), TRANSPORT_PUSH_ATOMIC),
 577                 OPT_END()
 578         };
 579
 580         packet_trace_identity("push");
 581         git_config(git_push_config, &flags);
 582         argc = parse_options(argc, argv, prefix, options, push_usage, 0);
 583         set_push_cert_flags(&flags, push_cert);
 584
 585         if (deleterefs && (tags || (flags & (TRANSPORT_PUSH_ALL | TRANSPORT_PUSH_MIRROR))))
 586                 die(_("--delete is incompatible with --all, --mirror and --tags"));
 587         if (deleterefs && argc < 2)
 588                 die(_("--delete doesn't make sense without any refs"));
 589
 590         if (recurse_submodules == RECURSE_SUBMODULES_CHECK)
 591                 flags |= TRANSPORT_RECURSE_SUBMODULES_CHECK;
 592         else if (recurse_submodules == RECURSE_SUBMODULES_ON_DEMAND)
 593                 flags |= TRANSPORT_RECURSE_SUBMODULES_ON_DEMAND;
 594
 595         if (tags)
 596                 add_refspec("refs/tags/*");
 597
 598         if (argc > 0) {
 599                 repo = argv[0];
 600                 set_refspecs(argv + 1, argc - 1, repo);
 601         }
 602
 603         rc = do_push(repo, flags);
 604         if (rc == -1)
 605                 usage_with_options(push_usage, options);
 606         else
 607                 return rc;
 608 }