git.oblomov.eu Git - git/blob - submodule.c

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