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