Andrew's git / gitweb.git / submodule.c
?
submodule.con commit Merge branch 'russian-l10n' of https://github.com/DJm00n/git-po-ru (45498f0)
   1#define NO_THE_INDEX_COMPATIBILITY_MACROS
   2
   3#include "cache.h"
   4#include "repository.h"
   5#include "config.h"
   6#include "submodule-config.h"
   7#include "submodule.h"
   8#include "dir.h"
   9#include "diff.h"
  10#include "commit.h"
  11#include "revision.h"
  12#include "run-command.h"
  13#include "diffcore.h"
  14#include "refs.h"
  15#include "string-list.h"
  16#include "sha1-array.h"
  17#include "argv-array.h"
  18#include "blob.h"
  19#include "thread-utils.h"
  20#include "quote.h"
  21#include "remote.h"
  22#include "worktree.h"
  23#include "parse-options.h"
  24
  25static int config_update_recurse_submodules = RECURSE_SUBMODULES_OFF;
  26static struct string_list changed_submodule_names = STRING_LIST_INIT_DUP;
  27static int initialized_fetch_ref_tips;
  28static struct oid_array ref_tips_before_fetch;
  29static struct oid_array ref_tips_after_fetch;
  30
  31/*
  32 * Check if the .gitmodules file is unmerged. Parsing of the .gitmodules file
  33 * will be disabled because we can't guess what might be configured in
  34 * .gitmodules unless the user resolves the conflict.
  35 */
  36int is_gitmodules_unmerged(const struct index_state *istate)
  37{
  38        int pos = index_name_pos(istate, GITMODULES_FILE, strlen(GITMODULES_FILE));
  39        if (pos < 0) { /* .gitmodules not found or isn't merged */
  40                pos = -1 - pos;
  41                if (istate->cache_nr > pos) {  /* there is a .gitmodules */
  42                        const struct cache_entry *ce = istate->cache[pos];
  43                        if (ce_namelen(ce) == strlen(GITMODULES_FILE) &&
  44                            !strcmp(ce->name, GITMODULES_FILE))
  45                                return 1;
  46                }
  47        }
  48
  49        return 0;
  50}
  51
  52/*
  53 * Check if the .gitmodules file has unstaged modifications.  This must be
  54 * checked before allowing modifications to the .gitmodules file with the
  55 * intention to stage them later, because when continuing we would stage the
  56 * modifications the user didn't stage herself too. That might change in a
  57 * future version when we learn to stage the changes we do ourselves without
  58 * staging any previous modifications.
  59 */
  60int is_staging_gitmodules_ok(struct index_state *istate)
  61{
  62        int pos = index_name_pos(istate, GITMODULES_FILE, strlen(GITMODULES_FILE));
  63
  64        if ((pos >= 0) && (pos < istate->cache_nr)) {
  65                struct stat st;
  66                if (lstat(GITMODULES_FILE, &st) == 0 &&
  67                    ie_match_stat(istate, istate->cache[pos], &st,
  68                                  CE_MATCH_IGNORE_FSMONITOR) & DATA_CHANGED)
  69                        return 0;
  70        }
  71
  72        return 1;
  73}
  74
  75static int for_each_remote_ref_submodule(const char *submodule,
  76                                         each_ref_fn fn, void *cb_data)
  77{
  78        return refs_for_each_remote_ref(get_submodule_ref_store(submodule),
  79                                        fn, cb_data);
  80}
  81
  82/*
  83 * Try to update the "path" entry in the "submodule.<name>" section of the
  84 * .gitmodules file. Return 0 only if a .gitmodules file was found, a section
  85 * with the correct path=<oldpath> setting was found and we could update it.
  86 */
  87int update_path_in_gitmodules(const char *oldpath, const char *newpath)
  88{
  89        struct strbuf entry = STRBUF_INIT;
  90        const struct submodule *submodule;
  91
  92        if (!file_exists(GITMODULES_FILE)) /* Do nothing without .gitmodules */
  93                return -1;
  94
  95        if (is_gitmodules_unmerged(&the_index))
  96                die(_("Cannot change unmerged .gitmodules, resolve merge conflicts first"));
  97
  98        submodule = submodule_from_path(&null_oid, oldpath);
  99        if (!submodule || !submodule->name) {
 100                warning(_("Could not find section in .gitmodules where path=%s"), oldpath);
 101                return -1;
 102        }
 103        strbuf_addstr(&entry, "submodule.");
 104        strbuf_addstr(&entry, submodule->name);
 105        strbuf_addstr(&entry, ".path");
 106        if (git_config_set_in_file_gently(GITMODULES_FILE, entry.buf, newpath) < 0) {
 107                /* Maybe the user already did that, don't error out here */
 108                warning(_("Could not update .gitmodules entry %s"), entry.buf);
 109                strbuf_release(&entry);
 110                return -1;
 111        }
 112        strbuf_release(&entry);
 113        return 0;
 114}
 115
 116/*
 117 * Try to remove the "submodule.<name>" section from .gitmodules where the given
 118 * path is configured. Return 0 only if a .gitmodules file was found, a section
 119 * with the correct path=<path> setting was found and we could remove it.
 120 */
 121int remove_path_from_gitmodules(const char *path)
 122{
 123        struct strbuf sect = STRBUF_INIT;
 124        const struct submodule *submodule;
 125
 126        if (!file_exists(GITMODULES_FILE)) /* Do nothing without .gitmodules */
 127                return -1;
 128
 129        if (is_gitmodules_unmerged(&the_index))
 130                die(_("Cannot change unmerged .gitmodules, resolve merge conflicts first"));
 131
 132        submodule = submodule_from_path(&null_oid, path);
 133        if (!submodule || !submodule->name) {
 134                warning(_("Could not find section in .gitmodules where path=%s"), path);
 135                return -1;
 136        }
 137        strbuf_addstr(&sect, "submodule.");
 138        strbuf_addstr(&sect, submodule->name);
 139        if (git_config_rename_section_in_file(GITMODULES_FILE, sect.buf, NULL) < 0) {
 140                /* Maybe the user already did that, don't error out here */
 141                warning(_("Could not remove .gitmodules entry for %s"), path);
 142                strbuf_release(&sect);
 143                return -1;
 144        }
 145        strbuf_release(&sect);
 146        return 0;
 147}
 148
 149void stage_updated_gitmodules(struct index_state *istate)
 150{
 151        if (add_file_to_index(istate, GITMODULES_FILE, 0))
 152                die(_("staging updated .gitmodules failed"));
 153}
 154
 155static int add_submodule_odb(const char *path)
 156{
 157        struct strbuf objects_directory = STRBUF_INIT;
 158        int ret = 0;
 159
 160        ret = strbuf_git_path_submodule(&objects_directory, path, "objects/");
 161        if (ret)
 162                goto done;
 163        if (!is_directory(objects_directory.buf)) {
 164                ret = -1;
 165                goto done;
 166        }
 167        add_to_alternates_memory(objects_directory.buf);
 168done:
 169        strbuf_release(&objects_directory);
 170        return ret;
 171}
 172
 173void set_diffopt_flags_from_submodule_config(struct diff_options *diffopt,
 174                                             const char *path)
 175{
 176        const struct submodule *submodule = submodule_from_path(&null_oid, path);
 177        if (submodule) {
 178                const char *ignore;
 179                char *key;
 180
 181                key = xstrfmt("submodule.%s.ignore", submodule->name);
 182                if (repo_config_get_string_const(the_repository, key, &ignore))
 183                        ignore = submodule->ignore;
 184                free(key);
 185
 186                if (ignore)
 187                        handle_ignore_submodules_arg(diffopt, ignore);
 188                else if (is_gitmodules_unmerged(&the_index))
 189                        diffopt->flags.ignore_submodules = 1;
 190        }
 191}
 192
 193/* Cheap function that only determines if we're interested in submodules at all */
 194int git_default_submodule_config(const char *var, const char *value, void *cb)
 195{
 196        if (!strcmp(var, "submodule.recurse")) {
 197                int v = git_config_bool(var, value) ?
 198                        RECURSE_SUBMODULES_ON : RECURSE_SUBMODULES_OFF;
 199                config_update_recurse_submodules = v;
 200        }
 201        return 0;
 202}
 203
 204int option_parse_recurse_submodules_worktree_updater(const struct option *opt,
 205                                                     const char *arg, int unset)
 206{
 207        if (unset) {
 208                config_update_recurse_submodules = RECURSE_SUBMODULES_OFF;
 209                return 0;
 210        }
 211        if (arg)
 212                config_update_recurse_submodules =
 213                        parse_update_recurse_submodules_arg(opt->long_name,
 214                                                            arg);
 215        else
 216                config_update_recurse_submodules = RECURSE_SUBMODULES_ON;
 217
 218        return 0;
 219}
 220
 221/*
 222 * Determine if a submodule has been initialized at a given 'path'
 223 */
 224int is_submodule_active(struct repository *repo, const char *path)
 225{
 226        int ret = 0;
 227        char *key = NULL;
 228        char *value = NULL;
 229        const struct string_list *sl;
 230        const struct submodule *module;
 231
 232        module = submodule_from_cache(repo, &null_oid, path);
 233
 234        /* early return if there isn't a path->module mapping */
 235        if (!module)
 236                return 0;
 237
 238        /* submodule.<name>.active is set */
 239        key = xstrfmt("submodule.%s.active", module->name);
 240        if (!repo_config_get_bool(repo, key, &ret)) {
 241                free(key);
 242                return ret;
 243        }
 244        free(key);
 245
 246        /* submodule.active is set */
 247        sl = repo_config_get_value_multi(repo, "submodule.active");
 248        if (sl) {
 249                struct pathspec ps;
 250                struct argv_array args = ARGV_ARRAY_INIT;
 251                const struct string_list_item *item;
 252
 253                for_each_string_list_item(item, sl) {
 254                        argv_array_push(&args, item->string);
 255                }
 256
 257                parse_pathspec(&ps, 0, 0, NULL, args.argv);
 258                ret = match_pathspec(&ps, path, strlen(path), 0, NULL, 1);
 259
 260                argv_array_clear(&args);
 261                clear_pathspec(&ps);
 262                return ret;
 263        }
 264
 265        /* fallback to checking if the URL is set */
 266        key = xstrfmt("submodule.%s.url", module->name);
 267        ret = !repo_config_get_string(repo, key, &value);
 268
 269        free(value);
 270        free(key);
 271        return ret;
 272}
 273
 274int is_submodule_populated_gently(const char *path, int *return_error_code)
 275{
 276        int ret = 0;
 277        char *gitdir = xstrfmt("%s/.git", path);
 278
 279        if (resolve_gitdir_gently(gitdir, return_error_code))
 280                ret = 1;
 281
 282        free(gitdir);
 283        return ret;
 284}
 285
 286/*
 287 * Dies if the provided 'prefix' corresponds to an unpopulated submodule
 288 */
 289void die_in_unpopulated_submodule(const struct index_state *istate,
 290                                  const char *prefix)
 291{
 292        int i, prefixlen;
 293
 294        if (!prefix)
 295                return;
 296
 297        prefixlen = strlen(prefix);
 298
 299        for (i = 0; i < istate->cache_nr; i++) {
 300                struct cache_entry *ce = istate->cache[i];
 301                int ce_len = ce_namelen(ce);
 302
 303                if (!S_ISGITLINK(ce->ce_mode))
 304                        continue;
 305                if (prefixlen <= ce_len)
 306                        continue;
 307                if (strncmp(ce->name, prefix, ce_len))
 308                        continue;
 309                if (prefix[ce_len] != '/')
 310                        continue;
 311
 312                die(_("in unpopulated submodule '%s'"), ce->name);
 313        }
 314}
 315
 316/*
 317 * Dies if any paths in the provided pathspec descends into a submodule
 318 */
 319void die_path_inside_submodule(const struct index_state *istate,
 320                               const struct pathspec *ps)
 321{
 322        int i, j;
 323
 324        for (i = 0; i < istate->cache_nr; i++) {
 325                struct cache_entry *ce = istate->cache[i];
 326                int ce_len = ce_namelen(ce);
 327
 328                if (!S_ISGITLINK(ce->ce_mode))
 329                        continue;
 330
 331                for (j = 0; j < ps->nr ; j++) {
 332                        const struct pathspec_item *item = &ps->items[j];
 333
 334                        if (item->len <= ce_len)
 335                                continue;
 336                        if (item->match[ce_len] != '/')
 337                                continue;
 338                        if (strncmp(ce->name, item->match, ce_len))
 339                                continue;
 340                        if (item->len == ce_len + 1)
 341                                continue;
 342
 343                        die(_("Pathspec '%s' is in submodule '%.*s'"),
 344                            item->original, ce_len, ce->name);
 345                }
 346        }
 347}
 348
 349enum submodule_update_type parse_submodule_update_type(const char *value)
 350{
 351        if (!strcmp(value, "none"))
 352                return SM_UPDATE_NONE;
 353        else if (!strcmp(value, "checkout"))
 354                return SM_UPDATE_CHECKOUT;
 355        else if (!strcmp(value, "rebase"))
 356                return SM_UPDATE_REBASE;
 357        else if (!strcmp(value, "merge"))
 358                return SM_UPDATE_MERGE;
 359        else if (*value == '!')
 360                return SM_UPDATE_COMMAND;
 361        else
 362                return SM_UPDATE_UNSPECIFIED;
 363}
 364
 365int parse_submodule_update_strategy(const char *value,
 366                struct submodule_update_strategy *dst)
 367{
 368        enum submodule_update_type type;
 369
 370        free((void*)dst->command);
 371        dst->command = NULL;
 372
 373        type = parse_submodule_update_type(value);
 374        if (type == SM_UPDATE_UNSPECIFIED)
 375                return -1;
 376
 377        dst->type = type;
 378        if (type == SM_UPDATE_COMMAND)
 379                dst->command = xstrdup(value + 1);
 380
 381        return 0;
 382}
 383
 384const char *submodule_strategy_to_string(const struct submodule_update_strategy *s)
 385{
 386        struct strbuf sb = STRBUF_INIT;
 387        switch (s->type) {
 388        case SM_UPDATE_CHECKOUT:
 389                return "checkout";
 390        case SM_UPDATE_MERGE:
 391                return "merge";
 392        case SM_UPDATE_REBASE:
 393                return "rebase";
 394        case SM_UPDATE_NONE:
 395                return "none";
 396        case SM_UPDATE_UNSPECIFIED:
 397                return NULL;
 398        case SM_UPDATE_COMMAND:
 399                strbuf_addf(&sb, "!%s", s->command);
 400                return strbuf_detach(&sb, NULL);
 401        }
 402        return NULL;
 403}
 404
 405void handle_ignore_submodules_arg(struct diff_options *diffopt,
 406                                  const char *arg)
 407{
 408        diffopt->flags.ignore_submodules = 0;
 409        diffopt->flags.ignore_untracked_in_submodules = 0;
 410        diffopt->flags.ignore_dirty_submodules = 0;
 411
 412        if (!strcmp(arg, "all"))
 413                diffopt->flags.ignore_submodules = 1;
 414        else if (!strcmp(arg, "untracked"))
 415                diffopt->flags.ignore_untracked_in_submodules = 1;
 416        else if (!strcmp(arg, "dirty"))
 417                diffopt->flags.ignore_dirty_submodules = 1;
 418        else if (strcmp(arg, "none"))
 419                die("bad --ignore-submodules argument: %s", arg);
 420}
 421
 422static int prepare_submodule_summary(struct rev_info *rev, const char *path,
 423                struct commit *left, struct commit *right,
 424                struct commit_list *merge_bases)
 425{
 426        struct commit_list *list;
 427
 428        init_revisions(rev, NULL);
 429        setup_revisions(0, NULL, rev, NULL);
 430        rev->left_right = 1;
 431        rev->first_parent_only = 1;
 432        left->object.flags |= SYMMETRIC_LEFT;
 433        add_pending_object(rev, &left->object, path);
 434        add_pending_object(rev, &right->object, path);
 435        for (list = merge_bases; list; list = list->next) {
 436                list->item->object.flags |= UNINTERESTING;
 437                add_pending_object(rev, &list->item->object,
 438                        oid_to_hex(&list->item->object.oid));
 439        }
 440        return prepare_revision_walk(rev);
 441}
 442
 443static void print_submodule_summary(struct rev_info *rev, struct diff_options *o)
 444{
 445        static const char format[] = "  %m %s";
 446        struct strbuf sb = STRBUF_INIT;
 447        struct commit *commit;
 448
 449        while ((commit = get_revision(rev))) {
 450                struct pretty_print_context ctx = {0};
 451                ctx.date_mode = rev->date_mode;
 452                ctx.output_encoding = get_log_output_encoding();
 453                strbuf_setlen(&sb, 0);
 454                format_commit_message(commit, format, &sb, &ctx);
 455                strbuf_addch(&sb, '\n');
 456                if (commit->object.flags & SYMMETRIC_LEFT)
 457                        diff_emit_submodule_del(o, sb.buf);
 458                else
 459                        diff_emit_submodule_add(o, sb.buf);
 460        }
 461        strbuf_release(&sb);
 462}
 463
 464static void prepare_submodule_repo_env_no_git_dir(struct argv_array *out)
 465{
 466        const char * const *var;
 467
 468        for (var = local_repo_env; *var; var++) {
 469                if (strcmp(*var, CONFIG_DATA_ENVIRONMENT))
 470                        argv_array_push(out, *var);
 471        }
 472}
 473
 474void prepare_submodule_repo_env(struct argv_array *out)
 475{
 476        prepare_submodule_repo_env_no_git_dir(out);
 477        argv_array_pushf(out, "%s=%s", GIT_DIR_ENVIRONMENT,
 478                         DEFAULT_GIT_DIR_ENVIRONMENT);
 479}
 480
 481/* Helper function to display the submodule header line prior to the full
 482 * summary output. If it can locate the submodule objects directory it will
 483 * attempt to lookup both the left and right commits and put them into the
 484 * left and right pointers.
 485 */
 486static void show_submodule_header(struct diff_options *o, const char *path,
 487                struct object_id *one, struct object_id *two,
 488                unsigned dirty_submodule,
 489                struct commit **left, struct commit **right,
 490                struct commit_list **merge_bases)
 491{
 492        const char *message = NULL;
 493        struct strbuf sb = STRBUF_INIT;
 494        int fast_forward = 0, fast_backward = 0;
 495
 496        if (dirty_submodule & DIRTY_SUBMODULE_UNTRACKED)
 497                diff_emit_submodule_untracked(o, path);
 498
 499        if (dirty_submodule & DIRTY_SUBMODULE_MODIFIED)
 500                diff_emit_submodule_modified(o, path);
 501
 502        if (is_null_oid(one))
 503                message = "(new submodule)";
 504        else if (is_null_oid(two))
 505                message = "(submodule deleted)";
 506
 507        if (add_submodule_odb(path)) {
 508                if (!message)
 509                        message = "(commits not present)";
 510                goto output_header;
 511        }
 512
 513        /*
 514         * Attempt to lookup the commit references, and determine if this is
 515         * a fast forward or fast backwards update.
 516         */
 517        *left = lookup_commit_reference(one);
 518        *right = lookup_commit_reference(two);
 519
 520        /*
 521         * Warn about missing commits in the submodule project, but only if
 522         * they aren't null.
 523         */
 524        if ((!is_null_oid(one) && !*left) ||
 525             (!is_null_oid(two) && !*right))
 526                message = "(commits not present)";
 527
 528        *merge_bases = get_merge_bases(*left, *right);
 529        if (*merge_bases) {
 530                if ((*merge_bases)->item == *left)
 531                        fast_forward = 1;
 532                else if ((*merge_bases)->item == *right)
 533                        fast_backward = 1;
 534        }
 535
 536        if (!oidcmp(one, two)) {
 537                strbuf_release(&sb);
 538                return;
 539        }
 540
 541output_header:
 542        strbuf_addf(&sb, "Submodule %s ", path);
 543        strbuf_add_unique_abbrev(&sb, one->hash, DEFAULT_ABBREV);
 544        strbuf_addstr(&sb, (fast_backward || fast_forward) ? ".." : "...");
 545        strbuf_add_unique_abbrev(&sb, two->hash, DEFAULT_ABBREV);
 546        if (message)
 547                strbuf_addf(&sb, " %s\n", message);
 548        else
 549                strbuf_addf(&sb, "%s:\n", fast_backward ? " (rewind)" : "");
 550        diff_emit_submodule_header(o, sb.buf);
 551
 552        strbuf_release(&sb);
 553}
 554
 555void show_submodule_summary(struct diff_options *o, const char *path,
 556                struct object_id *one, struct object_id *two,
 557                unsigned dirty_submodule)
 558{
 559        struct rev_info rev;
 560        struct commit *left = NULL, *right = NULL;
 561        struct commit_list *merge_bases = NULL;
 562
 563        show_submodule_header(o, path, one, two, dirty_submodule,
 564                              &left, &right, &merge_bases);
 565
 566        /*
 567         * If we don't have both a left and a right pointer, there is no
 568         * reason to try and display a summary. The header line should contain
 569         * all the information the user needs.
 570         */
 571        if (!left || !right)
 572                goto out;
 573
 574        /* Treat revision walker failure the same as missing commits */
 575        if (prepare_submodule_summary(&rev, path, left, right, merge_bases)) {
 576                diff_emit_submodule_error(o, "(revision walker failed)\n");
 577                goto out;
 578        }
 579
 580        print_submodule_summary(&rev, o);
 581
 582out:
 583        if (merge_bases)
 584                free_commit_list(merge_bases);
 585        clear_commit_marks(left, ~0);
 586        clear_commit_marks(right, ~0);
 587}
 588
 589void show_submodule_inline_diff(struct diff_options *o, const char *path,
 590                struct object_id *one, struct object_id *two,
 591                unsigned dirty_submodule)
 592{
 593        const struct object_id *old = the_hash_algo->empty_tree, *new = the_hash_algo->empty_tree;
 594        struct commit *left = NULL, *right = NULL;
 595        struct commit_list *merge_bases = NULL;
 596        struct child_process cp = CHILD_PROCESS_INIT;
 597        struct strbuf sb = STRBUF_INIT;
 598
 599        show_submodule_header(o, path, one, two, dirty_submodule,
 600                              &left, &right, &merge_bases);
 601
 602        /* We need a valid left and right commit to display a difference */
 603        if (!(left || is_null_oid(one)) ||
 604            !(right || is_null_oid(two)))
 605                goto done;
 606
 607        if (left)
 608                old = one;
 609        if (right)
 610                new = two;
 611
 612        cp.git_cmd = 1;
 613        cp.dir = path;
 614        cp.out = -1;
 615        cp.no_stdin = 1;
 616
 617        /* TODO: other options may need to be passed here. */
 618        argv_array_pushl(&cp.args, "diff", "--submodule=diff", NULL);
 619        argv_array_pushf(&cp.args, "--color=%s", want_color(o->use_color) ?
 620                         "always" : "never");
 621
 622        if (o->flags.reverse_diff) {
 623                argv_array_pushf(&cp.args, "--src-prefix=%s%s/",
 624                                 o->b_prefix, path);
 625                argv_array_pushf(&cp.args, "--dst-prefix=%s%s/",
 626                                 o->a_prefix, path);
 627        } else {
 628                argv_array_pushf(&cp.args, "--src-prefix=%s%s/",
 629                                 o->a_prefix, path);
 630                argv_array_pushf(&cp.args, "--dst-prefix=%s%s/",
 631                                 o->b_prefix, path);
 632        }
 633        argv_array_push(&cp.args, oid_to_hex(old));
 634        /*
 635         * If the submodule has modified content, we will diff against the
 636         * work tree, under the assumption that the user has asked for the
 637         * diff format and wishes to actually see all differences even if they
 638         * haven't yet been committed to the submodule yet.
 639         */
 640        if (!(dirty_submodule & DIRTY_SUBMODULE_MODIFIED))
 641                argv_array_push(&cp.args, oid_to_hex(new));
 642
 643        prepare_submodule_repo_env(&cp.env_array);
 644        if (start_command(&cp))
 645                diff_emit_submodule_error(o, "(diff failed)\n");
 646
 647        while (strbuf_getwholeline_fd(&sb, cp.out, '\n') != EOF)
 648                diff_emit_submodule_pipethrough(o, sb.buf, sb.len);
 649
 650        if (finish_command(&cp))
 651                diff_emit_submodule_error(o, "(diff failed)\n");
 652
 653done:
 654        strbuf_release(&sb);
 655        if (merge_bases)
 656                free_commit_list(merge_bases);
 657        if (left)
 658                clear_commit_marks(left, ~0);
 659        if (right)
 660                clear_commit_marks(right, ~0);
 661}
 662
 663int should_update_submodules(void)
 664{
 665        return config_update_recurse_submodules == RECURSE_SUBMODULES_ON;
 666}
 667
 668const struct submodule *submodule_from_ce(const struct cache_entry *ce)
 669{
 670        if (!S_ISGITLINK(ce->ce_mode))
 671                return NULL;
 672
 673        if (!should_update_submodules())
 674                return NULL;
 675
 676        return submodule_from_path(&null_oid, ce->name);
 677}
 678
 679static struct oid_array *submodule_commits(struct string_list *submodules,
 680                                           const char *name)
 681{
 682        struct string_list_item *item;
 683
 684        item = string_list_insert(submodules, name);
 685        if (item->util)
 686                return (struct oid_array *) item->util;
 687
 688        /* NEEDSWORK: should we have oid_array_init()? */
 689        item->util = xcalloc(1, sizeof(struct oid_array));
 690        return (struct oid_array *) item->util;
 691}
 692
 693struct collect_changed_submodules_cb_data {
 694        struct string_list *changed;
 695        const struct object_id *commit_oid;
 696};
 697
 698/*
 699 * this would normally be two functions: default_name_from_path() and
 700 * path_from_default_name(). Since the default name is the same as
 701 * the submodule path we can get away with just one function which only
 702 * checks whether there is a submodule in the working directory at that
 703 * location.
 704 */
 705static const char *default_name_or_path(const char *path_or_name)
 706{
 707        int error_code;
 708
 709        if (!is_submodule_populated_gently(path_or_name, &error_code))
 710                return NULL;
 711
 712        return path_or_name;
 713}
 714
 715static void collect_changed_submodules_cb(struct diff_queue_struct *q,
 716                                          struct diff_options *options,
 717                                          void *data)
 718{
 719        struct collect_changed_submodules_cb_data *me = data;
 720        struct string_list *changed = me->changed;
 721        const struct object_id *commit_oid = me->commit_oid;
 722        int i;
 723
 724        for (i = 0; i < q->nr; i++) {
 725                struct diff_filepair *p = q->queue[i];
 726                struct oid_array *commits;
 727                const struct submodule *submodule;
 728                const char *name;
 729
 730                if (!S_ISGITLINK(p->two->mode))
 731                        continue;
 732
 733                submodule = submodule_from_path(commit_oid, p->two->path);
 734                if (submodule)
 735                        name = submodule->name;
 736                else {
 737                        name = default_name_or_path(p->two->path);
 738                        /* make sure name does not collide with existing one */
 739                        submodule = submodule_from_name(commit_oid, name);
 740                        if (submodule) {
 741                                warning("Submodule in commit %s at path: "
 742                                        "'%s' collides with a submodule named "
 743                                        "the same. Skipping it.",
 744                                        oid_to_hex(commit_oid), name);
 745                                name = NULL;
 746                        }
 747                }
 748
 749                if (!name)
 750                        continue;
 751
 752                commits = submodule_commits(changed, name);
 753                oid_array_append(commits, &p->two->oid);
 754        }
 755}
 756
 757/*
 758 * Collect the paths of submodules in 'changed' which have changed based on
 759 * the revisions as specified in 'argv'.  Each entry in 'changed' will also
 760 * have a corresponding 'struct oid_array' (in the 'util' field) which lists
 761 * what the submodule pointers were updated to during the change.
 762 */
 763static void collect_changed_submodules(struct string_list *changed,
 764                                       struct argv_array *argv)
 765{
 766        struct rev_info rev;
 767        const struct commit *commit;
 768
 769        init_revisions(&rev, NULL);
 770        setup_revisions(argv->argc, argv->argv, &rev, NULL);
 771        if (prepare_revision_walk(&rev))
 772                die("revision walk setup failed");
 773
 774        while ((commit = get_revision(&rev))) {
 775                struct rev_info diff_rev;
 776                struct collect_changed_submodules_cb_data data;
 777                data.changed = changed;
 778                data.commit_oid = &commit->object.oid;
 779
 780                init_revisions(&diff_rev, NULL);
 781                diff_rev.diffopt.output_format |= DIFF_FORMAT_CALLBACK;
 782                diff_rev.diffopt.format_callback = collect_changed_submodules_cb;
 783                diff_rev.diffopt.format_callback_data = &data;
 784                diff_tree_combined_merge(commit, 1, &diff_rev);
 785        }
 786
 787        reset_revision_walk();
 788}
 789
 790static void free_submodules_oids(struct string_list *submodules)
 791{
 792        struct string_list_item *item;
 793        for_each_string_list_item(item, submodules)
 794                oid_array_clear((struct oid_array *) item->util);
 795        string_list_clear(submodules, 1);
 796}
 797
 798static int has_remote(const char *refname, const struct object_id *oid,
 799                      int flags, void *cb_data)
 800{
 801        return 1;
 802}
 803
 804static int append_oid_to_argv(const struct object_id *oid, void *data)
 805{
 806        struct argv_array *argv = data;
 807        argv_array_push(argv, oid_to_hex(oid));
 808        return 0;
 809}
 810
 811struct has_commit_data {
 812        int result;
 813        const char *path;
 814};
 815
 816static int check_has_commit(const struct object_id *oid, void *data)
 817{
 818        struct has_commit_data *cb = data;
 819
 820        enum object_type type = sha1_object_info(oid->hash, NULL);
 821
 822        switch (type) {
 823        case OBJ_COMMIT:
 824                return 0;
 825        case OBJ_BAD:
 826                /*
 827                 * Object is missing or invalid. If invalid, an error message
 828                 * has already been printed.
 829                 */
 830                cb->result = 0;
 831                return 0;
 832        default:
 833                die(_("submodule entry '%s' (%s) is a %s, not a commit"),
 834                    cb->path, oid_to_hex(oid), typename(type));
 835        }
 836}
 837
 838static int submodule_has_commits(const char *path, struct oid_array *commits)
 839{
 840        struct has_commit_data has_commit = { 1, path };
 841
 842        /*
 843         * Perform a cheap, but incorrect check for the existence of 'commits'.
 844         * This is done by adding the submodule's object store to the in-core
 845         * object store, and then querying for each commit's existence.  If we
 846         * do not have the commit object anywhere, there is no chance we have
 847         * it in the object store of the correct submodule and have it
 848         * reachable from a ref, so we can fail early without spawning rev-list
 849         * which is expensive.
 850         */
 851        if (add_submodule_odb(path))
 852                return 0;
 853
 854        oid_array_for_each_unique(commits, check_has_commit, &has_commit);
 855
 856        if (has_commit.result) {
 857                /*
 858                 * Even if the submodule is checked out and the commit is
 859                 * present, make sure it exists in the submodule's object store
 860                 * and that it is reachable from a ref.
 861                 */
 862                struct child_process cp = CHILD_PROCESS_INIT;
 863                struct strbuf out = STRBUF_INIT;
 864
 865                argv_array_pushl(&cp.args, "rev-list", "-n", "1", NULL);
 866                oid_array_for_each_unique(commits, append_oid_to_argv, &cp.args);
 867                argv_array_pushl(&cp.args, "--not", "--all", NULL);
 868
 869                prepare_submodule_repo_env(&cp.env_array);
 870                cp.git_cmd = 1;
 871                cp.no_stdin = 1;
 872                cp.dir = path;
 873
 874                if (capture_command(&cp, &out, GIT_MAX_HEXSZ + 1) || out.len)
 875                        has_commit.result = 0;
 876
 877                strbuf_release(&out);
 878        }
 879
 880        return has_commit.result;
 881}
 882
 883static int submodule_needs_pushing(const char *path, struct oid_array *commits)
 884{
 885        if (!submodule_has_commits(path, commits))
 886                /*
 887                 * NOTE: We do consider it safe to return "no" here. The
 888                 * correct answer would be "We do not know" instead of
 889                 * "No push needed", but it is quite hard to change
 890                 * the submodule pointer without having the submodule
 891                 * around. If a user did however change the submodules
 892                 * without having the submodule around, this indicates
 893                 * an expert who knows what they are doing or a
 894                 * maintainer integrating work from other people. In
 895                 * both cases it should be safe to skip this check.
 896                 */
 897                return 0;
 898
 899        if (for_each_remote_ref_submodule(path, has_remote, NULL) > 0) {
 900                struct child_process cp = CHILD_PROCESS_INIT;
 901                struct strbuf buf = STRBUF_INIT;
 902                int needs_pushing = 0;
 903
 904                argv_array_push(&cp.args, "rev-list");
 905                oid_array_for_each_unique(commits, append_oid_to_argv, &cp.args);
 906                argv_array_pushl(&cp.args, "--not", "--remotes", "-n", "1" , NULL);
 907
 908                prepare_submodule_repo_env(&cp.env_array);
 909                cp.git_cmd = 1;
 910                cp.no_stdin = 1;
 911                cp.out = -1;
 912                cp.dir = path;
 913                if (start_command(&cp))
 914                        die("Could not run 'git rev-list <commits> --not --remotes -n 1' command in submodule %s",
 915                                        path);
 916                if (strbuf_read(&buf, cp.out, 41))
 917                        needs_pushing = 1;
 918                finish_command(&cp);
 919                close(cp.out);
 920                strbuf_release(&buf);
 921                return needs_pushing;
 922        }
 923
 924        return 0;
 925}
 926
 927int find_unpushed_submodules(struct oid_array *commits,
 928                const char *remotes_name, struct string_list *needs_pushing)
 929{
 930        struct string_list submodules = STRING_LIST_INIT_DUP;
 931        struct string_list_item *name;
 932        struct argv_array argv = ARGV_ARRAY_INIT;
 933
 934        /* argv.argv[0] will be ignored by setup_revisions */
 935        argv_array_push(&argv, "find_unpushed_submodules");
 936        oid_array_for_each_unique(commits, append_oid_to_argv, &argv);
 937        argv_array_push(&argv, "--not");
 938        argv_array_pushf(&argv, "--remotes=%s", remotes_name);
 939
 940        collect_changed_submodules(&submodules, &argv);
 941
 942        for_each_string_list_item(name, &submodules) {
 943                struct oid_array *commits = name->util;
 944                const struct submodule *submodule;
 945                const char *path = NULL;
 946
 947                submodule = submodule_from_name(&null_oid, name->string);
 948                if (submodule)
 949                        path = submodule->path;
 950                else
 951                        path = default_name_or_path(name->string);
 952
 953                if (!path)
 954                        continue;
 955
 956                if (submodule_needs_pushing(path, commits))
 957                        string_list_insert(needs_pushing, path);
 958        }
 959
 960        free_submodules_oids(&submodules);
 961        argv_array_clear(&argv);
 962
 963        return needs_pushing->nr;
 964}
 965
 966static int push_submodule(const char *path,
 967                          const struct remote *remote,
 968                          const char **refspec, int refspec_nr,
 969                          const struct string_list *push_options,
 970                          int dry_run)
 971{
 972        if (add_submodule_odb(path))
 973                return 1;
 974
 975        if (for_each_remote_ref_submodule(path, has_remote, NULL) > 0) {
 976                struct child_process cp = CHILD_PROCESS_INIT;
 977                argv_array_push(&cp.args, "push");
 978                if (dry_run)
 979                        argv_array_push(&cp.args, "--dry-run");
 980
 981                if (push_options && push_options->nr) {
 982                        const struct string_list_item *item;
 983                        for_each_string_list_item(item, push_options)
 984                                argv_array_pushf(&cp.args, "--push-option=%s",
 985                                                 item->string);
 986                }
 987
 988                if (remote->origin != REMOTE_UNCONFIGURED) {
 989                        int i;
 990                        argv_array_push(&cp.args, remote->name);
 991                        for (i = 0; i < refspec_nr; i++)
 992                                argv_array_push(&cp.args, refspec[i]);
 993                }
 994
 995                prepare_submodule_repo_env(&cp.env_array);
 996                cp.git_cmd = 1;
 997                cp.no_stdin = 1;
 998                cp.dir = path;
 999                if (run_command(&cp))
1000                        return 0;
1001                close(cp.out);
1002        }
1003
1004        return 1;
1005}
1006
1007/*
1008 * Perform a check in the submodule to see if the remote and refspec work.
1009 * Die if the submodule can't be pushed.
1010 */
1011static void submodule_push_check(const char *path, const char *head,
1012                                 const struct remote *remote,
1013                                 const char **refspec, int refspec_nr)
1014{
1015        struct child_process cp = CHILD_PROCESS_INIT;
1016        int i;
1017
1018        argv_array_push(&cp.args, "submodule--helper");
1019        argv_array_push(&cp.args, "push-check");
1020        argv_array_push(&cp.args, head);
1021        argv_array_push(&cp.args, remote->name);
1022
1023        for (i = 0; i < refspec_nr; i++)
1024                argv_array_push(&cp.args, refspec[i]);
1025
1026        prepare_submodule_repo_env(&cp.env_array);
1027        cp.git_cmd = 1;
1028        cp.no_stdin = 1;
1029        cp.no_stdout = 1;
1030        cp.dir = path;
1031
1032        /*
1033         * Simply indicate if 'submodule--helper push-check' failed.
1034         * More detailed error information will be provided by the
1035         * child process.
1036         */
1037        if (run_command(&cp))
1038                die("process for submodule '%s' failed", path);
1039}
1040
1041int push_unpushed_submodules(struct oid_array *commits,
1042                             const struct remote *remote,
1043                             const char **refspec, int refspec_nr,
1044                             const struct string_list *push_options,
1045                             int dry_run)
1046{
1047        int i, ret = 1;
1048        struct string_list needs_pushing = STRING_LIST_INIT_DUP;
1049
1050        if (!find_unpushed_submodules(commits, remote->name, &needs_pushing))
1051                return 1;
1052
1053        /*
1054         * Verify that the remote and refspec can be propagated to all
1055         * submodules.  This check can be skipped if the remote and refspec
1056         * won't be propagated due to the remote being unconfigured (e.g. a URL
1057         * instead of a remote name).
1058         */
1059        if (remote->origin != REMOTE_UNCONFIGURED) {
1060                char *head;
1061                struct object_id head_oid;
1062
1063                head = resolve_refdup("HEAD", 0, &head_oid, NULL);
1064                if (!head)
1065                        die(_("Failed to resolve HEAD as a valid ref."));
1066
1067                for (i = 0; i < needs_pushing.nr; i++)
1068                        submodule_push_check(needs_pushing.items[i].string,
1069                                             head, remote,
1070                                             refspec, refspec_nr);
1071                free(head);
1072        }
1073
1074        /* Actually push the submodules */
1075        for (i = 0; i < needs_pushing.nr; i++) {
1076                const char *path = needs_pushing.items[i].string;
1077                fprintf(stderr, "Pushing submodule '%s'\n", path);
1078                if (!push_submodule(path, remote, refspec, refspec_nr,
1079                                    push_options, dry_run)) {
1080                        fprintf(stderr, "Unable to push submodule '%s'\n", path);
1081                        ret = 0;
1082                }
1083        }
1084
1085        string_list_clear(&needs_pushing, 0);
1086
1087        return ret;
1088}
1089
1090static int append_oid_to_array(const char *ref, const struct object_id *oid,
1091                               int flags, void *data)
1092{
1093        struct oid_array *array = data;
1094        oid_array_append(array, oid);
1095        return 0;
1096}
1097
1098void check_for_new_submodule_commits(struct object_id *oid)
1099{
1100        if (!initialized_fetch_ref_tips) {
1101                for_each_ref(append_oid_to_array, &ref_tips_before_fetch);
1102                initialized_fetch_ref_tips = 1;
1103        }
1104
1105        oid_array_append(&ref_tips_after_fetch, oid);
1106}
1107
1108static void calculate_changed_submodule_paths(void)
1109{
1110        struct argv_array argv = ARGV_ARRAY_INIT;
1111        struct string_list changed_submodules = STRING_LIST_INIT_DUP;
1112        const struct string_list_item *name;
1113
1114        /* No need to check if there are no submodules configured */
1115        if (!submodule_from_path(NULL, NULL))
1116                return;
1117
1118        argv_array_push(&argv, "--"); /* argv[0] program name */
1119        oid_array_for_each_unique(&ref_tips_after_fetch,
1120                                   append_oid_to_argv, &argv);
1121        argv_array_push(&argv, "--not");
1122        oid_array_for_each_unique(&ref_tips_before_fetch,
1123                                   append_oid_to_argv, &argv);
1124
1125        /*
1126         * Collect all submodules (whether checked out or not) for which new
1127         * commits have been recorded upstream in "changed_submodule_names".
1128         */
1129        collect_changed_submodules(&changed_submodules, &argv);
1130
1131        for_each_string_list_item(name, &changed_submodules) {
1132                struct oid_array *commits = name->util;
1133                const struct submodule *submodule;
1134                const char *path = NULL;
1135
1136                submodule = submodule_from_name(&null_oid, name->string);
1137                if (submodule)
1138                        path = submodule->path;
1139                else
1140                        path = default_name_or_path(name->string);
1141
1142                if (!path)
1143                        continue;
1144
1145                if (!submodule_has_commits(path, commits))
1146                        string_list_append(&changed_submodule_names, name->string);
1147        }
1148
1149        free_submodules_oids(&changed_submodules);
1150        argv_array_clear(&argv);
1151        oid_array_clear(&ref_tips_before_fetch);
1152        oid_array_clear(&ref_tips_after_fetch);
1153        initialized_fetch_ref_tips = 0;
1154}
1155
1156int submodule_touches_in_range(struct object_id *excl_oid,
1157                               struct object_id *incl_oid)
1158{
1159        struct string_list subs = STRING_LIST_INIT_DUP;
1160        struct argv_array args = ARGV_ARRAY_INIT;
1161        int ret;
1162
1163        /* No need to check if there are no submodules configured */
1164        if (!submodule_from_path(NULL, NULL))
1165                return 0;
1166
1167        argv_array_push(&args, "--"); /* args[0] program name */
1168        argv_array_push(&args, oid_to_hex(incl_oid));
1169        argv_array_push(&args, "--not");
1170        argv_array_push(&args, oid_to_hex(excl_oid));
1171
1172        collect_changed_submodules(&subs, &args);
1173        ret = subs.nr;
1174
1175        argv_array_clear(&args);
1176
1177        free_submodules_oids(&subs);
1178        return ret;
1179}
1180
1181struct submodule_parallel_fetch {
1182        int count;
1183        struct argv_array args;
1184        struct repository *r;
1185        const char *prefix;
1186        int command_line_option;
1187        int default_option;
1188        int quiet;
1189        int result;
1190};
1191#define SPF_INIT {0, ARGV_ARRAY_INIT, NULL, NULL, 0, 0, 0, 0}
1192
1193static int get_fetch_recurse_config(const struct submodule *submodule,
1194                                    struct submodule_parallel_fetch *spf)
1195{
1196        if (spf->command_line_option != RECURSE_SUBMODULES_DEFAULT)
1197                return spf->command_line_option;
1198
1199        if (submodule) {
1200                char *key;
1201                const char *value;
1202
1203                int fetch_recurse = submodule->fetch_recurse;
1204                key = xstrfmt("submodule.%s.fetchRecurseSubmodules", submodule->name);
1205                if (!repo_config_get_string_const(spf->r, key, &value)) {
1206                        fetch_recurse = parse_fetch_recurse_submodules_arg(key, value);
1207                }
1208                free(key);
1209
1210                if (fetch_recurse != RECURSE_SUBMODULES_NONE)
1211                        /* local config overrules everything except commandline */
1212                        return fetch_recurse;
1213        }
1214
1215        return spf->default_option;
1216}
1217
1218static int get_next_submodule(struct child_process *cp,
1219                              struct strbuf *err, void *data, void **task_cb)
1220{
1221        int ret = 0;
1222        struct submodule_parallel_fetch *spf = data;
1223
1224        for (; spf->count < spf->r->index->cache_nr; spf->count++) {
1225                struct strbuf submodule_path = STRBUF_INIT;
1226                struct strbuf submodule_git_dir = STRBUF_INIT;
1227                struct strbuf submodule_prefix = STRBUF_INIT;
1228                const struct cache_entry *ce = spf->r->index->cache[spf->count];
1229                const char *git_dir, *default_argv;
1230                const struct submodule *submodule;
1231                struct submodule default_submodule = SUBMODULE_INIT;
1232
1233                if (!S_ISGITLINK(ce->ce_mode))
1234                        continue;
1235
1236                submodule = submodule_from_cache(spf->r, &null_oid, ce->name);
1237                if (!submodule) {
1238                        const char *name = default_name_or_path(ce->name);
1239                        if (name) {
1240                                default_submodule.path = default_submodule.name = name;
1241                                submodule = &default_submodule;
1242                        }
1243                }
1244
1245                switch (get_fetch_recurse_config(submodule, spf))
1246                {
1247                default:
1248                case RECURSE_SUBMODULES_DEFAULT:
1249                case RECURSE_SUBMODULES_ON_DEMAND:
1250                        if (!submodule || !unsorted_string_list_lookup(&changed_submodule_names,
1251                                                         submodule->name))
1252                                continue;
1253                        default_argv = "on-demand";
1254                        break;
1255                case RECURSE_SUBMODULES_ON:
1256                        default_argv = "yes";
1257                        break;
1258                case RECURSE_SUBMODULES_OFF:
1259                        continue;
1260                }
1261
1262                strbuf_repo_worktree_path(&submodule_path, spf->r, "%s", ce->name);
1263                strbuf_addf(&submodule_git_dir, "%s/.git", submodule_path.buf);
1264                strbuf_addf(&submodule_prefix, "%s%s/", spf->prefix, ce->name);
1265                git_dir = read_gitfile(submodule_git_dir.buf);
1266                if (!git_dir)
1267                        git_dir = submodule_git_dir.buf;
1268                if (is_directory(git_dir)) {
1269                        child_process_init(cp);
1270                        cp->dir = strbuf_detach(&submodule_path, NULL);
1271                        prepare_submodule_repo_env(&cp->env_array);
1272                        cp->git_cmd = 1;
1273                        if (!spf->quiet)
1274                                strbuf_addf(err, "Fetching submodule %s%s\n",
1275                                            spf->prefix, ce->name);
1276                        argv_array_init(&cp->args);
1277                        argv_array_pushv(&cp->args, spf->args.argv);
1278                        argv_array_push(&cp->args, default_argv);
1279                        argv_array_push(&cp->args, "--submodule-prefix");
1280                        argv_array_push(&cp->args, submodule_prefix.buf);
1281                        ret = 1;
1282                }
1283                strbuf_release(&submodule_path);
1284                strbuf_release(&submodule_git_dir);
1285                strbuf_release(&submodule_prefix);
1286                if (ret) {
1287                        spf->count++;
1288                        return 1;
1289                }
1290        }
1291        return 0;
1292}
1293
1294static int fetch_start_failure(struct strbuf *err,
1295                               void *cb, void *task_cb)
1296{
1297        struct submodule_parallel_fetch *spf = cb;
1298
1299        spf->result = 1;
1300
1301        return 0;
1302}
1303
1304static int fetch_finish(int retvalue, struct strbuf *err,
1305                        void *cb, void *task_cb)
1306{
1307        struct submodule_parallel_fetch *spf = cb;
1308
1309        if (retvalue)
1310                spf->result = 1;
1311
1312        return 0;
1313}
1314
1315int fetch_populated_submodules(struct repository *r,
1316                               const struct argv_array *options,
1317                               const char *prefix, int command_line_option,
1318                               int default_option,
1319                               int quiet, int max_parallel_jobs)
1320{
1321        int i;
1322        struct submodule_parallel_fetch spf = SPF_INIT;
1323
1324        spf.r = r;
1325        spf.command_line_option = command_line_option;
1326        spf.default_option = default_option;
1327        spf.quiet = quiet;
1328        spf.prefix = prefix;
1329
1330        if (!r->worktree)
1331                goto out;
1332
1333        if (repo_read_index(r) < 0)
1334                die("index file corrupt");
1335
1336        argv_array_push(&spf.args, "fetch");
1337        for (i = 0; i < options->argc; i++)
1338                argv_array_push(&spf.args, options->argv[i]);
1339        argv_array_push(&spf.args, "--recurse-submodules-default");
1340        /* default value, "--submodule-prefix" and its value are added later */
1341
1342        calculate_changed_submodule_paths();
1343        run_processes_parallel(max_parallel_jobs,
1344                               get_next_submodule,
1345                               fetch_start_failure,
1346                               fetch_finish,
1347                               &spf);
1348
1349        argv_array_clear(&spf.args);
1350out:
1351        string_list_clear(&changed_submodule_names, 1);
1352        return spf.result;
1353}
1354
1355unsigned is_submodule_modified(const char *path, int ignore_untracked)
1356{
1357        struct child_process cp = CHILD_PROCESS_INIT;
1358        struct strbuf buf = STRBUF_INIT;
1359        FILE *fp;
1360        unsigned dirty_submodule = 0;
1361        const char *git_dir;
1362        int ignore_cp_exit_code = 0;
1363
1364        strbuf_addf(&buf, "%s/.git", path);
1365        git_dir = read_gitfile(buf.buf);
1366        if (!git_dir)
1367                git_dir = buf.buf;
1368        if (!is_git_directory(git_dir)) {
1369                if (is_directory(git_dir))
1370                        die(_("'%s' not recognized as a git repository"), git_dir);
1371                strbuf_release(&buf);
1372                /* The submodule is not checked out, so it is not modified */
1373                return 0;
1374        }
1375        strbuf_reset(&buf);
1376
1377        argv_array_pushl(&cp.args, "status", "--porcelain=2", NULL);
1378        if (ignore_untracked)
1379                argv_array_push(&cp.args, "-uno");
1380
1381        prepare_submodule_repo_env(&cp.env_array);
1382        cp.git_cmd = 1;
1383        cp.no_stdin = 1;
1384        cp.out = -1;
1385        cp.dir = path;
1386        if (start_command(&cp))
1387                die("Could not run 'git status --porcelain=2' in submodule %s", path);
1388
1389        fp = xfdopen(cp.out, "r");
1390        while (strbuf_getwholeline(&buf, fp, '\n') != EOF) {
1391                /* regular untracked files */
1392                if (buf.buf[0] == '?')
1393                        dirty_submodule |= DIRTY_SUBMODULE_UNTRACKED;
1394
1395                if (buf.buf[0] == 'u' ||
1396                    buf.buf[0] == '1' ||
1397                    buf.buf[0] == '2') {
1398                        /* T = line type, XY = status, SSSS = submodule state */
1399                        if (buf.len < strlen("T XY SSSS"))
1400                                die("BUG: invalid status --porcelain=2 line %s",
1401                                    buf.buf);
1402
1403                        if (buf.buf[5] == 'S' && buf.buf[8] == 'U')
1404                                /* nested untracked file */
1405                                dirty_submodule |= DIRTY_SUBMODULE_UNTRACKED;
1406
1407                        if (buf.buf[0] == 'u' ||
1408                            buf.buf[0] == '2' ||
1409                            memcmp(buf.buf + 5, "S..U", 4))
1410                                /* other change */
1411                                dirty_submodule |= DIRTY_SUBMODULE_MODIFIED;
1412                }
1413
1414                if ((dirty_submodule & DIRTY_SUBMODULE_MODIFIED) &&
1415                    ((dirty_submodule & DIRTY_SUBMODULE_UNTRACKED) ||
1416                     ignore_untracked)) {
1417                        /*
1418                         * We're not interested in any further information from
1419                         * the child any more, neither output nor its exit code.
1420                         */
1421                        ignore_cp_exit_code = 1;
1422                        break;
1423                }
1424        }
1425        fclose(fp);
1426
1427        if (finish_command(&cp) && !ignore_cp_exit_code)
1428                die("'git status --porcelain=2' failed in submodule %s", path);
1429
1430        strbuf_release(&buf);
1431        return dirty_submodule;
1432}
1433
1434int submodule_uses_gitfile(const char *path)
1435{
1436        struct child_process cp = CHILD_PROCESS_INIT;
1437        const char *argv[] = {
1438                "submodule",
1439                "foreach",
1440                "--quiet",
1441                "--recursive",
1442                "test -f .git",
1443                NULL,
1444        };
1445        struct strbuf buf = STRBUF_INIT;
1446        const char *git_dir;
1447
1448        strbuf_addf(&buf, "%s/.git", path);
1449        git_dir = read_gitfile(buf.buf);
1450        if (!git_dir) {
1451                strbuf_release(&buf);
1452                return 0;
1453        }
1454        strbuf_release(&buf);
1455
1456        /* Now test that all nested submodules use a gitfile too */
1457        cp.argv = argv;
1458        prepare_submodule_repo_env(&cp.env_array);
1459        cp.git_cmd = 1;
1460        cp.no_stdin = 1;
1461        cp.no_stderr = 1;
1462        cp.no_stdout = 1;
1463        cp.dir = path;
1464        if (run_command(&cp))
1465                return 0;
1466
1467        return 1;
1468}
1469
1470/*
1471 * Check if it is a bad idea to remove a submodule, i.e. if we'd lose data
1472 * when doing so.
1473 *
1474 * Return 1 if we'd lose data, return 0 if the removal is fine,
1475 * and negative values for errors.
1476 */
1477int bad_to_remove_submodule(const char *path, unsigned flags)
1478{
1479        ssize_t len;
1480        struct child_process cp = CHILD_PROCESS_INIT;
1481        struct strbuf buf = STRBUF_INIT;
1482        int ret = 0;
1483
1484        if (!file_exists(path) || is_empty_dir(path))
1485                return 0;
1486
1487        if (!submodule_uses_gitfile(path))
1488                return 1;
1489
1490        argv_array_pushl(&cp.args, "status", "--porcelain",
1491                                   "--ignore-submodules=none", NULL);
1492
1493        if (flags & SUBMODULE_REMOVAL_IGNORE_UNTRACKED)
1494                argv_array_push(&cp.args, "-uno");
1495        else
1496                argv_array_push(&cp.args, "-uall");
1497
1498        if (!(flags & SUBMODULE_REMOVAL_IGNORE_IGNORED_UNTRACKED))
1499                argv_array_push(&cp.args, "--ignored");
1500
1501        prepare_submodule_repo_env(&cp.env_array);
1502        cp.git_cmd = 1;
1503        cp.no_stdin = 1;
1504        cp.out = -1;
1505        cp.dir = path;
1506        if (start_command(&cp)) {
1507                if (flags & SUBMODULE_REMOVAL_DIE_ON_ERROR)
1508                        die(_("could not start 'git status' in submodule '%s'"),
1509                                path);
1510                ret = -1;
1511                goto out;
1512        }
1513
1514        len = strbuf_read(&buf, cp.out, 1024);
1515        if (len > 2)
1516                ret = 1;
1517        close(cp.out);
1518
1519        if (finish_command(&cp)) {
1520                if (flags & SUBMODULE_REMOVAL_DIE_ON_ERROR)
1521                        die(_("could not run 'git status' in submodule '%s'"),
1522                                path);
1523                ret = -1;
1524        }
1525out:
1526        strbuf_release(&buf);
1527        return ret;
1528}
1529
1530static const char *get_super_prefix_or_empty(void)
1531{
1532        const char *s = get_super_prefix();
1533        if (!s)
1534                s = "";
1535        return s;
1536}
1537
1538static int submodule_has_dirty_index(const struct submodule *sub)
1539{
1540        struct child_process cp = CHILD_PROCESS_INIT;
1541
1542        prepare_submodule_repo_env(&cp.env_array);
1543
1544        cp.git_cmd = 1;
1545        argv_array_pushl(&cp.args, "diff-index", "--quiet",
1546                                   "--cached", "HEAD", NULL);
1547        cp.no_stdin = 1;
1548        cp.no_stdout = 1;
1549        cp.dir = sub->path;
1550        if (start_command(&cp))
1551                die("could not recurse into submodule '%s'", sub->path);
1552
1553        return finish_command(&cp);
1554}
1555
1556static void submodule_reset_index(const char *path)
1557{
1558        struct child_process cp = CHILD_PROCESS_INIT;
1559        prepare_submodule_repo_env(&cp.env_array);
1560
1561        cp.git_cmd = 1;
1562        cp.no_stdin = 1;
1563        cp.dir = path;
1564
1565        argv_array_pushf(&cp.args, "--super-prefix=%s%s/",
1566                                   get_super_prefix_or_empty(), path);
1567        argv_array_pushl(&cp.args, "read-tree", "-u", "--reset", NULL);
1568
1569        argv_array_push(&cp.args, EMPTY_TREE_SHA1_HEX);
1570
1571        if (run_command(&cp))
1572                die("could not reset submodule index");
1573}
1574
1575/**
1576 * Moves a submodule at a given path from a given head to another new head.
1577 * For edge cases (a submodule coming into existence or removing a submodule)
1578 * pass NULL for old or new respectively.
1579 */
1580int submodule_move_head(const char *path,
1581                         const char *old,
1582                         const char *new,
1583                         unsigned flags)
1584{
1585        int ret = 0;
1586        struct child_process cp = CHILD_PROCESS_INIT;
1587        const struct submodule *sub;
1588        int *error_code_ptr, error_code;
1589
1590        if (!is_submodule_active(the_repository, path))
1591                return 0;
1592
1593        if (flags & SUBMODULE_MOVE_HEAD_FORCE)
1594                /*
1595                 * Pass non NULL pointer to is_submodule_populated_gently
1596                 * to prevent die()-ing. We'll use connect_work_tree_and_git_dir
1597                 * to fixup the submodule in the force case later.
1598                 */
1599                error_code_ptr = &error_code;
1600        else
1601                error_code_ptr = NULL;
1602
1603        if (old && !is_submodule_populated_gently(path, error_code_ptr))
1604                return 0;
1605
1606        sub = submodule_from_path(&null_oid, path);
1607
1608        if (!sub)
1609                die("BUG: could not get submodule information for '%s'", path);
1610
1611        if (old && !(flags & SUBMODULE_MOVE_HEAD_FORCE)) {
1612                /* Check if the submodule has a dirty index. */
1613                if (submodule_has_dirty_index(sub))
1614                        return error(_("submodule '%s' has dirty index"), path);
1615        }
1616
1617        if (!(flags & SUBMODULE_MOVE_HEAD_DRY_RUN)) {
1618                if (old) {
1619                        if (!submodule_uses_gitfile(path))
1620                                absorb_git_dir_into_superproject("", path,
1621                                        ABSORB_GITDIR_RECURSE_SUBMODULES);
1622                } else {
1623                        char *gitdir = xstrfmt("%s/modules/%s",
1624                                    get_git_common_dir(), sub->name);
1625                        connect_work_tree_and_git_dir(path, gitdir);
1626                        free(gitdir);
1627
1628                        /* make sure the index is clean as well */
1629                        submodule_reset_index(path);
1630                }
1631
1632                if (old && (flags & SUBMODULE_MOVE_HEAD_FORCE)) {
1633                        char *gitdir = xstrfmt("%s/modules/%s",
1634                                    get_git_common_dir(), sub->name);
1635                        connect_work_tree_and_git_dir(path, gitdir);
1636                        free(gitdir);
1637                }
1638        }
1639
1640        prepare_submodule_repo_env(&cp.env_array);
1641
1642        cp.git_cmd = 1;
1643        cp.no_stdin = 1;
1644        cp.dir = path;
1645
1646        argv_array_pushf(&cp.args, "--super-prefix=%s%s/",
1647                        get_super_prefix_or_empty(), path);
1648        argv_array_pushl(&cp.args, "read-tree", "--recurse-submodules", NULL);
1649
1650        if (flags & SUBMODULE_MOVE_HEAD_DRY_RUN)
1651                argv_array_push(&cp.args, "-n");
1652        else
1653                argv_array_push(&cp.args, "-u");
1654
1655        if (flags & SUBMODULE_MOVE_HEAD_FORCE)
1656                argv_array_push(&cp.args, "--reset");
1657        else
1658                argv_array_push(&cp.args, "-m");
1659
1660        argv_array_push(&cp.args, old ? old : EMPTY_TREE_SHA1_HEX);
1661        argv_array_push(&cp.args, new ? new : EMPTY_TREE_SHA1_HEX);
1662
1663        if (run_command(&cp)) {
1664                ret = -1;
1665                goto out;
1666        }
1667
1668        if (!(flags & SUBMODULE_MOVE_HEAD_DRY_RUN)) {
1669                if (new) {
1670                        child_process_init(&cp);
1671                        /* also set the HEAD accordingly */
1672                        cp.git_cmd = 1;
1673                        cp.no_stdin = 1;
1674                        cp.dir = path;
1675
1676                        prepare_submodule_repo_env(&cp.env_array);
1677                        argv_array_pushl(&cp.args, "update-ref", "HEAD",
1678                                         "--no-deref", new, NULL);
1679
1680                        if (run_command(&cp)) {
1681                                ret = -1;
1682                                goto out;
1683                        }
1684                } else {
1685                        struct strbuf sb = STRBUF_INIT;
1686
1687                        strbuf_addf(&sb, "%s/.git", path);
1688                        unlink_or_warn(sb.buf);
1689                        strbuf_release(&sb);
1690
1691                        if (is_empty_dir(path))
1692                                rmdir_or_warn(path);
1693                }
1694        }
1695out:
1696        return ret;
1697}
1698
1699static int find_first_merges(struct object_array *result, const char *path,
1700                struct commit *a, struct commit *b)
1701{
1702        int i, j;
1703        struct object_array merges = OBJECT_ARRAY_INIT;
1704        struct commit *commit;
1705        int contains_another;
1706
1707        char merged_revision[42];
1708        const char *rev_args[] = { "rev-list", "--merges", "--ancestry-path",
1709                                   "--all", merged_revision, NULL };
1710        struct rev_info revs;
1711        struct setup_revision_opt rev_opts;
1712
1713        memset(result, 0, sizeof(struct object_array));
1714        memset(&rev_opts, 0, sizeof(rev_opts));
1715
1716        /* get all revisions that merge commit a */
1717        xsnprintf(merged_revision, sizeof(merged_revision), "^%s",
1718                        oid_to_hex(&a->object.oid));
1719        init_revisions(&revs, NULL);
1720        rev_opts.submodule = path;
1721        /* FIXME: can't handle linked worktrees in submodules yet */
1722        revs.single_worktree = path != NULL;
1723        setup_revisions(ARRAY_SIZE(rev_args)-1, rev_args, &revs, &rev_opts);
1724
1725        /* save all revisions from the above list that contain b */
1726        if (prepare_revision_walk(&revs))
1727                die("revision walk setup failed");
1728        while ((commit = get_revision(&revs)) != NULL) {
1729                struct object *o = &(commit->object);
1730                if (in_merge_bases(b, commit))
1731                        add_object_array(o, NULL, &merges);
1732        }
1733        reset_revision_walk();
1734
1735        /* Now we've got all merges that contain a and b. Prune all
1736         * merges that contain another found merge and save them in
1737         * result.
1738         */
1739        for (i = 0; i < merges.nr; i++) {
1740                struct commit *m1 = (struct commit *) merges.objects[i].item;
1741
1742                contains_another = 0;
1743                for (j = 0; j < merges.nr; j++) {
1744                        struct commit *m2 = (struct commit *) merges.objects[j].item;
1745                        if (i != j && in_merge_bases(m2, m1)) {
1746                                contains_another = 1;
1747                                break;
1748                        }
1749                }
1750
1751                if (!contains_another)
1752                        add_object_array(merges.objects[i].item, NULL, result);
1753        }
1754
1755        object_array_clear(&merges);
1756        return result->nr;
1757}
1758
1759static void print_commit(struct commit *commit)
1760{
1761        struct strbuf sb = STRBUF_INIT;
1762        struct pretty_print_context ctx = {0};
1763        ctx.date_mode.type = DATE_NORMAL;
1764        format_commit_message(commit, " %h: %m %s", &sb, &ctx);
1765        fprintf(stderr, "%s\n", sb.buf);
1766        strbuf_release(&sb);
1767}
1768
1769#define MERGE_WARNING(path, msg) \
1770        warning("Failed to merge submodule %s (%s)", path, msg);
1771
1772int merge_submodule(struct object_id *result, const char *path,
1773                    const struct object_id *base, const struct object_id *a,
1774                    const struct object_id *b, int search)
1775{
1776        struct commit *commit_base, *commit_a, *commit_b;
1777        int parent_count;
1778        struct object_array merges;
1779
1780        int i;
1781
1782        /* store a in result in case we fail */
1783        oidcpy(result, a);
1784
1785        /* we can not handle deletion conflicts */
1786        if (is_null_oid(base))
1787                return 0;
1788        if (is_null_oid(a))
1789                return 0;
1790        if (is_null_oid(b))
1791                return 0;
1792
1793        if (add_submodule_odb(path)) {
1794                MERGE_WARNING(path, "not checked out");
1795                return 0;
1796        }
1797
1798        if (!(commit_base = lookup_commit_reference(base)) ||
1799            !(commit_a = lookup_commit_reference(a)) ||
1800            !(commit_b = lookup_commit_reference(b))) {
1801                MERGE_WARNING(path, "commits not present");
1802                return 0;
1803        }
1804
1805        /* check whether both changes are forward */
1806        if (!in_merge_bases(commit_base, commit_a) ||
1807            !in_merge_bases(commit_base, commit_b)) {
1808                MERGE_WARNING(path, "commits don't follow merge-base");
1809                return 0;
1810        }
1811
1812        /* Case #1: a is contained in b or vice versa */
1813        if (in_merge_bases(commit_a, commit_b)) {
1814                oidcpy(result, b);
1815                return 1;
1816        }
1817        if (in_merge_bases(commit_b, commit_a)) {
1818                oidcpy(result, a);
1819                return 1;
1820        }
1821
1822        /*
1823         * Case #2: There are one or more merges that contain a and b in
1824         * the submodule. If there is only one, then present it as a
1825         * suggestion to the user, but leave it marked unmerged so the
1826         * user needs to confirm the resolution.
1827         */
1828
1829        /* Skip the search if makes no sense to the calling context.  */
1830        if (!search)
1831                return 0;
1832
1833        /* find commit which merges them */
1834        parent_count = find_first_merges(&merges, path, commit_a, commit_b);
1835        switch (parent_count) {
1836        case 0:
1837                MERGE_WARNING(path, "merge following commits not found");
1838                break;
1839
1840        case 1:
1841                MERGE_WARNING(path, "not fast-forward");
1842                fprintf(stderr, "Found a possible merge resolution "
1843                                "for the submodule:\n");
1844                print_commit((struct commit *) merges.objects[0].item);
1845                fprintf(stderr,
1846                        "If this is correct simply add it to the index "
1847                        "for example\n"
1848                        "by using:\n\n"
1849                        "  git update-index --cacheinfo 160000 %s \"%s\"\n\n"
1850                        "which will accept this suggestion.\n",
1851                        oid_to_hex(&merges.objects[0].item->oid), path);
1852                break;
1853
1854        default:
1855                MERGE_WARNING(path, "multiple merges found");
1856                for (i = 0; i < merges.nr; i++)
1857                        print_commit((struct commit *) merges.objects[i].item);
1858        }
1859
1860        object_array_clear(&merges);
1861        return 0;
1862}
1863
1864/*
1865 * Embeds a single submodules git directory into the superprojects git dir,
1866 * non recursively.
1867 */
1868static void relocate_single_git_dir_into_superproject(const char *prefix,
1869                                                      const char *path)
1870{
1871        char *old_git_dir = NULL, *real_old_git_dir = NULL, *real_new_git_dir = NULL;
1872        const char *new_git_dir;
1873        const struct submodule *sub;
1874
1875        if (submodule_uses_worktrees(path))
1876                die(_("relocate_gitdir for submodule '%s' with "
1877                      "more than one worktree not supported"), path);
1878
1879        old_git_dir = xstrfmt("%s/.git", path);
1880        if (read_gitfile(old_git_dir))
1881                /* If it is an actual gitfile, it doesn't need migration. */
1882                return;
1883
1884        real_old_git_dir = real_pathdup(old_git_dir, 1);
1885
1886        sub = submodule_from_path(&null_oid, path);
1887        if (!sub)
1888                die(_("could not lookup name for submodule '%s'"), path);
1889
1890        new_git_dir = git_path("modules/%s", sub->name);
1891        if (safe_create_leading_directories_const(new_git_dir) < 0)
1892                die(_("could not create directory '%s'"), new_git_dir);
1893        real_new_git_dir = real_pathdup(new_git_dir, 1);
1894
1895        fprintf(stderr, _("Migrating git directory of '%s%s' from\n'%s' to\n'%s'\n"),
1896                get_super_prefix_or_empty(), path,
1897                real_old_git_dir, real_new_git_dir);
1898
1899        relocate_gitdir(path, real_old_git_dir, real_new_git_dir);
1900
1901        free(old_git_dir);
1902        free(real_old_git_dir);
1903        free(real_new_git_dir);
1904}
1905
1906/*
1907 * Migrate the git directory of the submodule given by path from
1908 * having its git directory within the working tree to the git dir nested
1909 * in its superprojects git dir under modules/.
1910 */
1911void absorb_git_dir_into_superproject(const char *prefix,
1912                                      const char *path,
1913                                      unsigned flags)
1914{
1915        int err_code;
1916        const char *sub_git_dir;
1917        struct strbuf gitdir = STRBUF_INIT;
1918        strbuf_addf(&gitdir, "%s/.git", path);
1919        sub_git_dir = resolve_gitdir_gently(gitdir.buf, &err_code);
1920
1921        /* Not populated? */
1922        if (!sub_git_dir) {
1923                const struct submodule *sub;
1924
1925                if (err_code == READ_GITFILE_ERR_STAT_FAILED) {
1926                        /* unpopulated as expected */
1927                        strbuf_release(&gitdir);
1928                        return;
1929                }
1930
1931                if (err_code != READ_GITFILE_ERR_NOT_A_REPO)
1932                        /* We don't know what broke here. */
1933                        read_gitfile_error_die(err_code, path, NULL);
1934
1935                /*
1936                * Maybe populated, but no git directory was found?
1937                * This can happen if the superproject is a submodule
1938                * itself and was just absorbed. The absorption of the
1939                * superproject did not rewrite the git file links yet,
1940                * fix it now.
1941                */
1942                sub = submodule_from_path(&null_oid, path);
1943                if (!sub)
1944                        die(_("could not lookup name for submodule '%s'"), path);
1945                connect_work_tree_and_git_dir(path,
1946                        git_path("modules/%s", sub->name));
1947        } else {
1948                /* Is it already absorbed into the superprojects git dir? */
1949                char *real_sub_git_dir = real_pathdup(sub_git_dir, 1);
1950                char *real_common_git_dir = real_pathdup(get_git_common_dir(), 1);
1951
1952                if (!starts_with(real_sub_git_dir, real_common_git_dir))
1953                        relocate_single_git_dir_into_superproject(prefix, path);
1954
1955                free(real_sub_git_dir);
1956                free(real_common_git_dir);
1957        }
1958        strbuf_release(&gitdir);
1959
1960        if (flags & ABSORB_GITDIR_RECURSE_SUBMODULES) {
1961                struct child_process cp = CHILD_PROCESS_INIT;
1962                struct strbuf sb = STRBUF_INIT;
1963
1964                if (flags & ~ABSORB_GITDIR_RECURSE_SUBMODULES)
1965                        die("BUG: we don't know how to pass the flags down?");
1966
1967                strbuf_addstr(&sb, get_super_prefix_or_empty());
1968                strbuf_addstr(&sb, path);
1969                strbuf_addch(&sb, '/');
1970
1971                cp.dir = path;
1972                cp.git_cmd = 1;
1973                cp.no_stdin = 1;
1974                argv_array_pushl(&cp.args, "--super-prefix", sb.buf,
1975                                           "submodule--helper",
1976                                           "absorb-git-dirs", NULL);
1977                prepare_submodule_repo_env(&cp.env_array);
1978                if (run_command(&cp))
1979                        die(_("could not recurse into submodule '%s'"), path);
1980
1981                strbuf_release(&sb);
1982        }
1983}
1984
1985const char *get_superproject_working_tree(void)
1986{
1987        struct child_process cp = CHILD_PROCESS_INIT;
1988        struct strbuf sb = STRBUF_INIT;
1989        const char *one_up = real_path_if_valid("../");
1990        const char *cwd = xgetcwd();
1991        const char *ret = NULL;
1992        const char *subpath;
1993        int code;
1994        ssize_t len;
1995
1996        if (!is_inside_work_tree())
1997                /*
1998                 * FIXME:
1999                 * We might have a superproject, but it is harder
2000                 * to determine.
2001                 */
2002                return NULL;
2003
2004        if (!one_up)
2005                return NULL;
2006
2007        subpath = relative_path(cwd, one_up, &sb);
2008
2009        prepare_submodule_repo_env(&cp.env_array);
2010        argv_array_pop(&cp.env_array);
2011
2012        argv_array_pushl(&cp.args, "--literal-pathspecs", "-C", "..",
2013                        "ls-files", "-z", "--stage", "--full-name", "--",
2014                        subpath, NULL);
2015        strbuf_reset(&sb);
2016
2017        cp.no_stdin = 1;
2018        cp.no_stderr = 1;
2019        cp.out = -1;
2020        cp.git_cmd = 1;
2021
2022        if (start_command(&cp))
2023                die(_("could not start ls-files in .."));
2024
2025        len = strbuf_read(&sb, cp.out, PATH_MAX);
2026        close(cp.out);
2027
2028        if (starts_with(sb.buf, "160000")) {
2029                int super_sub_len;
2030                int cwd_len = strlen(cwd);
2031                char *super_sub, *super_wt;
2032
2033                /*
2034                 * There is a superproject having this repo as a submodule.
2035                 * The format is <mode> SP <hash> SP <stage> TAB <full name> \0,
2036                 * We're only interested in the name after the tab.
2037                 */
2038                super_sub = strchr(sb.buf, '\t') + 1;
2039                super_sub_len = sb.buf + sb.len - super_sub - 1;
2040
2041                if (super_sub_len > cwd_len ||
2042                    strcmp(&cwd[cwd_len - super_sub_len], super_sub))
2043                        die (_("BUG: returned path string doesn't match cwd?"));
2044
2045                super_wt = xstrdup(cwd);
2046                super_wt[cwd_len - super_sub_len] = '\0';
2047
2048                ret = real_path(super_wt);
2049                free(super_wt);
2050        }
2051        strbuf_release(&sb);
2052
2053        code = finish_command(&cp);
2054
2055        if (code == 128)
2056                /* '../' is not a git repository */
2057                return NULL;
2058        if (code == 0 && len == 0)
2059                /* There is an unrelated git repository at '../' */
2060                return NULL;
2061        if (code)
2062                die(_("ls-tree returned unexpected return code %d"), code);
2063
2064        return ret;
2065}
2066
2067/*
2068 * Put the gitdir for a submodule (given relative to the main
2069 * repository worktree) into `buf`, or return -1 on error.
2070 */
2071int submodule_to_gitdir(struct strbuf *buf, const char *submodule)
2072{
2073        const struct submodule *sub;
2074        const char *git_dir;
2075        int ret = 0;
2076
2077        strbuf_reset(buf);
2078        strbuf_addstr(buf, submodule);
2079        strbuf_complete(buf, '/');
2080        strbuf_addstr(buf, ".git");
2081
2082        git_dir = read_gitfile(buf->buf);
2083        if (git_dir) {
2084                strbuf_reset(buf);
2085                strbuf_addstr(buf, git_dir);
2086        }
2087        if (!is_git_directory(buf->buf)) {
2088                sub = submodule_from_path(&null_oid, submodule);
2089                if (!sub) {
2090                        ret = -1;
2091                        goto cleanup;
2092                }
2093                strbuf_reset(buf);
2094                strbuf_git_path(buf, "%s/%s", "modules", sub->name);
2095        }
2096
2097cleanup:
2098        return ret;
2099}