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
  26 static int config_update_recurse_submodules = RECURSE_SUBMODULES_OFF;
  27 static struct string_list changed_submodule_names = STRING_LIST_INIT_DUP;
  28 static int initialized_fetch_ref_tips;
  29 static struct oid_array ref_tips_before_fetch;
  30 static struct oid_array ref_tips_after_fetch;
  31
  32 /*
  33  * Check if the .gitmodules file is unmerged. Parsing of the .gitmodules file
  34  * will be disabled because we can't guess what might be configured in
  35  * .gitmodules unless the user resolves the conflict.
  36  */
  37 int is_gitmodules_unmerged(const struct index_state *istate)
  38 {
  39         int pos = index_name_pos(istate, GITMODULES_FILE, strlen(GITMODULES_FILE));
  40         if (pos < 0) { /* .gitmodules not found or isn't merged */
  41                 pos = -1 - pos;
  42                 if (istate->cache_nr > pos) {  /* there is a .gitmodules */
  43                         const struct cache_entry *ce = istate->cache[pos];
  44                         if (ce_namelen(ce) == strlen(GITMODULES_FILE) &&
  45                             !strcmp(ce->name, GITMODULES_FILE))
  46                                 return 1;
  47                 }
  48         }
  49
  50         return 0;
  51 }
  52
  53 /*
  54  * Check if the .gitmodules file is safe to write.
  55  *
  56  * Writing to the .gitmodules file requires that the file exists in the
  57  * working tree or, if it doesn't, that a brand new .gitmodules file is going
  58  * to be created (i.e. it's neither in the index nor in the current branch).
  59  *
  60  * It is not safe to write to .gitmodules if it's not in the working tree but
  61  * it is in the index or in the current branch, because writing new values
  62  * (and staging them) would blindly overwrite ALL the old content.
  63  */
  64 int is_writing_gitmodules_ok(void)
  65 {
  66         struct object_id oid;
  67         return file_exists(GITMODULES_FILE) ||
  68                 (get_oid(GITMODULES_INDEX, &oid) < 0 && get_oid(GITMODULES_HEAD, &oid) < 0);
  69 }
  70
  71 /*
  72  * Check if the .gitmodules file has unstaged modifications.  This must be
  73  * checked before allowing modifications to the .gitmodules file with the
  74  * intention to stage them later, because when continuing we would stage the
  75  * modifications the user didn't stage herself too. That might change in a
  76  * future version when we learn to stage the changes we do ourselves without
  77  * staging any previous modifications.
  78  */
  79 int is_staging_gitmodules_ok(struct index_state *istate)
  80 {
  81         int pos = index_name_pos(istate, GITMODULES_FILE, strlen(GITMODULES_FILE));
  82
  83         if ((pos >= 0) && (pos < istate->cache_nr)) {
  84                 struct stat st;
  85                 if (lstat(GITMODULES_FILE, &st) == 0 &&
  86                     ie_match_stat(istate, istate->cache[pos], &st,
  87                                   CE_MATCH_IGNORE_FSMONITOR) & 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         init_revisions(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 (!oidcmp(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 string_list *changed;
 712         const struct object_id *commit_oid;
 713 };
 714
 715 /*
 716  * this would normally be two functions: default_name_from_path() and
 717  * path_from_default_name(). Since the default name is the same as
 718  * the submodule path we can get away with just one function which only
 719  * checks whether there is a submodule in the working directory at that
 720  * location.
 721  */
 722 static const char *default_name_or_path(const char *path_or_name)
 723 {
 724         int error_code;
 725
 726         if (!is_submodule_populated_gently(path_or_name, &error_code))
 727                 return NULL;
 728
 729         return path_or_name;
 730 }
 731
 732 static void collect_changed_submodules_cb(struct diff_queue_struct *q,
 733                                           struct diff_options *options,
 734                                           void *data)
 735 {
 736         struct collect_changed_submodules_cb_data *me = data;
 737         struct string_list *changed = me->changed;
 738         const struct object_id *commit_oid = me->commit_oid;
 739         int i;
 740
 741         for (i = 0; i < q->nr; i++) {
 742                 struct diff_filepair *p = q->queue[i];
 743                 struct oid_array *commits;
 744                 const struct submodule *submodule;
 745                 const char *name;
 746
 747                 if (!S_ISGITLINK(p->two->mode))
 748                         continue;
 749
 750                 submodule = submodule_from_path(the_repository,
 751                                                 commit_oid, p->two->path);
 752                 if (submodule)
 753                         name = submodule->name;
 754                 else {
 755                         name = default_name_or_path(p->two->path);
 756                         /* make sure name does not collide with existing one */
 757                         if (name)
 758                                 submodule = submodule_from_name(the_repository,
 759                                                                 commit_oid, name);
 760                         if (submodule) {
 761                                 warning("Submodule in commit %s at path: "
 762                                         "'%s' collides with a submodule named "
 763                                         "the same. Skipping it.",
 764                                         oid_to_hex(commit_oid), p->two->path);
 765                                 name = NULL;
 766                         }
 767                 }
 768
 769                 if (!name)
 770                         continue;
 771
 772                 commits = submodule_commits(changed, name);
 773                 oid_array_append(commits, &p->two->oid);
 774         }
 775 }
 776
 777 /*
 778  * Collect the paths of submodules in 'changed' which have changed based on
 779  * the revisions as specified in 'argv'.  Each entry in 'changed' will also
 780  * have a corresponding 'struct oid_array' (in the 'util' field) which lists
 781  * what the submodule pointers were updated to during the change.
 782  */
 783 static void collect_changed_submodules(struct string_list *changed,
 784                                        struct argv_array *argv)
 785 {
 786         struct rev_info rev;
 787         const struct commit *commit;
 788
 789         init_revisions(&rev, NULL);
 790         setup_revisions(argv->argc, argv->argv, &rev, NULL);
 791         if (prepare_revision_walk(&rev))
 792                 die("revision walk setup failed");
 793
 794         while ((commit = get_revision(&rev))) {
 795                 struct rev_info diff_rev;
 796                 struct collect_changed_submodules_cb_data data;
 797                 data.changed = changed;
 798                 data.commit_oid = &commit->object.oid;
 799
 800                 init_revisions(&diff_rev, NULL);
 801                 diff_rev.diffopt.output_format |= DIFF_FORMAT_CALLBACK;
 802                 diff_rev.diffopt.format_callback = collect_changed_submodules_cb;
 803                 diff_rev.diffopt.format_callback_data = &data;
 804                 diff_tree_combined_merge(commit, 1, &diff_rev);
 805         }
 806
 807         reset_revision_walk();
 808 }
 809
 810 static void free_submodules_oids(struct string_list *submodules)
 811 {
 812         struct string_list_item *item;
 813         for_each_string_list_item(item, submodules)
 814                 oid_array_clear((struct oid_array *) item->util);
 815         string_list_clear(submodules, 1);
 816 }
 817
 818 static int has_remote(const char *refname, const struct object_id *oid,
 819                       int flags, void *cb_data)
 820 {
 821         return 1;
 822 }
 823
 824 static int append_oid_to_argv(const struct object_id *oid, void *data)
 825 {
 826         struct argv_array *argv = data;
 827         argv_array_push(argv, oid_to_hex(oid));
 828         return 0;
 829 }
 830
 831 struct has_commit_data {
 832         int result;
 833         const char *path;
 834 };
 835
 836 static int check_has_commit(const struct object_id *oid, void *data)
 837 {
 838         struct has_commit_data *cb = data;
 839
 840         enum object_type type = oid_object_info(the_repository, oid, NULL);
 841
 842         switch (type) {
 843         case OBJ_COMMIT:
 844                 return 0;
 845         case OBJ_BAD:
 846                 /*
 847                  * Object is missing or invalid. If invalid, an error message
 848                  * has already been printed.
 849                  */
 850                 cb->result = 0;
 851                 return 0;
 852         default:
 853                 die(_("submodule entry '%s' (%s) is a %s, not a commit"),
 854                     cb->path, oid_to_hex(oid), type_name(type));
 855         }
 856 }
 857
 858 static int submodule_has_commits(const char *path, struct oid_array *commits)
 859 {
 860         struct has_commit_data has_commit = { 1, path };
 861
 862         /*
 863          * Perform a cheap, but incorrect check for the existence of 'commits'.
 864          * This is done by adding the submodule's object store to the in-core
 865          * object store, and then querying for each commit's existence.  If we
 866          * do not have the commit object anywhere, there is no chance we have
 867          * it in the object store of the correct submodule and have it
 868          * reachable from a ref, so we can fail early without spawning rev-list
 869          * which is expensive.
 870          */
 871         if (add_submodule_odb(path))
 872                 return 0;
 873
 874         oid_array_for_each_unique(commits, check_has_commit, &has_commit);
 875
 876         if (has_commit.result) {
 877                 /*
 878                  * Even if the submodule is checked out and the commit is
 879                  * present, make sure it exists in the submodule's object store
 880                  * and that it is reachable from a ref.
 881                  */
 882                 struct child_process cp = CHILD_PROCESS_INIT;
 883                 struct strbuf out = STRBUF_INIT;
 884
 885                 argv_array_pushl(&cp.args, "rev-list", "-n", "1", NULL);
 886                 oid_array_for_each_unique(commits, append_oid_to_argv, &cp.args);
 887                 argv_array_pushl(&cp.args, "--not", "--all", NULL);
 888
 889                 prepare_submodule_repo_env(&cp.env_array);
 890                 cp.git_cmd = 1;
 891                 cp.no_stdin = 1;
 892                 cp.dir = path;
 893
 894                 if (capture_command(&cp, &out, GIT_MAX_HEXSZ + 1) || out.len)
 895                         has_commit.result = 0;
 896
 897                 strbuf_release(&out);
 898         }
 899
 900         return has_commit.result;
 901 }
 902
 903 static int submodule_needs_pushing(const char *path, struct oid_array *commits)
 904 {
 905         if (!submodule_has_commits(path, commits))
 906                 /*
 907                  * NOTE: We do consider it safe to return "no" here. The
 908                  * correct answer would be "We do not know" instead of
 909                  * "No push needed", but it is quite hard to change
 910                  * the submodule pointer without having the submodule
 911                  * around. If a user did however change the submodules
 912                  * without having the submodule around, this indicates
 913                  * an expert who knows what they are doing or a
 914                  * maintainer integrating work from other people. In
 915                  * both cases it should be safe to skip this check.
 916                  */
 917                 return 0;
 918
 919         if (for_each_remote_ref_submodule(path, has_remote, NULL) > 0) {
 920                 struct child_process cp = CHILD_PROCESS_INIT;
 921                 struct strbuf buf = STRBUF_INIT;
 922                 int needs_pushing = 0;
 923
 924                 argv_array_push(&cp.args, "rev-list");
 925                 oid_array_for_each_unique(commits, append_oid_to_argv, &cp.args);
 926                 argv_array_pushl(&cp.args, "--not", "--remotes", "-n", "1" , NULL);
 927
 928                 prepare_submodule_repo_env(&cp.env_array);
 929                 cp.git_cmd = 1;
 930                 cp.no_stdin = 1;
 931                 cp.out = -1;
 932                 cp.dir = path;
 933                 if (start_command(&cp))
 934                         die("Could not run 'git rev-list <commits> --not --remotes -n 1' command in submodule %s",
 935                                         path);
 936                 if (strbuf_read(&buf, cp.out, 41))
 937                         needs_pushing = 1;
 938                 finish_command(&cp);
 939                 close(cp.out);
 940                 strbuf_release(&buf);
 941                 return needs_pushing;
 942         }
 943
 944         return 0;
 945 }
 946
 947 int find_unpushed_submodules(struct oid_array *commits,
 948                 const char *remotes_name, struct string_list *needs_pushing)
 949 {
 950         struct string_list submodules = STRING_LIST_INIT_DUP;
 951         struct string_list_item *name;
 952         struct argv_array argv = ARGV_ARRAY_INIT;
 953
 954         /* argv.argv[0] will be ignored by setup_revisions */
 955         argv_array_push(&argv, "find_unpushed_submodules");
 956         oid_array_for_each_unique(commits, append_oid_to_argv, &argv);
 957         argv_array_push(&argv, "--not");
 958         argv_array_pushf(&argv, "--remotes=%s", remotes_name);
 959
 960         collect_changed_submodules(&submodules, &argv);
 961
 962         for_each_string_list_item(name, &submodules) {
 963                 struct oid_array *commits = name->util;
 964                 const struct submodule *submodule;
 965                 const char *path = NULL;
 966
 967                 submodule = submodule_from_name(the_repository, &null_oid, name->string);
 968                 if (submodule)
 969                         path = submodule->path;
 970                 else
 971                         path = default_name_or_path(name->string);
 972
 973                 if (!path)
 974                         continue;
 975
 976                 if (submodule_needs_pushing(path, commits))
 977                         string_list_insert(needs_pushing, path);
 978         }
 979
 980         free_submodules_oids(&submodules);
 981         argv_array_clear(&argv);
 982
 983         return needs_pushing->nr;
 984 }
 985
 986 static int push_submodule(const char *path,
 987                           const struct remote *remote,
 988                           const struct refspec *rs,
 989                           const struct string_list *push_options,
 990                           int dry_run)
 991 {
 992         if (add_submodule_odb(path))
 993                 return 1;
 994
 995         if (for_each_remote_ref_submodule(path, has_remote, NULL) > 0) {
 996                 struct child_process cp = CHILD_PROCESS_INIT;
 997                 argv_array_push(&cp.args, "push");
 998                 if (dry_run)
 999                         argv_array_push(&cp.args, "--dry-run");
1000
1001                 if (push_options && push_options->nr) {
1002                         const struct string_list_item *item;
1003                         for_each_string_list_item(item, push_options)
1004                                 argv_array_pushf(&cp.args, "--push-option=%s",
1005                                                  item->string);
1006                 }
1007
1008                 if (remote->origin != REMOTE_UNCONFIGURED) {
1009                         int i;
1010                         argv_array_push(&cp.args, remote->name);
1011                         for (i = 0; i < rs->raw_nr; i++)
1012                                 argv_array_push(&cp.args, rs->raw[i]);
1013                 }
1014
1015                 prepare_submodule_repo_env(&cp.env_array);
1016                 cp.git_cmd = 1;
1017                 cp.no_stdin = 1;
1018                 cp.dir = path;
1019                 if (run_command(&cp))
1020                         return 0;
1021                 close(cp.out);
1022         }
1023
1024         return 1;
1025 }
1026
1027 /*
1028  * Perform a check in the submodule to see if the remote and refspec work.
1029  * Die if the submodule can't be pushed.
1030  */
1031 static void submodule_push_check(const char *path, const char *head,
1032                                  const struct remote *remote,
1033                                  const struct refspec *rs)
1034 {
1035         struct child_process cp = CHILD_PROCESS_INIT;
1036         int i;
1037
1038         argv_array_push(&cp.args, "submodule--helper");
1039         argv_array_push(&cp.args, "push-check");
1040         argv_array_push(&cp.args, head);
1041         argv_array_push(&cp.args, remote->name);
1042
1043         for (i = 0; i < rs->raw_nr; i++)
1044                 argv_array_push(&cp.args, rs->raw[i]);
1045
1046         prepare_submodule_repo_env(&cp.env_array);
1047         cp.git_cmd = 1;
1048         cp.no_stdin = 1;
1049         cp.no_stdout = 1;
1050         cp.dir = path;
1051
1052         /*
1053          * Simply indicate if 'submodule--helper push-check' failed.
1054          * More detailed error information will be provided by the
1055          * child process.
1056          */
1057         if (run_command(&cp))
1058                 die("process for submodule '%s' failed", path);
1059 }
1060
1061 int push_unpushed_submodules(struct oid_array *commits,
1062                              const struct remote *remote,
1063                              const struct refspec *rs,
1064                              const struct string_list *push_options,
1065                              int dry_run)
1066 {
1067         int i, ret = 1;
1068         struct string_list needs_pushing = STRING_LIST_INIT_DUP;
1069
1070         if (!find_unpushed_submodules(commits, remote->name, &needs_pushing))
1071                 return 1;
1072
1073         /*
1074          * Verify that the remote and refspec can be propagated to all
1075          * submodules.  This check can be skipped if the remote and refspec
1076          * won't be propagated due to the remote being unconfigured (e.g. a URL
1077          * instead of a remote name).
1078          */
1079         if (remote->origin != REMOTE_UNCONFIGURED) {
1080                 char *head;
1081                 struct object_id head_oid;
1082
1083                 head = resolve_refdup("HEAD", 0, &head_oid, NULL);
1084                 if (!head)
1085                         die(_("Failed to resolve HEAD as a valid ref."));
1086
1087                 for (i = 0; i < needs_pushing.nr; i++)
1088                         submodule_push_check(needs_pushing.items[i].string,
1089                                              head, remote, rs);
1090                 free(head);
1091         }
1092
1093         /* Actually push the submodules */
1094         for (i = 0; i < needs_pushing.nr; i++) {
1095                 const char *path = needs_pushing.items[i].string;
1096                 fprintf(stderr, "Pushing submodule '%s'\n", path);
1097                 if (!push_submodule(path, remote, rs,
1098                                     push_options, dry_run)) {
1099                         fprintf(stderr, "Unable to push submodule '%s'\n", path);
1100                         ret = 0;
1101                 }
1102         }
1103
1104         string_list_clear(&needs_pushing, 0);
1105
1106         return ret;
1107 }
1108
1109 static int append_oid_to_array(const char *ref, const struct object_id *oid,
1110                                int flags, void *data)
1111 {
1112         struct oid_array *array = data;
1113         oid_array_append(array, oid);
1114         return 0;
1115 }
1116
1117 void check_for_new_submodule_commits(struct object_id *oid)
1118 {
1119         if (!initialized_fetch_ref_tips) {
1120                 for_each_ref(append_oid_to_array, &ref_tips_before_fetch);
1121                 initialized_fetch_ref_tips = 1;
1122         }
1123
1124         oid_array_append(&ref_tips_after_fetch, oid);
1125 }
1126
1127 static void calculate_changed_submodule_paths(void)
1128 {
1129         struct argv_array argv = ARGV_ARRAY_INIT;
1130         struct string_list changed_submodules = STRING_LIST_INIT_DUP;
1131         const struct string_list_item *name;
1132
1133         /* No need to check if there are no submodules configured */
1134         if (!submodule_from_path(the_repository, NULL, NULL))
1135                 return;
1136
1137         argv_array_push(&argv, "--"); /* argv[0] program name */
1138         oid_array_for_each_unique(&ref_tips_after_fetch,
1139                                    append_oid_to_argv, &argv);
1140         argv_array_push(&argv, "--not");
1141         oid_array_for_each_unique(&ref_tips_before_fetch,
1142                                    append_oid_to_argv, &argv);
1143
1144         /*
1145          * Collect all submodules (whether checked out or not) for which new
1146          * commits have been recorded upstream in "changed_submodule_names".
1147          */
1148         collect_changed_submodules(&changed_submodules, &argv);
1149
1150         for_each_string_list_item(name, &changed_submodules) {
1151                 struct oid_array *commits = name->util;
1152                 const struct submodule *submodule;
1153                 const char *path = NULL;
1154
1155                 submodule = submodule_from_name(the_repository, &null_oid, name->string);
1156                 if (submodule)
1157                         path = submodule->path;
1158                 else
1159                         path = default_name_or_path(name->string);
1160
1161                 if (!path)
1162                         continue;
1163
1164                 if (!submodule_has_commits(path, commits))
1165                         string_list_append(&changed_submodule_names, name->string);
1166         }
1167
1168         free_submodules_oids(&changed_submodules);
1169         argv_array_clear(&argv);
1170         oid_array_clear(&ref_tips_before_fetch);
1171         oid_array_clear(&ref_tips_after_fetch);
1172         initialized_fetch_ref_tips = 0;
1173 }
1174
1175 int submodule_touches_in_range(struct object_id *excl_oid,
1176                                struct object_id *incl_oid)
1177 {
1178         struct string_list subs = STRING_LIST_INIT_DUP;
1179         struct argv_array args = ARGV_ARRAY_INIT;
1180         int ret;
1181
1182         /* No need to check if there are no submodules configured */
1183         if (!submodule_from_path(the_repository, NULL, NULL))
1184                 return 0;
1185
1186         argv_array_push(&args, "--"); /* args[0] program name */
1187         argv_array_push(&args, oid_to_hex(incl_oid));
1188         if (!is_null_oid(excl_oid)) {
1189                 argv_array_push(&args, "--not");
1190                 argv_array_push(&args, oid_to_hex(excl_oid));
1191         }
1192
1193         collect_changed_submodules(&subs, &args);
1194         ret = subs.nr;
1195
1196         argv_array_clear(&args);
1197
1198         free_submodules_oids(&subs);
1199         return ret;
1200 }
1201
1202 struct submodule_parallel_fetch {
1203         int count;
1204         struct argv_array args;
1205         struct repository *r;
1206         const char *prefix;
1207         int command_line_option;
1208         int default_option;
1209         int quiet;
1210         int result;
1211 };
1212 #define SPF_INIT {0, ARGV_ARRAY_INIT, NULL, NULL, 0, 0, 0, 0}
1213
1214 static int get_fetch_recurse_config(const struct submodule *submodule,
1215                                     struct submodule_parallel_fetch *spf)
1216 {
1217         if (spf->command_line_option != RECURSE_SUBMODULES_DEFAULT)
1218                 return spf->command_line_option;
1219
1220         if (submodule) {
1221                 char *key;
1222                 const char *value;
1223
1224                 int fetch_recurse = submodule->fetch_recurse;
1225                 key = xstrfmt("submodule.%s.fetchRecurseSubmodules", submodule->name);
1226                 if (!repo_config_get_string_const(spf->r, key, &value)) {
1227                         fetch_recurse = parse_fetch_recurse_submodules_arg(key, value);
1228                 }
1229                 free(key);
1230
1231                 if (fetch_recurse != RECURSE_SUBMODULES_NONE)
1232                         /* local config overrules everything except commandline */
1233                         return fetch_recurse;
1234         }
1235
1236         return spf->default_option;
1237 }
1238
1239 static int get_next_submodule(struct child_process *cp,
1240                               struct strbuf *err, void *data, void **task_cb)
1241 {
1242         int ret = 0;
1243         struct submodule_parallel_fetch *spf = data;
1244
1245         for (; spf->count < spf->r->index->cache_nr; spf->count++) {
1246                 struct strbuf submodule_path = STRBUF_INIT;
1247                 struct strbuf submodule_git_dir = STRBUF_INIT;
1248                 struct strbuf submodule_prefix = STRBUF_INIT;
1249                 const struct cache_entry *ce = spf->r->index->cache[spf->count];
1250                 const char *git_dir, *default_argv;
1251                 const struct submodule *submodule;
1252                 struct submodule default_submodule = SUBMODULE_INIT;
1253
1254                 if (!S_ISGITLINK(ce->ce_mode))
1255                         continue;
1256
1257                 submodule = submodule_from_path(spf->r, &null_oid, ce->name);
1258                 if (!submodule) {
1259                         const char *name = default_name_or_path(ce->name);
1260                         if (name) {
1261                                 default_submodule.path = default_submodule.name = name;
1262                                 submodule = &default_submodule;
1263                         }
1264                 }
1265
1266                 switch (get_fetch_recurse_config(submodule, spf))
1267                 {
1268                 default:
1269                 case RECURSE_SUBMODULES_DEFAULT:
1270                 case RECURSE_SUBMODULES_ON_DEMAND:
1271                         if (!submodule || !unsorted_string_list_lookup(&changed_submodule_names,
1272                                                          submodule->name))
1273                                 continue;
1274                         default_argv = "on-demand";
1275                         break;
1276                 case RECURSE_SUBMODULES_ON:
1277                         default_argv = "yes";
1278                         break;
1279                 case RECURSE_SUBMODULES_OFF:
1280                         continue;
1281                 }
1282
1283                 strbuf_repo_worktree_path(&submodule_path, spf->r, "%s", ce->name);
1284                 strbuf_addf(&submodule_git_dir, "%s/.git", submodule_path.buf);
1285                 strbuf_addf(&submodule_prefix, "%s%s/", spf->prefix, ce->name);
1286                 git_dir = read_gitfile(submodule_git_dir.buf);
1287                 if (!git_dir)
1288                         git_dir = submodule_git_dir.buf;
1289                 if (is_directory(git_dir)) {
1290                         child_process_init(cp);
1291                         cp->dir = strbuf_detach(&submodule_path, NULL);
1292                         prepare_submodule_repo_env(&cp->env_array);
1293                         cp->git_cmd = 1;
1294                         if (!spf->quiet)
1295                                 strbuf_addf(err, "Fetching submodule %s%s\n",
1296                                             spf->prefix, ce->name);
1297                         argv_array_init(&cp->args);
1298                         argv_array_pushv(&cp->args, spf->args.argv);
1299                         argv_array_push(&cp->args, default_argv);
1300                         argv_array_push(&cp->args, "--submodule-prefix");
1301                         argv_array_push(&cp->args, submodule_prefix.buf);
1302                         ret = 1;
1303                 }
1304                 strbuf_release(&submodule_path);
1305                 strbuf_release(&submodule_git_dir);
1306                 strbuf_release(&submodule_prefix);
1307                 if (ret) {
1308                         spf->count++;
1309                         return 1;
1310                 }
1311         }
1312         return 0;
1313 }
1314
1315 static int fetch_start_failure(struct strbuf *err,
1316                                void *cb, void *task_cb)
1317 {
1318         struct submodule_parallel_fetch *spf = cb;
1319
1320         spf->result = 1;
1321
1322         return 0;
1323 }
1324
1325 static int fetch_finish(int retvalue, struct strbuf *err,
1326                         void *cb, void *task_cb)
1327 {
1328         struct submodule_parallel_fetch *spf = cb;
1329
1330         if (retvalue)
1331                 spf->result = 1;
1332
1333         return 0;
1334 }
1335
1336 int fetch_populated_submodules(struct repository *r,
1337                                const struct argv_array *options,
1338                                const char *prefix, int command_line_option,
1339                                int default_option,
1340                                int quiet, int max_parallel_jobs)
1341 {
1342         int i;
1343         struct submodule_parallel_fetch spf = SPF_INIT;
1344
1345         spf.r = r;
1346         spf.command_line_option = command_line_option;
1347         spf.default_option = default_option;
1348         spf.quiet = quiet;
1349         spf.prefix = prefix;
1350
1351         if (!r->worktree)
1352                 goto out;
1353
1354         if (repo_read_index(r) < 0)
1355                 die("index file corrupt");
1356
1357         argv_array_push(&spf.args, "fetch");
1358         for (i = 0; i < options->argc; i++)
1359                 argv_array_push(&spf.args, options->argv[i]);
1360         argv_array_push(&spf.args, "--recurse-submodules-default");
1361         /* default value, "--submodule-prefix" and its value are added later */
1362
1363         calculate_changed_submodule_paths();
1364         run_processes_parallel(max_parallel_jobs,
1365                                get_next_submodule,
1366                                fetch_start_failure,
1367                                fetch_finish,
1368                                &spf);
1369
1370         argv_array_clear(&spf.args);
1371 out:
1372         string_list_clear(&changed_submodule_names, 1);
1373         return spf.result;
1374 }
1375
1376 unsigned is_submodule_modified(const char *path, int ignore_untracked)
1377 {
1378         struct child_process cp = CHILD_PROCESS_INIT;
1379         struct strbuf buf = STRBUF_INIT;
1380         FILE *fp;
1381         unsigned dirty_submodule = 0;
1382         const char *git_dir;
1383         int ignore_cp_exit_code = 0;
1384
1385         strbuf_addf(&buf, "%s/.git", path);
1386         git_dir = read_gitfile(buf.buf);
1387         if (!git_dir)
1388                 git_dir = buf.buf;
1389         if (!is_git_directory(git_dir)) {
1390                 if (is_directory(git_dir))
1391                         die(_("'%s' not recognized as a git repository"), git_dir);
1392                 strbuf_release(&buf);
1393                 /* The submodule is not checked out, so it is not modified */
1394                 return 0;
1395         }
1396         strbuf_reset(&buf);
1397
1398         argv_array_pushl(&cp.args, "status", "--porcelain=2", NULL);
1399         if (ignore_untracked)
1400                 argv_array_push(&cp.args, "-uno");
1401
1402         prepare_submodule_repo_env(&cp.env_array);
1403         cp.git_cmd = 1;
1404         cp.no_stdin = 1;
1405         cp.out = -1;
1406         cp.dir = path;
1407         if (start_command(&cp))
1408                 die("Could not run 'git status --porcelain=2' in submodule %s", path);
1409
1410         fp = xfdopen(cp.out, "r");
1411         while (strbuf_getwholeline(&buf, fp, '\n') != EOF) {
1412                 /* regular untracked files */
1413                 if (buf.buf[0] == '?')
1414                         dirty_submodule |= DIRTY_SUBMODULE_UNTRACKED;
1415
1416                 if (buf.buf[0] == 'u' ||
1417                     buf.buf[0] == '1' ||
1418                     buf.buf[0] == '2') {
1419                         /* T = line type, XY = status, SSSS = submodule state */
1420                         if (buf.len < strlen("T XY SSSS"))
1421                                 BUG("invalid status --porcelain=2 line %s",
1422                                     buf.buf);
1423
1424                         if (buf.buf[5] == 'S' && buf.buf[8] == 'U')
1425                                 /* nested untracked file */
1426                                 dirty_submodule |= DIRTY_SUBMODULE_UNTRACKED;
1427
1428                         if (buf.buf[0] == 'u' ||
1429                             buf.buf[0] == '2' ||
1430                             memcmp(buf.buf + 5, "S..U", 4))
1431                                 /* other change */
1432                                 dirty_submodule |= DIRTY_SUBMODULE_MODIFIED;
1433                 }
1434
1435                 if ((dirty_submodule & DIRTY_SUBMODULE_MODIFIED) &&
1436                     ((dirty_submodule & DIRTY_SUBMODULE_UNTRACKED) ||
1437                      ignore_untracked)) {
1438                         /*
1439                          * We're not interested in any further information from
1440                          * the child any more, neither output nor its exit code.
1441                          */
1442                         ignore_cp_exit_code = 1;
1443                         break;
1444                 }
1445         }
1446         fclose(fp);
1447
1448         if (finish_command(&cp) && !ignore_cp_exit_code)
1449                 die("'git status --porcelain=2' failed in submodule %s", path);
1450
1451         strbuf_release(&buf);
1452         return dirty_submodule;
1453 }
1454
1455 int submodule_uses_gitfile(const char *path)
1456 {
1457         struct child_process cp = CHILD_PROCESS_INIT;
1458         const char *argv[] = {
1459                 "submodule",
1460                 "foreach",
1461                 "--quiet",
1462                 "--recursive",
1463                 "test -f .git",
1464                 NULL,
1465         };
1466         struct strbuf buf = STRBUF_INIT;
1467         const char *git_dir;
1468
1469         strbuf_addf(&buf, "%s/.git", path);
1470         git_dir = read_gitfile(buf.buf);
1471         if (!git_dir) {
1472                 strbuf_release(&buf);
1473                 return 0;
1474         }
1475         strbuf_release(&buf);
1476
1477         /* Now test that all nested submodules use a gitfile too */
1478         cp.argv = argv;
1479         prepare_submodule_repo_env(&cp.env_array);
1480         cp.git_cmd = 1;
1481         cp.no_stdin = 1;
1482         cp.no_stderr = 1;
1483         cp.no_stdout = 1;
1484         cp.dir = path;
1485         if (run_command(&cp))
1486                 return 0;
1487
1488         return 1;
1489 }
1490
1491 /*
1492  * Check if it is a bad idea to remove a submodule, i.e. if we'd lose data
1493  * when doing so.
1494  *
1495  * Return 1 if we'd lose data, return 0 if the removal is fine,
1496  * and negative values for errors.
1497  */
1498 int bad_to_remove_submodule(const char *path, unsigned flags)
1499 {
1500         ssize_t len;
1501         struct child_process cp = CHILD_PROCESS_INIT;
1502         struct strbuf buf = STRBUF_INIT;
1503         int ret = 0;
1504
1505         if (!file_exists(path) || is_empty_dir(path))
1506                 return 0;
1507
1508         if (!submodule_uses_gitfile(path))
1509                 return 1;
1510
1511         argv_array_pushl(&cp.args, "status", "--porcelain",
1512                                    "--ignore-submodules=none", NULL);
1513
1514         if (flags & SUBMODULE_REMOVAL_IGNORE_UNTRACKED)
1515                 argv_array_push(&cp.args, "-uno");
1516         else
1517                 argv_array_push(&cp.args, "-uall");
1518
1519         if (!(flags & SUBMODULE_REMOVAL_IGNORE_IGNORED_UNTRACKED))
1520                 argv_array_push(&cp.args, "--ignored");
1521
1522         prepare_submodule_repo_env(&cp.env_array);
1523         cp.git_cmd = 1;
1524         cp.no_stdin = 1;
1525         cp.out = -1;
1526         cp.dir = path;
1527         if (start_command(&cp)) {
1528                 if (flags & SUBMODULE_REMOVAL_DIE_ON_ERROR)
1529                         die(_("could not start 'git status' in submodule '%s'"),
1530                                 path);
1531                 ret = -1;
1532                 goto out;
1533         }
1534
1535         len = strbuf_read(&buf, cp.out, 1024);
1536         if (len > 2)
1537                 ret = 1;
1538         close(cp.out);
1539
1540         if (finish_command(&cp)) {
1541                 if (flags & SUBMODULE_REMOVAL_DIE_ON_ERROR)
1542                         die(_("could not run 'git status' in submodule '%s'"),
1543                                 path);
1544                 ret = -1;
1545         }
1546 out:
1547         strbuf_release(&buf);
1548         return ret;
1549 }
1550
1551 static const char *get_super_prefix_or_empty(void)
1552 {
1553         const char *s = get_super_prefix();
1554         if (!s)
1555                 s = "";
1556         return s;
1557 }
1558
1559 static int submodule_has_dirty_index(const struct submodule *sub)
1560 {
1561         struct child_process cp = CHILD_PROCESS_INIT;
1562
1563         prepare_submodule_repo_env(&cp.env_array);
1564
1565         cp.git_cmd = 1;
1566         argv_array_pushl(&cp.args, "diff-index", "--quiet",
1567                                    "--cached", "HEAD", NULL);
1568         cp.no_stdin = 1;
1569         cp.no_stdout = 1;
1570         cp.dir = sub->path;
1571         if (start_command(&cp))
1572                 die("could not recurse into submodule '%s'", sub->path);
1573
1574         return finish_command(&cp);
1575 }
1576
1577 static void submodule_reset_index(const char *path)
1578 {
1579         struct child_process cp = CHILD_PROCESS_INIT;
1580         prepare_submodule_repo_env(&cp.env_array);
1581
1582         cp.git_cmd = 1;
1583         cp.no_stdin = 1;
1584         cp.dir = path;
1585
1586         argv_array_pushf(&cp.args, "--super-prefix=%s%s/",
1587                                    get_super_prefix_or_empty(), path);
1588         argv_array_pushl(&cp.args, "read-tree", "-u", "--reset", NULL);
1589
1590         argv_array_push(&cp.args, empty_tree_oid_hex());
1591
1592         if (run_command(&cp))
1593                 die("could not reset submodule index");
1594 }
1595
1596 /**
1597  * Moves a submodule at a given path from a given head to another new head.
1598  * For edge cases (a submodule coming into existence or removing a submodule)
1599  * pass NULL for old or new respectively.
1600  */
1601 int submodule_move_head(const char *path,
1602                          const char *old_head,
1603                          const char *new_head,
1604                          unsigned flags)
1605 {
1606         int ret = 0;
1607         struct child_process cp = CHILD_PROCESS_INIT;
1608         const struct submodule *sub;
1609         int *error_code_ptr, error_code;
1610
1611         if (!is_submodule_active(the_repository, path))
1612                 return 0;
1613
1614         if (flags & SUBMODULE_MOVE_HEAD_FORCE)
1615                 /*
1616                  * Pass non NULL pointer to is_submodule_populated_gently
1617                  * to prevent die()-ing. We'll use connect_work_tree_and_git_dir
1618                  * to fixup the submodule in the force case later.
1619                  */
1620                 error_code_ptr = &error_code;
1621         else
1622                 error_code_ptr = NULL;
1623
1624         if (old_head && !is_submodule_populated_gently(path, error_code_ptr))
1625                 return 0;
1626
1627         sub = submodule_from_path(the_repository, &null_oid, path);
1628
1629         if (!sub)
1630                 BUG("could not get submodule information for '%s'", path);
1631
1632         if (old_head && !(flags & SUBMODULE_MOVE_HEAD_FORCE)) {
1633                 /* Check if the submodule has a dirty index. */
1634                 if (submodule_has_dirty_index(sub))
1635                         return error(_("submodule '%s' has dirty index"), path);
1636         }
1637
1638         if (!(flags & SUBMODULE_MOVE_HEAD_DRY_RUN)) {
1639                 if (old_head) {
1640                         if (!submodule_uses_gitfile(path))
1641                                 absorb_git_dir_into_superproject("", path,
1642                                         ABSORB_GITDIR_RECURSE_SUBMODULES);
1643                 } else {
1644                         char *gitdir = xstrfmt("%s/modules/%s",
1645                                     get_git_common_dir(), sub->name);
1646                         connect_work_tree_and_git_dir(path, gitdir, 0);
1647                         free(gitdir);
1648
1649                         /* make sure the index is clean as well */
1650                         submodule_reset_index(path);
1651                 }
1652
1653                 if (old_head && (flags & SUBMODULE_MOVE_HEAD_FORCE)) {
1654                         char *gitdir = xstrfmt("%s/modules/%s",
1655                                     get_git_common_dir(), sub->name);
1656                         connect_work_tree_and_git_dir(path, gitdir, 1);
1657                         free(gitdir);
1658                 }
1659         }
1660
1661         prepare_submodule_repo_env(&cp.env_array);
1662
1663         cp.git_cmd = 1;
1664         cp.no_stdin = 1;
1665         cp.dir = path;
1666
1667         argv_array_pushf(&cp.args, "--super-prefix=%s%s/",
1668                         get_super_prefix_or_empty(), path);
1669         argv_array_pushl(&cp.args, "read-tree", "--recurse-submodules", NULL);
1670
1671         if (flags & SUBMODULE_MOVE_HEAD_DRY_RUN)
1672                 argv_array_push(&cp.args, "-n");
1673         else
1674                 argv_array_push(&cp.args, "-u");
1675
1676         if (flags & SUBMODULE_MOVE_HEAD_FORCE)
1677                 argv_array_push(&cp.args, "--reset");
1678         else
1679                 argv_array_push(&cp.args, "-m");
1680
1681         if (!(flags & SUBMODULE_MOVE_HEAD_FORCE))
1682                 argv_array_push(&cp.args, old_head ? old_head : empty_tree_oid_hex());
1683
1684         argv_array_push(&cp.args, new_head ? new_head : empty_tree_oid_hex());
1685
1686         if (run_command(&cp)) {
1687                 ret = error(_("Submodule '%s' could not be updated."), path);
1688                 goto out;
1689         }
1690
1691         if (!(flags & SUBMODULE_MOVE_HEAD_DRY_RUN)) {
1692                 if (new_head) {
1693                         child_process_init(&cp);
1694                         /* also set the HEAD accordingly */
1695                         cp.git_cmd = 1;
1696                         cp.no_stdin = 1;
1697                         cp.dir = path;
1698
1699                         prepare_submodule_repo_env(&cp.env_array);
1700                         argv_array_pushl(&cp.args, "update-ref", "HEAD",
1701                                          "--no-deref", new_head, NULL);
1702
1703                         if (run_command(&cp)) {
1704                                 ret = -1;
1705                                 goto out;
1706                         }
1707                 } else {
1708                         struct strbuf sb = STRBUF_INIT;
1709
1710                         strbuf_addf(&sb, "%s/.git", path);
1711                         unlink_or_warn(sb.buf);
1712                         strbuf_release(&sb);
1713
1714                         if (is_empty_dir(path))
1715                                 rmdir_or_warn(path);
1716                 }
1717         }
1718 out:
1719         return ret;
1720 }
1721
1722 /*
1723  * Embeds a single submodules git directory into the superprojects git dir,
1724  * non recursively.
1725  */
1726 static void relocate_single_git_dir_into_superproject(const char *prefix,
1727                                                       const char *path)
1728 {
1729         char *old_git_dir = NULL, *real_old_git_dir = NULL, *real_new_git_dir = NULL;
1730         const char *new_git_dir;
1731         const struct submodule *sub;
1732
1733         if (submodule_uses_worktrees(path))
1734                 die(_("relocate_gitdir for submodule '%s' with "
1735                       "more than one worktree not supported"), path);
1736
1737         old_git_dir = xstrfmt("%s/.git", path);
1738         if (read_gitfile(old_git_dir))
1739                 /* If it is an actual gitfile, it doesn't need migration. */
1740                 return;
1741
1742         real_old_git_dir = real_pathdup(old_git_dir, 1);
1743
1744         sub = submodule_from_path(the_repository, &null_oid, path);
1745         if (!sub)
1746                 die(_("could not lookup name for submodule '%s'"), path);
1747
1748         new_git_dir = git_path("modules/%s", sub->name);
1749         if (safe_create_leading_directories_const(new_git_dir) < 0)
1750                 die(_("could not create directory '%s'"), new_git_dir);
1751         real_new_git_dir = real_pathdup(new_git_dir, 1);
1752
1753         fprintf(stderr, _("Migrating git directory of '%s%s' from\n'%s' to\n'%s'\n"),
1754                 get_super_prefix_or_empty(), path,
1755                 real_old_git_dir, real_new_git_dir);
1756
1757         relocate_gitdir(path, real_old_git_dir, real_new_git_dir);
1758
1759         free(old_git_dir);
1760         free(real_old_git_dir);
1761         free(real_new_git_dir);
1762 }
1763
1764 /*
1765  * Migrate the git directory of the submodule given by path from
1766  * having its git directory within the working tree to the git dir nested
1767  * in its superprojects git dir under modules/.
1768  */
1769 void absorb_git_dir_into_superproject(const char *prefix,
1770                                       const char *path,
1771                                       unsigned flags)
1772 {
1773         int err_code;
1774         const char *sub_git_dir;
1775         struct strbuf gitdir = STRBUF_INIT;
1776         strbuf_addf(&gitdir, "%s/.git", path);
1777         sub_git_dir = resolve_gitdir_gently(gitdir.buf, &err_code);
1778
1779         /* Not populated? */
1780         if (!sub_git_dir) {
1781                 const struct submodule *sub;
1782
1783                 if (err_code == READ_GITFILE_ERR_STAT_FAILED) {
1784                         /* unpopulated as expected */
1785                         strbuf_release(&gitdir);
1786                         return;
1787                 }
1788
1789                 if (err_code != READ_GITFILE_ERR_NOT_A_REPO)
1790                         /* We don't know what broke here. */
1791                         read_gitfile_error_die(err_code, path, NULL);
1792
1793                 /*
1794                 * Maybe populated, but no git directory was found?
1795                 * This can happen if the superproject is a submodule
1796                 * itself and was just absorbed. The absorption of the
1797                 * superproject did not rewrite the git file links yet,
1798                 * fix it now.
1799                 */
1800                 sub = submodule_from_path(the_repository, &null_oid, path);
1801                 if (!sub)
1802                         die(_("could not lookup name for submodule '%s'"), path);
1803                 connect_work_tree_and_git_dir(path,
1804                         git_path("modules/%s", sub->name), 0);
1805         } else {
1806                 /* Is it already absorbed into the superprojects git dir? */
1807                 char *real_sub_git_dir = real_pathdup(sub_git_dir, 1);
1808                 char *real_common_git_dir = real_pathdup(get_git_common_dir(), 1);
1809
1810                 if (!starts_with(real_sub_git_dir, real_common_git_dir))
1811                         relocate_single_git_dir_into_superproject(prefix, path);
1812
1813                 free(real_sub_git_dir);
1814                 free(real_common_git_dir);
1815         }
1816         strbuf_release(&gitdir);
1817
1818         if (flags & ABSORB_GITDIR_RECURSE_SUBMODULES) {
1819                 struct child_process cp = CHILD_PROCESS_INIT;
1820                 struct strbuf sb = STRBUF_INIT;
1821
1822                 if (flags & ~ABSORB_GITDIR_RECURSE_SUBMODULES)
1823                         BUG("we don't know how to pass the flags down?");
1824
1825                 strbuf_addstr(&sb, get_super_prefix_or_empty());
1826                 strbuf_addstr(&sb, path);
1827                 strbuf_addch(&sb, '/');
1828
1829                 cp.dir = path;
1830                 cp.git_cmd = 1;
1831                 cp.no_stdin = 1;
1832                 argv_array_pushl(&cp.args, "--super-prefix", sb.buf,
1833                                            "submodule--helper",
1834                                            "absorb-git-dirs", NULL);
1835                 prepare_submodule_repo_env(&cp.env_array);
1836                 if (run_command(&cp))
1837                         die(_("could not recurse into submodule '%s'"), path);
1838
1839                 strbuf_release(&sb);
1840         }
1841 }
1842
1843 const char *get_superproject_working_tree(void)
1844 {
1845         struct child_process cp = CHILD_PROCESS_INIT;
1846         struct strbuf sb = STRBUF_INIT;
1847         const char *one_up = real_path_if_valid("../");
1848         const char *cwd = xgetcwd();
1849         const char *ret = NULL;
1850         const char *subpath;
1851         int code;
1852         ssize_t len;
1853
1854         if (!is_inside_work_tree())
1855                 /*
1856                  * FIXME:
1857                  * We might have a superproject, but it is harder
1858                  * to determine.
1859                  */
1860                 return NULL;
1861
1862         if (!one_up)
1863                 return NULL;
1864
1865         subpath = relative_path(cwd, one_up, &sb);
1866
1867         prepare_submodule_repo_env(&cp.env_array);
1868         argv_array_pop(&cp.env_array);
1869
1870         argv_array_pushl(&cp.args, "--literal-pathspecs", "-C", "..",
1871                         "ls-files", "-z", "--stage", "--full-name", "--",
1872                         subpath, NULL);
1873         strbuf_reset(&sb);
1874
1875         cp.no_stdin = 1;
1876         cp.no_stderr = 1;
1877         cp.out = -1;
1878         cp.git_cmd = 1;
1879
1880         if (start_command(&cp))
1881                 die(_("could not start ls-files in .."));
1882
1883         len = strbuf_read(&sb, cp.out, PATH_MAX);
1884         close(cp.out);
1885
1886         if (starts_with(sb.buf, "160000")) {
1887                 int super_sub_len;
1888                 int cwd_len = strlen(cwd);
1889                 char *super_sub, *super_wt;
1890
1891                 /*
1892                  * There is a superproject having this repo as a submodule.
1893                  * The format is <mode> SP <hash> SP <stage> TAB <full name> \0,
1894                  * We're only interested in the name after the tab.
1895                  */
1896                 super_sub = strchr(sb.buf, '\t') + 1;
1897                 super_sub_len = sb.buf + sb.len - super_sub - 1;
1898
1899                 if (super_sub_len > cwd_len ||
1900                     strcmp(&cwd[cwd_len - super_sub_len], super_sub))
1901                         BUG("returned path string doesn't match cwd?");
1902
1903                 super_wt = xstrdup(cwd);
1904                 super_wt[cwd_len - super_sub_len] = '\0';
1905
1906                 ret = real_path(super_wt);
1907                 free(super_wt);
1908         }
1909         strbuf_release(&sb);
1910
1911         code = finish_command(&cp);
1912
1913         if (code == 128)
1914                 /* '../' is not a git repository */
1915                 return NULL;
1916         if (code == 0 && len == 0)
1917                 /* There is an unrelated git repository at '../' */
1918                 return NULL;
1919         if (code)
1920                 die(_("ls-tree returned unexpected return code %d"), code);
1921
1922         return ret;
1923 }
1924
1925 /*
1926  * Put the gitdir for a submodule (given relative to the main
1927  * repository worktree) into `buf`, or return -1 on error.
1928  */
1929 int submodule_to_gitdir(struct strbuf *buf, const char *submodule)
1930 {
1931         const struct submodule *sub;
1932         const char *git_dir;
1933         int ret = 0;
1934
1935         strbuf_reset(buf);
1936         strbuf_addstr(buf, submodule);
1937         strbuf_complete(buf, '/');
1938         strbuf_addstr(buf, ".git");
1939
1940         git_dir = read_gitfile(buf->buf);
1941         if (git_dir) {
1942                 strbuf_reset(buf);
1943                 strbuf_addstr(buf, git_dir);
1944         }
1945         if (!is_git_directory(buf->buf)) {
1946                 sub = submodule_from_path(the_repository, &null_oid, submodule);
1947                 if (!sub) {
1948                         ret = -1;
1949                         goto cleanup;
1950                 }
1951                 strbuf_reset(buf);
1952                 strbuf_git_path(buf, "%s/%s", "modules", sub->name);
1953         }
1954
1955 cleanup:
1956         return ret;
1957 }