branch.c

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