branch.c

   1 #define USE_THE_REPOSITORY_VARIABLE
   2
   3 #include "git-compat-util.h"
   4 #include "advice.h"
   5 #include "config.h"
   6 #include "branch.h"
   7 #include "environment.h"
   8 #include "gettext.h"
   9 #include "hex.h"
  10 #include "object-name.h"
  11 #include "path.h"
  12 #include "refs.h"
  13 #include "refspec.h"
  14 #include "remote.h"
  15 #include "repository.h"
  16 #include "sequencer.h"
  17 #include "commit.h"
  18 #include "worktree.h"
  19 #include "submodule-config.h"
  20 #include "run-command.h"
  21 #include "strmap.h"
  22
  23 struct tracking {
  24         struct refspec_item spec;
  25         struct string_list *srcs;
  26         const char *remote;
  27         int matches;
  28 };
  29
  30 struct find_tracked_branch_cb {
  31         struct tracking *tracking;
  32         struct string_list ambiguous_remotes;
  33 };
  34
  35 static int find_tracked_branch(struct remote *remote, void *priv)
  36 {
  37         struct find_tracked_branch_cb *ftb = priv;
  38         struct tracking *tracking = ftb->tracking;
  39
  40         if (!remote_find_tracking(remote, &tracking->spec)) {
  41                 switch (++tracking->matches) {
  42                 case 1:
  43                         string_list_append_nodup(tracking->srcs, tracking->spec.src);
  44                         tracking->remote = remote->name;
  45                         break;
  46                 case 2:
  47                         /* there are at least two remotes; backfill the first one */
  48                         string_list_append(&ftb->ambiguous_remotes, tracking->remote);
  49                         /* fall through */
  50                 default:
  51                         string_list_append(&ftb->ambiguous_remotes, remote->name);
  52                         free(tracking->spec.src);
  53                         string_list_clear(tracking->srcs, 0);
  54                 break;
  55                 }
  56                 /* remote_find_tracking() searches by src if present */
  57                 tracking->spec.src = NULL;
  58         }
  59         return 0;
  60 }
  61
  62 static int should_setup_rebase(const char *origin)
  63 {
  64         switch (autorebase) {
  65         case AUTOREBASE_NEVER:
  66                 return 0;
  67         case AUTOREBASE_LOCAL:
  68                 return origin == NULL;
  69         case AUTOREBASE_REMOTE:
  70                 return origin != NULL;
  71         case AUTOREBASE_ALWAYS:
  72                 return 1;
  73         }
  74         return 0;
  75 }
  76
  77 /**
  78  * Install upstream tracking configuration for a branch; specifically, add
  79  * `branch.<name>.remote` and `branch.<name>.merge` entries.
  80  *
  81  * `flag` contains integer flags for options; currently only
  82  * BRANCH_CONFIG_VERBOSE is checked.
  83  *
  84  * `local` is the name of the branch whose configuration we're installing.
  85  *
  86  * `origin` is the name of the remote owning the upstream branches. NULL means
  87  * the upstream branches are local to this repo.
  88  *
  89  * `remotes` is a list of refs that are upstream of local
  90  */
  91 static int install_branch_config_multiple_remotes(int flag, const char *local,
  92                 const char *origin, struct string_list *remotes)
  93 {
  94         const char *shortname = NULL;
  95         struct strbuf key = STRBUF_INIT;
  96         struct string_list_item *item;
  97         int rebasing = should_setup_rebase(origin);
  98
  99         if (!remotes->nr)
 100                 BUG("must provide at least one remote for branch config");
 101         if (rebasing && remotes->nr > 1)
 102                 die(_("cannot inherit upstream tracking configuration of "
 103                       "multiple refs when rebasing is requested"));
 104
 105         /*
 106          * If the new branch is trying to track itself, something has gone
 107          * wrong. Warn the user and don't proceed any further.
 108          */
 109         if (!origin)
 110                 for_each_string_list_item(item, remotes)
 111                         if (skip_prefix(item->string, "refs/heads/", &shortname)
 112                             && !strcmp(local, shortname)) {
 113                                 warning(_("not setting branch '%s' as its own upstream"),
 114                                         local);
 115                                 return 0;
 116                         }
 117
 118         strbuf_addf(&key, "branch.%s.remote", local);
 119         if (git_config_set_gently(key.buf, origin ? origin : ".") < 0)
 120                 goto out_err;
 121
 122         strbuf_reset(&key);
 123         strbuf_addf(&key, "branch.%s.merge", local);
 124         /*
 125          * We want to overwrite any existing config with all the branches in
 126          * "remotes". Override any existing config, then write our branches. If
 127          * more than one is provided, use CONFIG_REGEX_NONE to preserve what
 128          * we've written so far.
 129          */
 130         if (git_config_set_gently(key.buf, NULL) < 0)
 131                 goto out_err;
 132         for_each_string_list_item(item, remotes)
 133                 if (git_config_set_multivar_gently(key.buf, item->string, CONFIG_REGEX_NONE, 0) < 0)
 134                         goto out_err;
 135
 136         if (rebasing) {
 137                 strbuf_reset(&key);
 138                 strbuf_addf(&key, "branch.%s.rebase", local);
 139                 if (git_config_set_gently(key.buf, "true") < 0)
 140                         goto out_err;
 141         }
 142         strbuf_release(&key);
 143
 144         if (flag & BRANCH_CONFIG_VERBOSE) {
 145                 struct strbuf tmp_ref_name = STRBUF_INIT;
 146                 struct string_list friendly_ref_names = STRING_LIST_INIT_DUP;
 147
 148                 for_each_string_list_item(item, remotes) {
 149                         shortname = item->string;
 150                         skip_prefix(shortname, "refs/heads/", &shortname);
 151                         if (origin) {
 152                                 strbuf_addf(&tmp_ref_name, "%s/%s",
 153                                             origin, shortname);
 154                                 string_list_append_nodup(
 155                                         &friendly_ref_names,
 156                                         strbuf_detach(&tmp_ref_name, NULL));
 157                         } else {
 158                                 string_list_append(
 159                                         &friendly_ref_names, shortname);
 160                         }
 161                 }
 162
 163                 if (remotes->nr == 1) {
 164                         /*
 165                          * Rebasing is only allowed in the case of a single
 166                          * upstream branch.
 167                          */
 168                         printf_ln(rebasing ?
 169                                 _("branch '%s' set up to track '%s' by rebasing.") :
 170                                 _("branch '%s' set up to track '%s'."),
 171                                 local, friendly_ref_names.items[0].string);
 172                 } else {
 173                         printf_ln(_("branch '%s' set up to track:"), local);
 174                         for_each_string_list_item(item, &friendly_ref_names)
 175                                 printf_ln("  %s", item->string);
 176                 }
 177
 178                 string_list_clear(&friendly_ref_names, 0);
 179         }
 180
 181         return 0;
 182
 183 out_err:
 184         strbuf_release(&key);
 185         error(_("unable to write upstream branch configuration"));
 186
 187         advise(_("\nAfter fixing the error cause you may try to fix up\n"
 188                 "the remote tracking information by invoking:"));
 189         if (remotes->nr == 1)
 190                 advise("  git branch --set-upstream-to=%s%s%s",
 191                         origin ? origin : "",
 192                         origin ? "/" : "",
 193                         remotes->items[0].string);
 194         else {
 195                 advise("  git config --add branch.\"%s\".remote %s",
 196                         local, origin ? origin : ".");
 197                 for_each_string_list_item(item, remotes)
 198                         advise("  git config --add branch.\"%s\".merge %s",
 199                                 local, item->string);
 200         }
 201
 202         return -1;
 203 }
 204
 205 int install_branch_config(int flag, const char *local, const char *origin,
 206                 const char *remote)
 207 {
 208         int ret;
 209         struct string_list remotes = STRING_LIST_INIT_DUP;
 210
 211         string_list_append(&remotes, remote);
 212         ret = install_branch_config_multiple_remotes(flag, local, origin, &remotes);
 213         string_list_clear(&remotes, 0);
 214         return ret;
 215 }
 216
 217 static int inherit_tracking(struct tracking *tracking, const char *orig_ref)
 218 {
 219         const char *bare_ref;
 220         struct branch *branch;
 221         int i;
 222
 223         bare_ref = orig_ref;
 224         skip_prefix(orig_ref, "refs/heads/", &bare_ref);
 225
 226         branch = branch_get(bare_ref);
 227         if (!branch->remote_name) {
 228                 warning(_("asked to inherit tracking from '%s', but no remote is set"),
 229                         bare_ref);
 230                 return -1;
 231         }
 232
 233         if (branch->merge_nr < 1 || !branch->merge_name || !branch->merge_name[0]) {
 234                 warning(_("asked to inherit tracking from '%s', but no merge configuration is set"),
 235                         bare_ref);
 236                 return -1;
 237         }
 238
 239         tracking->remote = branch->remote_name;
 240         for (i = 0; i < branch->merge_nr; i++)
 241                 string_list_append(tracking->srcs, branch->merge_name[i]);
 242         return 0;
 243 }
 244
 245 /*
 246  * Used internally to set the branch.<new_ref>.{remote,merge} config
 247  * settings so that branch 'new_ref' tracks 'orig_ref'. Unlike
 248  * dwim_and_setup_tracking(), this does not do DWIM, i.e. "origin/main"
 249  * will not be expanded to "refs/remotes/origin/main", so it is not safe
 250  * for 'orig_ref' to be raw user input.
 251  */
 252 static void setup_tracking(const char *new_ref, const char *orig_ref,
 253                            enum branch_track track, int quiet)
 254 {
 255         struct tracking tracking;
 256         struct string_list tracking_srcs = STRING_LIST_INIT_DUP;
 257         int config_flags = quiet ? 0 : BRANCH_CONFIG_VERBOSE;
 258         struct find_tracked_branch_cb ftb_cb = {
 259                 .tracking = &tracking,
 260                 .ambiguous_remotes = STRING_LIST_INIT_DUP,
 261         };
 262
 263         if (!track)
 264                 BUG("asked to set up tracking, but tracking is disallowed");
 265
 266         memset(&tracking, 0, sizeof(tracking));
 267         tracking.spec.dst = (char *)orig_ref;
 268         tracking.srcs = &tracking_srcs;
 269         if (track != BRANCH_TRACK_INHERIT)
 270                 for_each_remote(find_tracked_branch, &ftb_cb);
 271         else if (inherit_tracking(&tracking, orig_ref))
 272                 goto cleanup;
 273
 274         if (!tracking.matches)
 275                 switch (track) {
 276                 /* If ref is not remote, still use local */
 277                 case BRANCH_TRACK_ALWAYS:
 278                 case BRANCH_TRACK_EXPLICIT:
 279                 case BRANCH_TRACK_OVERRIDE:
 280                 /* Remote matches not evaluated */
 281                 case BRANCH_TRACK_INHERIT:
 282                         break;
 283                 /* Otherwise, if no remote don't track */
 284                 default:
 285                         goto cleanup;
 286                 }
 287
 288         /*
 289          * This check does not apply to BRANCH_TRACK_INHERIT;
 290          * that supports multiple entries in tracking_srcs but
 291          * leaves tracking.matches at 0.
 292          */
 293         if (tracking.matches > 1) {
 294                 int status = die_message(_("not tracking: ambiguous information for ref '%s'"),
 295                                             orig_ref);
 296                 if (advice_enabled(ADVICE_AMBIGUOUS_FETCH_REFSPEC)) {
 297                         struct strbuf remotes_advice = STRBUF_INIT;
 298                         struct string_list_item *item;
 299
 300                         for_each_string_list_item(item, &ftb_cb.ambiguous_remotes)
 301                                 /*
 302                                  * TRANSLATORS: This is a line listing a remote with duplicate
 303                                  * refspecs in the advice message below. For RTL languages you'll
 304                                  * probably want to swap the "%s" and leading "  " space around.
 305                                  */
 306                                 strbuf_addf(&remotes_advice, _("  %s\n"), item->string);
 307
 308                         /*
 309                          * TRANSLATORS: The second argument is a \n-delimited list of
 310                          * duplicate refspecs, composed above.
 311                          */
 312                         advise(_("There are multiple remotes whose fetch refspecs map to the remote\n"
 313                                  "tracking ref '%s':\n"
 314                                  "%s"
 315                                  "\n"
 316                                  "This is typically a configuration error.\n"
 317                                  "\n"
 318                                  "To support setting up tracking branches, ensure that\n"
 319                                  "different remotes' fetch refspecs map into different\n"
 320                                  "tracking namespaces."), orig_ref,
 321                                remotes_advice.buf);
 322                         strbuf_release(&remotes_advice);
 323                 }
 324                 exit(status);
 325         }
 326
 327         if (track == BRANCH_TRACK_SIMPLE) {
 328                 /*
 329                  * Only track if remote branch name matches.
 330                  * Reaching into items[0].string is safe because
 331                  * we know there is at least one and not more than
 332                  * one entry (because only BRANCH_TRACK_INHERIT can
 333                  * produce more than one entry).
 334                  */
 335                 const char *tracked_branch;
 336                 if (!skip_prefix(tracking.srcs->items[0].string,
 337                                  "refs/heads/", &tracked_branch) ||
 338                     strcmp(tracked_branch, new_ref))
 339                         goto cleanup;
 340         }
 341
 342         if (tracking.srcs->nr < 1)
 343                 string_list_append(tracking.srcs, orig_ref);
 344         if (install_branch_config_multiple_remotes(config_flags, new_ref,
 345                                 tracking.remote, tracking.srcs) < 0)
 346                 exit(1);
 347
 348 cleanup:
 349         string_list_clear(&tracking_srcs, 0);
 350         string_list_clear(&ftb_cb.ambiguous_remotes, 0);
 351 }
 352
 353 int read_branch_desc(struct strbuf *buf, const char *branch_name)
 354 {
 355         char *v = NULL;
 356         struct strbuf name = STRBUF_INIT;
 357         strbuf_addf(&name, "branch.%s.description", branch_name);
 358         if (git_config_get_string(name.buf, &v)) {
 359                 strbuf_release(&name);
 360                 return -1;
 361         }
 362         strbuf_addstr(buf, v);
 363         free(v);
 364         strbuf_release(&name);
 365         return 0;
 366 }
 367
 368 /*
 369  * Check if 'name' can be a valid name for a branch; die otherwise.
 370  * Return 1 if the named branch already exists; return 0 otherwise.
 371  * Fill ref with the full refname for the branch.
 372  */
 373 int validate_branchname(const char *name, struct strbuf *ref)
 374 {
 375         if (strbuf_check_branch_ref(ref, name)) {
 376                 int code = die_message(_("'%s' is not a valid branch name"), name);
 377                 advise_if_enabled(ADVICE_REF_SYNTAX,
 378                                   _("See `man git check-ref-format`"));
 379                 exit(code);
 380         }
 381
 382         return refs_ref_exists(get_main_ref_store(the_repository), ref->buf);
 383 }
 384
 385 static int initialized_checked_out_branches;
 386 static struct strmap current_checked_out_branches = STRMAP_INIT;
 387
 388 static void prepare_checked_out_branches(void)
 389 {
 390         int i = 0;
 391         struct worktree **worktrees;
 392
 393         if (initialized_checked_out_branches)
 394                 return;
 395         initialized_checked_out_branches = 1;
 396
 397         worktrees = get_worktrees();
 398
 399         while (worktrees[i]) {
 400                 char *old;
 401                 struct wt_status_state state = { 0 };
 402                 struct worktree *wt = worktrees[i++];
 403                 struct string_list update_refs = STRING_LIST_INIT_DUP;
 404
 405                 if (wt->is_bare)
 406                         continue;
 407
 408                 if (wt->head_ref) {
 409                         old = strmap_put(&current_checked_out_branches,
 410                                          wt->head_ref,
 411                                          xstrdup(wt->path));
 412                         free(old);
 413                 }
 414
 415                 if (wt_status_check_rebase(wt, &state) &&
 416                     (state.rebase_in_progress || state.rebase_interactive_in_progress) &&
 417                     state.branch) {
 418                         struct strbuf ref = STRBUF_INIT;
 419                         strbuf_addf(&ref, "refs/heads/%s", state.branch);
 420                         old = strmap_put(&current_checked_out_branches,
 421                                          ref.buf,
 422                                          xstrdup(wt->path));
 423                         free(old);
 424                         strbuf_release(&ref);
 425                 }
 426                 wt_status_state_free_buffers(&state);
 427
 428                 if (wt_status_check_bisect(wt, &state) &&
 429                     state.bisecting_from) {
 430                         struct strbuf ref = STRBUF_INIT;
 431                         strbuf_addf(&ref, "refs/heads/%s", state.bisecting_from);
 432                         old = strmap_put(&current_checked_out_branches,
 433                                          ref.buf,
 434                                          xstrdup(wt->path));
 435                         free(old);
 436                         strbuf_release(&ref);
 437                 }
 438                 wt_status_state_free_buffers(&state);
 439
 440                 if (!sequencer_get_update_refs_state(get_worktree_git_dir(wt),
 441                                                      &update_refs)) {
 442                         struct string_list_item *item;
 443                         for_each_string_list_item(item, &update_refs) {
 444                                 old = strmap_put(&current_checked_out_branches,
 445                                                  item->string,
 446                                                  xstrdup(wt->path));
 447                                 free(old);
 448                         }
 449                         string_list_clear(&update_refs, 1);
 450                 }
 451         }
 452
 453         free_worktrees(worktrees);
 454 }
 455
 456 const char *branch_checked_out(const char *refname)
 457 {
 458         prepare_checked_out_branches();
 459         return strmap_get(&current_checked_out_branches, refname);
 460 }
 461
 462 /*
 463  * Check if a branch 'name' can be created as a new branch; die otherwise.
 464  * 'force' can be used when it is OK for the named branch already exists.
 465  * Return 1 if the named branch already exists; return 0 otherwise.
 466  * Fill ref with the full refname for the branch.
 467  */
 468 int validate_new_branchname(const char *name, struct strbuf *ref, int force)
 469 {
 470         const char *path;
 471         if (!validate_branchname(name, ref))
 472                 return 0;
 473
 474         if (!force)
 475                 die(_("a branch named '%s' already exists"),
 476                     ref->buf + strlen("refs/heads/"));
 477
 478         if ((path = branch_checked_out(ref->buf)))
 479                 die(_("cannot force update the branch '%s' "
 480                       "used by worktree at '%s'"),
 481                     ref->buf + strlen("refs/heads/"), path);
 482
 483         return 1;
 484 }
 485
 486 static int check_tracking_branch(struct remote *remote, void *cb_data)
 487 {
 488         char *tracking_branch = cb_data;
 489         struct refspec_item query;
 490         int res;
 491         memset(&query, 0, sizeof(struct refspec_item));
 492         query.dst = tracking_branch;
 493         res = !remote_find_tracking(remote, &query);
 494         free(query.src);
 495         return res;
 496 }
 497
 498 static int validate_remote_tracking_branch(char *ref)
 499 {
 500         return !for_each_remote(check_tracking_branch, ref);
 501 }
 502
 503 static const char upstream_not_branch[] =
 504 N_("cannot set up tracking information; starting point '%s' is not a branch");
 505 static const char upstream_missing[] =
 506 N_("the requested upstream branch '%s' does not exist");
 507 static const char upstream_advice[] =
 508 N_("\n"
 509 "If you are planning on basing your work on an upstream\n"
 510 "branch that already exists at the remote, you may need to\n"
 511 "run \"git fetch\" to retrieve it.\n"
 512 "\n"
 513 "If you are planning to push out a new local branch that\n"
 514 "will track its remote counterpart, you may want to use\n"
 515 "\"git push -u\" to set the upstream config as you push.");
 516
 517 /**
 518  * DWIMs a user-provided ref to determine the starting point for a
 519  * branch and validates it, where:
 520  *
 521  *   - r is the repository to validate the branch for
 522  *
 523  *   - start_name is the ref that we would like to test. This is
 524  *     expanded with DWIM and assigned to out_real_ref.
 525  *
 526  *   - track is the tracking mode of the new branch. If tracking is
 527  *     explicitly requested, start_name must be a branch (because
 528  *     otherwise start_name cannot be tracked)
 529  *
 530  *   - out_oid is an out parameter containing the object_id of start_name
 531  *
 532  *   - out_real_ref is an out parameter containing the full, 'real' form
 533  *     of start_name e.g. refs/heads/main instead of main
 534  *
 535  */
 536 static void dwim_branch_start(struct repository *r, const char *start_name,
 537                            enum branch_track track, char **out_real_ref,
 538                            struct object_id *out_oid)
 539 {
 540         struct commit *commit;
 541         struct object_id oid;
 542         char *real_ref;
 543         int explicit_tracking = 0;
 544
 545         if (track == BRANCH_TRACK_EXPLICIT || track == BRANCH_TRACK_OVERRIDE)
 546                 explicit_tracking = 1;
 547
 548         real_ref = NULL;
 549         if (repo_get_oid_mb(r, start_name, &oid)) {
 550                 if (explicit_tracking) {
 551                         int code = die_message(_(upstream_missing), start_name);
 552                         advise_if_enabled(ADVICE_SET_UPSTREAM_FAILURE,
 553                                           _(upstream_advice));
 554                         exit(code);
 555                 }
 556                 die(_("not a valid object name: '%s'"), start_name);
 557         }
 558
 559         switch (repo_dwim_ref(r, start_name, strlen(start_name), &oid,
 560                               &real_ref, 0)) {
 561         case 0:
 562                 /* Not branching from any existing branch */
 563                 if (explicit_tracking)
 564                         die(_(upstream_not_branch), start_name);
 565                 break;
 566         case 1:
 567                 /* Unique completion -- good, only if it is a real branch */
 568                 if (!starts_with(real_ref, "refs/heads/") &&
 569                     validate_remote_tracking_branch(real_ref)) {
 570                         if (explicit_tracking)
 571                                 die(_(upstream_not_branch), start_name);
 572                         else
 573                                 FREE_AND_NULL(real_ref);
 574                 }
 575                 break;
 576         default:
 577                 die(_("ambiguous object name: '%s'"), start_name);
 578                 break;
 579         }
 580
 581         if (!(commit = lookup_commit_reference(r, &oid)))
 582                 die(_("not a valid branch point: '%s'"), start_name);
 583         if (out_real_ref) {
 584                 *out_real_ref = real_ref;
 585                 real_ref = NULL;
 586         }
 587         if (out_oid)
 588                 oidcpy(out_oid, &commit->object.oid);
 589
 590         FREE_AND_NULL(real_ref);
 591 }
 592
 593 void create_branch(struct repository *r,
 594                    const char *name, const char *start_name,
 595                    int force, int clobber_head_ok, int reflog,
 596                    int quiet, enum branch_track track, int dry_run)
 597 {
 598         struct object_id oid;
 599         char *real_ref;
 600         struct strbuf ref = STRBUF_INIT;
 601         int forcing = 0;
 602         struct ref_transaction *transaction;
 603         struct strbuf err = STRBUF_INIT;
 604         char *msg;
 605
 606         if (track == BRANCH_TRACK_OVERRIDE)
 607                 BUG("'track' cannot be BRANCH_TRACK_OVERRIDE. Did you mean to call dwim_and_setup_tracking()?");
 608         if (clobber_head_ok && !force)
 609                 BUG("'clobber_head_ok' can only be used with 'force'");
 610
 611         if (clobber_head_ok ?
 612                           validate_branchname(name, &ref) :
 613                           validate_new_branchname(name, &ref, force)) {
 614                 forcing = 1;
 615         }
 616
 617         dwim_branch_start(r, start_name, track, &real_ref, &oid);
 618         if (dry_run)
 619                 goto cleanup;
 620
 621         if (reflog)
 622                 log_all_ref_updates = LOG_REFS_NORMAL;
 623
 624         if (forcing)
 625                 msg = xstrfmt("branch: Reset to %s", start_name);
 626         else
 627                 msg = xstrfmt("branch: Created from %s", start_name);
 628         transaction = ref_store_transaction_begin(get_main_ref_store(the_repository),
 629                                                   &err);
 630         if (!transaction ||
 631                 ref_transaction_update(transaction, ref.buf,
 632                                         &oid, forcing ? NULL : null_oid(),
 633                                         NULL, NULL, 0, msg, &err) ||
 634                 ref_transaction_commit(transaction, &err))
 635                 die("%s", err.buf);
 636         ref_transaction_free(transaction);
 637         strbuf_release(&err);
 638         free(msg);
 639
 640         if (real_ref && track)
 641                 setup_tracking(ref.buf + 11, real_ref, track, quiet);
 642
 643 cleanup:
 644         strbuf_release(&ref);
 645         free(real_ref);
 646 }
 647
 648 void dwim_and_setup_tracking(struct repository *r, const char *new_ref,
 649                              const char *orig_ref, enum branch_track track,
 650                              int quiet)
 651 {
 652         char *real_orig_ref = NULL;
 653         dwim_branch_start(r, orig_ref, track, &real_orig_ref, NULL);
 654         setup_tracking(new_ref, real_orig_ref, track, quiet);
 655         free(real_orig_ref);
 656 }
 657
 658 /**
 659  * Creates a branch in a submodule by calling
 660  * create_branches_recursively() in a child process. The child process
 661  * is necessary because install_branch_config_multiple_remotes() (which
 662  * is called by setup_tracking()) does not support writing configs to
 663  * submodules.
 664  */
 665 static int submodule_create_branch(struct repository *r,
 666                                    const struct submodule *submodule,
 667                                    const char *name, const char *start_oid,
 668                                    const char *tracking_name, int force,
 669                                    int reflog, int quiet,
 670                                    enum branch_track track, int dry_run)
 671 {
 672         int ret = 0;
 673         struct child_process child = CHILD_PROCESS_INIT;
 674         struct strbuf child_err = STRBUF_INIT;
 675         struct strbuf out_buf = STRBUF_INIT;
 676         char *out_prefix = xstrfmt("submodule '%s': ", submodule->name);
 677         child.git_cmd = 1;
 678         child.err = -1;
 679         child.stdout_to_stderr = 1;
 680
 681         prepare_other_repo_env(&child.env, r->gitdir);
 682         /*
 683          * submodule_create_branch() is indirectly invoked by "git
 684          * branch", but we cannot invoke "git branch" in the child
 685          * process. "git branch" accepts a branch name and start point,
 686          * where the start point is assumed to provide both the OID
 687          * (start_oid) and the branch to use for tracking
 688          * (tracking_name). But when recursing through submodules,
 689          * start_oid and tracking name need to be specified separately
 690          * (see create_branches_recursively()).
 691          */
 692         strvec_pushl(&child.args, "submodule--helper", "create-branch", NULL);
 693         if (dry_run)
 694                 strvec_push(&child.args, "--dry-run");
 695         if (force)
 696                 strvec_push(&child.args, "--force");
 697         if (quiet)
 698                 strvec_push(&child.args, "--quiet");
 699         if (reflog)
 700                 strvec_push(&child.args, "--create-reflog");
 701
 702         switch (track) {
 703         case BRANCH_TRACK_NEVER:
 704                 strvec_push(&child.args, "--no-track");
 705                 break;
 706         case BRANCH_TRACK_ALWAYS:
 707         case BRANCH_TRACK_EXPLICIT:
 708                 strvec_push(&child.args, "--track=direct");
 709                 break;
 710         case BRANCH_TRACK_OVERRIDE:
 711                 BUG("BRANCH_TRACK_OVERRIDE cannot be used when creating a branch.");
 712                 break;
 713         case BRANCH_TRACK_INHERIT:
 714                 strvec_push(&child.args, "--track=inherit");
 715                 break;
 716         case BRANCH_TRACK_UNSPECIFIED:
 717                 /* Default for "git checkout". Do not pass --track. */
 718         case BRANCH_TRACK_REMOTE:
 719                 /* Default for "git branch". Do not pass --track. */
 720         case BRANCH_TRACK_SIMPLE:
 721                 /* Config-driven only. Do not pass --track. */
 722                 break;
 723         }
 724
 725         strvec_pushl(&child.args, name, start_oid, tracking_name, NULL);
 726
 727         if ((ret = start_command(&child)))
 728                 return ret;
 729         ret = finish_command(&child);
 730         strbuf_read(&child_err, child.err, 0);
 731         strbuf_add_lines(&out_buf, out_prefix, child_err.buf, child_err.len);
 732
 733         if (ret)
 734                 fprintf(stderr, "%s", out_buf.buf);
 735         else
 736                 printf("%s", out_buf.buf);
 737
 738         strbuf_release(&child_err);
 739         strbuf_release(&out_buf);
 740         return ret;
 741 }
 742
 743 void create_branches_recursively(struct repository *r, const char *name,
 744                                  const char *start_committish,
 745                                  const char *tracking_name, int force,
 746                                  int reflog, int quiet, enum branch_track track,
 747                                  int dry_run)
 748 {
 749         int i = 0;
 750         char *branch_point = NULL;
 751         struct object_id super_oid;
 752         struct submodule_entry_list submodule_entry_list;
 753
 754         /* Perform dwim on start_committish to get super_oid and branch_point. */
 755         dwim_branch_start(r, start_committish, BRANCH_TRACK_NEVER,
 756                           &branch_point, &super_oid);
 757
 758         /*
 759          * If we were not given an explicit name to track, then assume we are at
 760          * the top level and, just like the non-recursive case, the tracking
 761          * name is the branch point.
 762          */
 763         if (!tracking_name)
 764                 tracking_name = branch_point;
 765
 766         submodules_of_tree(r, &super_oid, &submodule_entry_list);
 767         /*
 768          * Before creating any branches, first check that the branch can
 769          * be created in every submodule.
 770          */
 771         for (i = 0; i < submodule_entry_list.entry_nr; i++) {
 772                 if (!submodule_entry_list.entries[i].repo) {
 773                         int code = die_message(
 774                                 _("submodule '%s': unable to find submodule"),
 775                                 submodule_entry_list.entries[i].submodule->name);
 776                         if (advice_enabled(ADVICE_SUBMODULES_NOT_UPDATED))
 777                                 advise(_("You may try updating the submodules using 'git checkout --no-recurse-submodules %s && git submodule update --init'"),
 778                                        start_committish);
 779                         exit(code);
 780                 }
 781
 782                 if (submodule_create_branch(
 783                             submodule_entry_list.entries[i].repo,
 784                             submodule_entry_list.entries[i].submodule, name,
 785                             oid_to_hex(&submodule_entry_list.entries[i]
 786                                                 .name_entry->oid),
 787                             tracking_name, force, reflog, quiet, track, 1))
 788                         die(_("submodule '%s': cannot create branch '%s'"),
 789                             submodule_entry_list.entries[i].submodule->name,
 790                             name);
 791         }
 792
 793         create_branch(r, name, start_committish, force, 0, reflog, quiet,
 794                       BRANCH_TRACK_NEVER, dry_run);
 795         if (dry_run)
 796                 return;
 797         /*
 798          * NEEDSWORK If tracking was set up in the superproject but not the
 799          * submodule, users might expect "git branch --recurse-submodules" to
 800          * fail or give a warning, but this is not yet implemented because it is
 801          * tedious to determine whether or not tracking was set up in the
 802          * superproject.
 803          */
 804         if (track)
 805                 setup_tracking(name, tracking_name, track, quiet);
 806
 807         for (i = 0; i < submodule_entry_list.entry_nr; i++) {
 808                 if (submodule_create_branch(
 809                             submodule_entry_list.entries[i].repo,
 810                             submodule_entry_list.entries[i].submodule, name,
 811                             oid_to_hex(&submodule_entry_list.entries[i]
 812                                                 .name_entry->oid),
 813                             tracking_name, force, reflog, quiet, track, 0))
 814                         die(_("submodule '%s': cannot create branch '%s'"),
 815                             submodule_entry_list.entries[i].submodule->name,
 816                             name);
 817                 repo_clear(submodule_entry_list.entries[i].repo);
 818         }
 819 }
 820
 821 void remove_merge_branch_state(struct repository *r)
 822 {
 823         unlink(git_path_merge_head(r));
 824         unlink(git_path_merge_rr(r));
 825         unlink(git_path_merge_msg(r));
 826         unlink(git_path_merge_mode(r));
 827         refs_delete_ref(get_main_ref_store(r), "", "AUTO_MERGE",
 828                         NULL, REF_NO_DEREF);
 829         save_autostash_ref(r, "MERGE_AUTOSTASH");
 830 }
 831
 832 void remove_branch_state(struct repository *r, int verbose)
 833 {
 834         sequencer_post_commit_cleanup(r, verbose);
 835         unlink(git_path_squash_msg(r));
 836         remove_merge_branch_state(r);
 837 }
 838
 839 void die_if_checked_out(const char *branch, int ignore_current_worktree)
 840 {
 841         struct worktree **worktrees = get_worktrees();
 842
 843         for (int i = 0; worktrees[i]; i++) {
 844                 if (worktrees[i]->is_current && ignore_current_worktree)
 845                         continue;
 846
 847                 if (is_shared_symref(worktrees[i], "HEAD", branch)) {
 848                         skip_prefix(branch, "refs/heads/", &branch);
 849                         die(_("'%s' is already used by worktree at '%s'"),
 850                                 branch, worktrees[i]->path);
 851                 }
 852         }
 853
 854         free_worktrees(worktrees);
 855 }