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

   1 #include "cache.h"
   2 #include "submodule-config.h"
   3 #include "submodule.h"
   4 #include "dir.h"
   5 #include "diff.h"
   6 #include "commit.h"
   7 #include "revision.h"
   8 #include "run-command.h"
   9 #include "diffcore.h"
  10 #include "refs.h"
  11 #include "string-list.h"
  12 #include "sha1-array.h"
  13 #include "argv-array.h"
  14 #include "blob.h"
  15 #include "thread-utils.h"
  16 #include "quote.h"
  17
  18 static int config_fetch_recurse_submodules = RECURSE_SUBMODULES_ON_DEMAND;
  19 static struct string_list changed_submodule_paths;
  20 static int initialized_fetch_ref_tips;
  21 static struct sha1_array ref_tips_before_fetch;
  22 static struct sha1_array ref_tips_after_fetch;
  23
  24 /*
  25  * The following flag is set if the .gitmodules file is unmerged. We then
  26  * disable recursion for all submodules where .git/config doesn't have a
  27  * matching config entry because we can't guess what might be configured in
  28  * .gitmodules unless the user resolves the conflict. When a command line
  29  * option is given (which always overrides configuration) this flag will be
  30  * ignored.
  31  */
  32 static int gitmodules_is_unmerged;
  33
  34 /*
  35  * This flag is set if the .gitmodules file had unstaged modifications on
  36  * startup. This must be checked before allowing modifications to the
  37  * .gitmodules file with the intention to stage them later, because when
  38  * continuing we would stage the modifications the user didn't stage herself
  39  * too. That might change in a future version when we learn to stage the
  40  * changes we do ourselves without staging any previous modifications.
  41  */
  42 static int gitmodules_is_modified;
  43
  44 int is_staging_gitmodules_ok(void)
  45 {
  46         return !gitmodules_is_modified;
  47 }
  48
  49 /*
  50  * Try to update the "path" entry in the "submodule.<name>" section of the
  51  * .gitmodules file. Return 0 only if a .gitmodules file was found, a section
  52  * with the correct path=<oldpath> setting was found and we could update it.
  53  */
  54 int update_path_in_gitmodules(const char *oldpath, const char *newpath)
  55 {
  56         struct strbuf entry = STRBUF_INIT;
  57         const struct submodule *submodule;
  58
  59         if (!file_exists(".gitmodules")) /* Do nothing without .gitmodules */
  60                 return -1;
  61
  62         if (gitmodules_is_unmerged)
  63                 die(_("Cannot change unmerged .gitmodules, resolve merge conflicts first"));
  64
  65         submodule = submodule_from_path(null_sha1, oldpath);
  66         if (!submodule || !submodule->name) {
  67                 warning(_("Could not find section in .gitmodules where path=%s"), oldpath);
  68                 return -1;
  69         }
  70         strbuf_addstr(&entry, "submodule.");
  71         strbuf_addstr(&entry, submodule->name);
  72         strbuf_addstr(&entry, ".path");
  73         if (git_config_set_in_file(".gitmodules", entry.buf, newpath) < 0) {
  74                 /* Maybe the user already did that, don't error out here */
  75                 warning(_("Could not update .gitmodules entry %s"), entry.buf);
  76                 strbuf_release(&entry);
  77                 return -1;
  78         }
  79         strbuf_release(&entry);
  80         return 0;
  81 }
  82
  83 /*
  84  * Try to remove the "submodule.<name>" section from .gitmodules where the given
  85  * path is configured. Return 0 only if a .gitmodules file was found, a section
  86  * with the correct path=<path> setting was found and we could remove it.
  87  */
  88 int remove_path_from_gitmodules(const char *path)
  89 {
  90         struct strbuf sect = STRBUF_INIT;
  91         const struct submodule *submodule;
  92
  93         if (!file_exists(".gitmodules")) /* Do nothing without .gitmodules */
  94                 return -1;
  95
  96         if (gitmodules_is_unmerged)
  97                 die(_("Cannot change unmerged .gitmodules, resolve merge conflicts first"));
  98
  99         submodule = submodule_from_path(null_sha1, path);
 100         if (!submodule || !submodule->name) {
 101                 warning(_("Could not find section in .gitmodules where path=%s"), path);
 102                 return -1;
 103         }
 104         strbuf_addstr(&sect, "submodule.");
 105         strbuf_addstr(&sect, submodule->name);
 106         if (git_config_rename_section_in_file(".gitmodules", sect.buf, NULL) < 0) {
 107                 /* Maybe the user already did that, don't error out here */
 108                 warning(_("Could not remove .gitmodules entry for %s"), path);
 109                 strbuf_release(&sect);
 110                 return -1;
 111         }
 112         strbuf_release(&sect);
 113         return 0;
 114 }
 115
 116 void stage_updated_gitmodules(void)
 117 {
 118         if (add_file_to_cache(".gitmodules", 0))
 119                 die(_("staging updated .gitmodules failed"));
 120 }
 121
 122 static int add_submodule_odb(const char *path)
 123 {
 124         struct strbuf objects_directory = STRBUF_INIT;
 125         struct alternate_object_database *alt_odb;
 126         int ret = 0;
 127         int alloc;
 128
 129         strbuf_git_path_submodule(&objects_directory, path, "objects/");
 130         if (!is_directory(objects_directory.buf)) {
 131                 ret = -1;
 132                 goto done;
 133         }
 134         /* avoid adding it twice */
 135         prepare_alt_odb();
 136         for (alt_odb = alt_odb_list; alt_odb; alt_odb = alt_odb->next)
 137                 if (alt_odb->name - alt_odb->base == objects_directory.len &&
 138                                 !strncmp(alt_odb->base, objects_directory.buf,
 139                                         objects_directory.len))
 140                         goto done;
 141
 142         alloc = objects_directory.len + 42; /* for "12/345..." sha1 */
 143         alt_odb = xmalloc(sizeof(*alt_odb) + alloc);
 144         alt_odb->next = alt_odb_list;
 145         xsnprintf(alt_odb->base, alloc, "%s", objects_directory.buf);
 146         alt_odb->name = alt_odb->base + objects_directory.len;
 147         alt_odb->name[2] = '/';
 148         alt_odb->name[40] = '\0';
 149         alt_odb->name[41] = '\0';
 150         alt_odb_list = alt_odb;
 151
 152         /* add possible alternates from the submodule */
 153         read_info_alternates(objects_directory.buf, 0);
 154 done:
 155         strbuf_release(&objects_directory);
 156         return ret;
 157 }
 158
 159 void set_diffopt_flags_from_submodule_config(struct diff_options *diffopt,
 160                                              const char *path)
 161 {
 162         const struct submodule *submodule = submodule_from_path(null_sha1, path);
 163         if (submodule) {
 164                 if (submodule->ignore)
 165                         handle_ignore_submodules_arg(diffopt, submodule->ignore);
 166                 else if (gitmodules_is_unmerged)
 167                         DIFF_OPT_SET(diffopt, IGNORE_SUBMODULES);
 168         }
 169 }
 170
 171 int submodule_config(const char *var, const char *value, void *cb)
 172 {
 173         if (starts_with(var, "submodule."))
 174                 return parse_submodule_config_option(var, value);
 175         else if (!strcmp(var, "fetch.recursesubmodules")) {
 176                 config_fetch_recurse_submodules = parse_fetch_recurse_submodules_arg(var, value);
 177                 return 0;
 178         }
 179         return 0;
 180 }
 181
 182 void gitmodules_config(void)
 183 {
 184         const char *work_tree = get_git_work_tree();
 185         if (work_tree) {
 186                 struct strbuf gitmodules_path = STRBUF_INIT;
 187                 int pos;
 188                 strbuf_addstr(&gitmodules_path, work_tree);
 189                 strbuf_addstr(&gitmodules_path, "/.gitmodules");
 190                 if (read_cache() < 0)
 191                         die("index file corrupt");
 192                 pos = cache_name_pos(".gitmodules", 11);
 193                 if (pos < 0) { /* .gitmodules not found or isn't merged */
 194                         pos = -1 - pos;
 195                         if (active_nr > pos) {  /* there is a .gitmodules */
 196                                 const struct cache_entry *ce = active_cache[pos];
 197                                 if (ce_namelen(ce) == 11 &&
 198                                     !memcmp(ce->name, ".gitmodules", 11))
 199                                         gitmodules_is_unmerged = 1;
 200                         }
 201                 } else if (pos < active_nr) {
 202                         struct stat st;
 203                         if (lstat(".gitmodules", &st) == 0 &&
 204                             ce_match_stat(active_cache[pos], &st, 0) & DATA_CHANGED)
 205                                 gitmodules_is_modified = 1;
 206                 }
 207
 208                 if (!gitmodules_is_unmerged)
 209                         git_config_from_file(submodule_config, gitmodules_path.buf, NULL);
 210                 strbuf_release(&gitmodules_path);
 211         }
 212 }
 213
 214 void handle_ignore_submodules_arg(struct diff_options *diffopt,
 215                                   const char *arg)
 216 {
 217         DIFF_OPT_CLR(diffopt, IGNORE_SUBMODULES);
 218         DIFF_OPT_CLR(diffopt, IGNORE_UNTRACKED_IN_SUBMODULES);
 219         DIFF_OPT_CLR(diffopt, IGNORE_DIRTY_SUBMODULES);
 220
 221         if (!strcmp(arg, "all"))
 222                 DIFF_OPT_SET(diffopt, IGNORE_SUBMODULES);
 223         else if (!strcmp(arg, "untracked"))
 224                 DIFF_OPT_SET(diffopt, IGNORE_UNTRACKED_IN_SUBMODULES);
 225         else if (!strcmp(arg, "dirty"))
 226                 DIFF_OPT_SET(diffopt, IGNORE_DIRTY_SUBMODULES);
 227         else if (strcmp(arg, "none"))
 228                 die("bad --ignore-submodules argument: %s", arg);
 229 }
 230
 231 static int prepare_submodule_summary(struct rev_info *rev, const char *path,
 232                 struct commit *left, struct commit *right,
 233                 int *fast_forward, int *fast_backward)
 234 {
 235         struct commit_list *merge_bases, *list;
 236
 237         init_revisions(rev, NULL);
 238         setup_revisions(0, NULL, rev, NULL);
 239         rev->left_right = 1;
 240         rev->first_parent_only = 1;
 241         left->object.flags |= SYMMETRIC_LEFT;
 242         add_pending_object(rev, &left->object, path);
 243         add_pending_object(rev, &right->object, path);
 244         merge_bases = get_merge_bases(left, right);
 245         if (merge_bases) {
 246                 if (merge_bases->item == left)
 247                         *fast_forward = 1;
 248                 else if (merge_bases->item == right)
 249                         *fast_backward = 1;
 250         }
 251         for (list = merge_bases; list; list = list->next) {
 252                 list->item->object.flags |= UNINTERESTING;
 253                 add_pending_object(rev, &list->item->object,
 254                         oid_to_hex(&list->item->object.oid));
 255         }
 256         return prepare_revision_walk(rev);
 257 }
 258
 259 static void print_submodule_summary(struct rev_info *rev, FILE *f,
 260                 const char *line_prefix,
 261                 const char *del, const char *add, const char *reset)
 262 {
 263         static const char format[] = "  %m %s";
 264         struct strbuf sb = STRBUF_INIT;
 265         struct commit *commit;
 266
 267         while ((commit = get_revision(rev))) {
 268                 struct pretty_print_context ctx = {0};
 269                 ctx.date_mode = rev->date_mode;
 270                 ctx.output_encoding = get_log_output_encoding();
 271                 strbuf_setlen(&sb, 0);
 272                 strbuf_addstr(&sb, line_prefix);
 273                 if (commit->object.flags & SYMMETRIC_LEFT) {
 274                         if (del)
 275                                 strbuf_addstr(&sb, del);
 276                 }
 277                 else if (add)
 278                         strbuf_addstr(&sb, add);
 279                 format_commit_message(commit, format, &sb, &ctx);
 280                 if (reset)
 281                         strbuf_addstr(&sb, reset);
 282                 strbuf_addch(&sb, '\n');
 283                 fprintf(f, "%s", sb.buf);
 284         }
 285         strbuf_release(&sb);
 286 }
 287
 288 void show_submodule_summary(FILE *f, const char *path,
 289                 const char *line_prefix,
 290                 unsigned char one[20], unsigned char two[20],
 291                 unsigned dirty_submodule, const char *meta,
 292                 const char *del, const char *add, const char *reset)
 293 {
 294         struct rev_info rev;
 295         struct commit *left = NULL, *right = NULL;
 296         const char *message = NULL;
 297         struct strbuf sb = STRBUF_INIT;
 298         int fast_forward = 0, fast_backward = 0;
 299
 300         if (is_null_sha1(two))
 301                 message = "(submodule deleted)";
 302         else if (add_submodule_odb(path))
 303                 message = "(not checked out)";
 304         else if (is_null_sha1(one))
 305                 message = "(new submodule)";
 306         else if (!(left = lookup_commit_reference(one)) ||
 307                  !(right = lookup_commit_reference(two)))
 308                 message = "(commits not present)";
 309         else if (prepare_submodule_summary(&rev, path, left, right,
 310                                            &fast_forward, &fast_backward))
 311                 message = "(revision walker failed)";
 312
 313         if (dirty_submodule & DIRTY_SUBMODULE_UNTRACKED)
 314                 fprintf(f, "%sSubmodule %s contains untracked content\n",
 315                         line_prefix, path);
 316         if (dirty_submodule & DIRTY_SUBMODULE_MODIFIED)
 317                 fprintf(f, "%sSubmodule %s contains modified content\n",
 318                         line_prefix, path);
 319
 320         if (!hashcmp(one, two)) {
 321                 strbuf_release(&sb);
 322                 return;
 323         }
 324
 325         strbuf_addf(&sb, "%s%sSubmodule %s %s..", line_prefix, meta, path,
 326                         find_unique_abbrev(one, DEFAULT_ABBREV));
 327         if (!fast_backward && !fast_forward)
 328                 strbuf_addch(&sb, '.');
 329         strbuf_addf(&sb, "%s", find_unique_abbrev(two, DEFAULT_ABBREV));
 330         if (message)
 331                 strbuf_addf(&sb, " %s%s\n", message, reset);
 332         else
 333                 strbuf_addf(&sb, "%s:%s\n", fast_backward ? " (rewind)" : "", reset);
 334         fwrite(sb.buf, sb.len, 1, f);
 335
 336         if (!message) /* only NULL if we succeeded in setting up the walk */
 337                 print_submodule_summary(&rev, f, line_prefix, del, add, reset);
 338         if (left)
 339                 clear_commit_marks(left, ~0);
 340         if (right)
 341                 clear_commit_marks(right, ~0);
 342
 343         strbuf_release(&sb);
 344 }
 345
 346 void set_config_fetch_recurse_submodules(int value)
 347 {
 348         config_fetch_recurse_submodules = value;
 349 }
 350
 351 static int has_remote(const char *refname, const struct object_id *oid,
 352                       int flags, void *cb_data)
 353 {
 354         return 1;
 355 }
 356
 357 static int submodule_needs_pushing(const char *path, const unsigned char sha1[20])
 358 {
 359         if (add_submodule_odb(path) || !lookup_commit_reference(sha1))
 360                 return 0;
 361
 362         if (for_each_remote_ref_submodule(path, has_remote, NULL) > 0) {
 363                 struct child_process cp = CHILD_PROCESS_INIT;
 364                 const char *argv[] = {"rev-list", NULL, "--not", "--remotes", "-n", "1" , NULL};
 365                 struct strbuf buf = STRBUF_INIT;
 366                 int needs_pushing = 0;
 367
 368                 argv[1] = sha1_to_hex(sha1);
 369                 cp.argv = argv;
 370                 prepare_submodule_repo_env(&cp.env_array);
 371                 cp.git_cmd = 1;
 372                 cp.no_stdin = 1;
 373                 cp.out = -1;
 374                 cp.dir = path;
 375                 if (start_command(&cp))
 376                         die("Could not run 'git rev-list %s --not --remotes -n 1' command in submodule %s",
 377                                 sha1_to_hex(sha1), path);
 378                 if (strbuf_read(&buf, cp.out, 41))
 379                         needs_pushing = 1;
 380                 finish_command(&cp);
 381                 close(cp.out);
 382                 strbuf_release(&buf);
 383                 return needs_pushing;
 384         }
 385
 386         return 0;
 387 }
 388
 389 static void collect_submodules_from_diff(struct diff_queue_struct *q,
 390                                          struct diff_options *options,
 391                                          void *data)
 392 {
 393         int i;
 394         struct string_list *needs_pushing = data;
 395
 396         for (i = 0; i < q->nr; i++) {
 397                 struct diff_filepair *p = q->queue[i];
 398                 if (!S_ISGITLINK(p->two->mode))
 399                         continue;
 400                 if (submodule_needs_pushing(p->two->path, p->two->sha1))
 401                         string_list_insert(needs_pushing, p->two->path);
 402         }
 403 }
 404
 405 static void find_unpushed_submodule_commits(struct commit *commit,
 406                 struct string_list *needs_pushing)
 407 {
 408         struct rev_info rev;
 409
 410         init_revisions(&rev, NULL);
 411         rev.diffopt.output_format |= DIFF_FORMAT_CALLBACK;
 412         rev.diffopt.format_callback = collect_submodules_from_diff;
 413         rev.diffopt.format_callback_data = needs_pushing;
 414         diff_tree_combined_merge(commit, 1, &rev);
 415 }
 416
 417 int find_unpushed_submodules(unsigned char new_sha1[20],
 418                 const char *remotes_name, struct string_list *needs_pushing)
 419 {
 420         struct rev_info rev;
 421         struct commit *commit;
 422         const char *argv[] = {NULL, NULL, "--not", "NULL", NULL};
 423         int argc = ARRAY_SIZE(argv) - 1;
 424         char *sha1_copy;
 425
 426         struct strbuf remotes_arg = STRBUF_INIT;
 427
 428         strbuf_addf(&remotes_arg, "--remotes=%s", remotes_name);
 429         init_revisions(&rev, NULL);
 430         sha1_copy = xstrdup(sha1_to_hex(new_sha1));
 431         argv[1] = sha1_copy;
 432         argv[3] = remotes_arg.buf;
 433         setup_revisions(argc, argv, &rev, NULL);
 434         if (prepare_revision_walk(&rev))
 435                 die("revision walk setup failed");
 436
 437         while ((commit = get_revision(&rev)) != NULL)
 438                 find_unpushed_submodule_commits(commit, needs_pushing);
 439
 440         reset_revision_walk();
 441         free(sha1_copy);
 442         strbuf_release(&remotes_arg);
 443
 444         return needs_pushing->nr;
 445 }
 446
 447 static int push_submodule(const char *path)
 448 {
 449         if (add_submodule_odb(path))
 450                 return 1;
 451
 452         if (for_each_remote_ref_submodule(path, has_remote, NULL) > 0) {
 453                 struct child_process cp = CHILD_PROCESS_INIT;
 454                 const char *argv[] = {"push", NULL};
 455
 456                 cp.argv = argv;
 457                 prepare_submodule_repo_env(&cp.env_array);
 458                 cp.git_cmd = 1;
 459                 cp.no_stdin = 1;
 460                 cp.dir = path;
 461                 if (run_command(&cp))
 462                         return 0;
 463                 close(cp.out);
 464         }
 465
 466         return 1;
 467 }
 468
 469 int push_unpushed_submodules(unsigned char new_sha1[20], const char *remotes_name)
 470 {
 471         int i, ret = 1;
 472         struct string_list needs_pushing = STRING_LIST_INIT_DUP;
 473
 474         if (!find_unpushed_submodules(new_sha1, remotes_name, &needs_pushing))
 475                 return 1;
 476
 477         for (i = 0; i < needs_pushing.nr; i++) {
 478                 const char *path = needs_pushing.items[i].string;
 479                 fprintf(stderr, "Pushing submodule '%s'\n", path);
 480                 if (!push_submodule(path)) {
 481                         fprintf(stderr, "Unable to push submodule '%s'\n", path);
 482                         ret = 0;
 483                 }
 484         }
 485
 486         string_list_clear(&needs_pushing, 0);
 487
 488         return ret;
 489 }
 490
 491 static int is_submodule_commit_present(const char *path, unsigned char sha1[20])
 492 {
 493         int is_present = 0;
 494         if (!add_submodule_odb(path) && lookup_commit_reference(sha1)) {
 495                 /* Even if the submodule is checked out and the commit is
 496                  * present, make sure it is reachable from a ref. */
 497                 struct child_process cp = CHILD_PROCESS_INIT;
 498                 const char *argv[] = {"rev-list", "-n", "1", NULL, "--not", "--all", NULL};
 499                 struct strbuf buf = STRBUF_INIT;
 500
 501                 argv[3] = sha1_to_hex(sha1);
 502                 cp.argv = argv;
 503                 prepare_submodule_repo_env(&cp.env_array);
 504                 cp.git_cmd = 1;
 505                 cp.no_stdin = 1;
 506                 cp.dir = path;
 507                 if (!capture_command(&cp, &buf, 1024) && !buf.len)
 508                         is_present = 1;
 509
 510                 strbuf_release(&buf);
 511         }
 512         return is_present;
 513 }
 514
 515 static void submodule_collect_changed_cb(struct diff_queue_struct *q,
 516                                          struct diff_options *options,
 517                                          void *data)
 518 {
 519         int i;
 520         for (i = 0; i < q->nr; i++) {
 521                 struct diff_filepair *p = q->queue[i];
 522                 if (!S_ISGITLINK(p->two->mode))
 523                         continue;
 524
 525                 if (S_ISGITLINK(p->one->mode)) {
 526                         /* NEEDSWORK: We should honor the name configured in
 527                          * the .gitmodules file of the commit we are examining
 528                          * here to be able to correctly follow submodules
 529                          * being moved around. */
 530                         struct string_list_item *path;
 531                         path = unsorted_string_list_lookup(&changed_submodule_paths, p->two->path);
 532                         if (!path && !is_submodule_commit_present(p->two->path, p->two->sha1))
 533                                 string_list_append(&changed_submodule_paths, xstrdup(p->two->path));
 534                 } else {
 535                         /* Submodule is new or was moved here */
 536                         /* NEEDSWORK: When the .git directories of submodules
 537                          * live inside the superprojects .git directory some
 538                          * day we should fetch new submodules directly into
 539                          * that location too when config or options request
 540                          * that so they can be checked out from there. */
 541                         continue;
 542                 }
 543         }
 544 }
 545
 546 static int add_sha1_to_array(const char *ref, const struct object_id *oid,
 547                              int flags, void *data)
 548 {
 549         sha1_array_append(data, oid->hash);
 550         return 0;
 551 }
 552
 553 void check_for_new_submodule_commits(unsigned char new_sha1[20])
 554 {
 555         if (!initialized_fetch_ref_tips) {
 556                 for_each_ref(add_sha1_to_array, &ref_tips_before_fetch);
 557                 initialized_fetch_ref_tips = 1;
 558         }
 559
 560         sha1_array_append(&ref_tips_after_fetch, new_sha1);
 561 }
 562
 563 static void add_sha1_to_argv(const unsigned char sha1[20], void *data)
 564 {
 565         argv_array_push(data, sha1_to_hex(sha1));
 566 }
 567
 568 static void calculate_changed_submodule_paths(void)
 569 {
 570         struct rev_info rev;
 571         struct commit *commit;
 572         struct argv_array argv = ARGV_ARRAY_INIT;
 573
 574         /* No need to check if there are no submodules configured */
 575         if (!submodule_from_path(NULL, NULL))
 576                 return;
 577
 578         init_revisions(&rev, NULL);
 579         argv_array_push(&argv, "--"); /* argv[0] program name */
 580         sha1_array_for_each_unique(&ref_tips_after_fetch,
 581                                    add_sha1_to_argv, &argv);
 582         argv_array_push(&argv, "--not");
 583         sha1_array_for_each_unique(&ref_tips_before_fetch,
 584                                    add_sha1_to_argv, &argv);
 585         setup_revisions(argv.argc, argv.argv, &rev, NULL);
 586         if (prepare_revision_walk(&rev))
 587                 die("revision walk setup failed");
 588
 589         /*
 590          * Collect all submodules (whether checked out or not) for which new
 591          * commits have been recorded upstream in "changed_submodule_paths".
 592          */
 593         while ((commit = get_revision(&rev))) {
 594                 struct commit_list *parent = commit->parents;
 595                 while (parent) {
 596                         struct diff_options diff_opts;
 597                         diff_setup(&diff_opts);
 598                         DIFF_OPT_SET(&diff_opts, RECURSIVE);
 599                         diff_opts.output_format |= DIFF_FORMAT_CALLBACK;
 600                         diff_opts.format_callback = submodule_collect_changed_cb;
 601                         diff_setup_done(&diff_opts);
 602                         diff_tree_sha1(parent->item->object.oid.hash, commit->object.oid.hash, "", &diff_opts);
 603                         diffcore_std(&diff_opts);
 604                         diff_flush(&diff_opts);
 605                         parent = parent->next;
 606                 }
 607         }
 608
 609         argv_array_clear(&argv);
 610         sha1_array_clear(&ref_tips_before_fetch);
 611         sha1_array_clear(&ref_tips_after_fetch);
 612         initialized_fetch_ref_tips = 0;
 613 }
 614
 615 struct submodule_parallel_fetch {
 616         int count;
 617         struct argv_array args;
 618         const char *work_tree;
 619         const char *prefix;
 620         int command_line_option;
 621         int quiet;
 622         int result;
 623 };
 624 #define SPF_INIT {0, ARGV_ARRAY_INIT, NULL, NULL, 0, 0, 0}
 625
 626 static int get_next_submodule(struct child_process *cp,
 627                               struct strbuf *err, void *data, void **task_cb)
 628 {
 629         int ret = 0;
 630         struct submodule_parallel_fetch *spf = data;
 631
 632         for (; spf->count < active_nr; spf->count++) {
 633                 struct strbuf submodule_path = STRBUF_INIT;
 634                 struct strbuf submodule_git_dir = STRBUF_INIT;
 635                 struct strbuf submodule_prefix = STRBUF_INIT;
 636                 const struct cache_entry *ce = active_cache[spf->count];
 637                 const char *git_dir, *default_argv;
 638                 const struct submodule *submodule;
 639
 640                 if (!S_ISGITLINK(ce->ce_mode))
 641                         continue;
 642
 643                 submodule = submodule_from_path(null_sha1, ce->name);
 644                 if (!submodule)
 645                         submodule = submodule_from_name(null_sha1, ce->name);
 646
 647                 default_argv = "yes";
 648                 if (spf->command_line_option == RECURSE_SUBMODULES_DEFAULT) {
 649                         if (submodule &&
 650                             submodule->fetch_recurse !=
 651                                                 RECURSE_SUBMODULES_NONE) {
 652                                 if (submodule->fetch_recurse ==
 653                                                 RECURSE_SUBMODULES_OFF)
 654                                         continue;
 655                                 if (submodule->fetch_recurse ==
 656                                                 RECURSE_SUBMODULES_ON_DEMAND) {
 657                                         if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name))
 658                                                 continue;
 659                                         default_argv = "on-demand";
 660                                 }
 661                         } else {
 662                                 if ((config_fetch_recurse_submodules == RECURSE_SUBMODULES_OFF) ||
 663                                     gitmodules_is_unmerged)
 664                                         continue;
 665                                 if (config_fetch_recurse_submodules == RECURSE_SUBMODULES_ON_DEMAND) {
 666                                         if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name))
 667                                                 continue;
 668                                         default_argv = "on-demand";
 669                                 }
 670                         }
 671                 } else if (spf->command_line_option == RECURSE_SUBMODULES_ON_DEMAND) {
 672                         if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name))
 673                                 continue;
 674                         default_argv = "on-demand";
 675                 }
 676
 677                 strbuf_addf(&submodule_path, "%s/%s", spf->work_tree, ce->name);
 678                 strbuf_addf(&submodule_git_dir, "%s/.git", submodule_path.buf);
 679                 strbuf_addf(&submodule_prefix, "%s%s/", spf->prefix, ce->name);
 680                 git_dir = read_gitfile(submodule_git_dir.buf);
 681                 if (!git_dir)
 682                         git_dir = submodule_git_dir.buf;
 683                 if (is_directory(git_dir)) {
 684                         child_process_init(cp);
 685                         cp->dir = strbuf_detach(&submodule_path, NULL);
 686                         prepare_submodule_repo_env(&cp->env_array);
 687                         cp->git_cmd = 1;
 688                         if (!spf->quiet)
 689                                 strbuf_addf(err, "Fetching submodule %s%s\n",
 690                                             spf->prefix, ce->name);
 691                         argv_array_init(&cp->args);
 692                         argv_array_pushv(&cp->args, spf->args.argv);
 693                         argv_array_push(&cp->args, default_argv);
 694                         argv_array_push(&cp->args, "--submodule-prefix");
 695                         argv_array_push(&cp->args, submodule_prefix.buf);
 696                         ret = 1;
 697                 }
 698                 strbuf_release(&submodule_path);
 699                 strbuf_release(&submodule_git_dir);
 700                 strbuf_release(&submodule_prefix);
 701                 if (ret) {
 702                         spf->count++;
 703                         return 1;
 704                 }
 705         }
 706         return 0;
 707 }
 708
 709 static int fetch_start_failure(struct child_process *cp,
 710                                struct strbuf *err,
 711                                void *cb, void *task_cb)
 712 {
 713         struct submodule_parallel_fetch *spf = cb;
 714
 715         spf->result = 1;
 716
 717         return 0;
 718 }
 719
 720 static int fetch_finish(int retvalue, struct child_process *cp,
 721                         struct strbuf *err, void *cb, void *task_cb)
 722 {
 723         struct submodule_parallel_fetch *spf = cb;
 724
 725         if (retvalue)
 726                 spf->result = 1;
 727
 728         return 0;
 729 }
 730
 731 int fetch_populated_submodules(const struct argv_array *options,
 732                                const char *prefix, int command_line_option,
 733                                int quiet, int max_parallel_jobs)
 734 {
 735         int i;
 736         struct submodule_parallel_fetch spf = SPF_INIT;
 737
 738         spf.work_tree = get_git_work_tree();
 739         spf.command_line_option = command_line_option;
 740         spf.quiet = quiet;
 741         spf.prefix = prefix;
 742
 743         if (!spf.work_tree)
 744                 goto out;
 745
 746         if (read_cache() < 0)
 747                 die("index file corrupt");
 748
 749         argv_array_push(&spf.args, "fetch");
 750         for (i = 0; i < options->argc; i++)
 751                 argv_array_push(&spf.args, options->argv[i]);
 752         argv_array_push(&spf.args, "--recurse-submodules-default");
 753         /* default value, "--submodule-prefix" and its value are added later */
 754
 755         calculate_changed_submodule_paths();
 756         run_processes_parallel(max_parallel_jobs,
 757                                get_next_submodule,
 758                                fetch_start_failure,
 759                                fetch_finish,
 760                                &spf);
 761
 762         argv_array_clear(&spf.args);
 763 out:
 764         string_list_clear(&changed_submodule_paths, 1);
 765         return spf.result;
 766 }
 767
 768 unsigned is_submodule_modified(const char *path, int ignore_untracked)
 769 {
 770         ssize_t len;
 771         struct child_process cp = CHILD_PROCESS_INIT;
 772         const char *argv[] = {
 773                 "status",
 774                 "--porcelain",
 775                 NULL,
 776                 NULL,
 777         };
 778         struct strbuf buf = STRBUF_INIT;
 779         unsigned dirty_submodule = 0;
 780         const char *line, *next_line;
 781         const char *git_dir;
 782
 783         strbuf_addf(&buf, "%s/.git", path);
 784         git_dir = read_gitfile(buf.buf);
 785         if (!git_dir)
 786                 git_dir = buf.buf;
 787         if (!is_directory(git_dir)) {
 788                 strbuf_release(&buf);
 789                 /* The submodule is not checked out, so it is not modified */
 790                 return 0;
 791
 792         }
 793         strbuf_reset(&buf);
 794
 795         if (ignore_untracked)
 796                 argv[2] = "-uno";
 797
 798         cp.argv = argv;
 799         prepare_submodule_repo_env(&cp.env_array);
 800         cp.git_cmd = 1;
 801         cp.no_stdin = 1;
 802         cp.out = -1;
 803         cp.dir = path;
 804         if (start_command(&cp))
 805                 die("Could not run 'git status --porcelain' in submodule %s", path);
 806
 807         len = strbuf_read(&buf, cp.out, 1024);
 808         line = buf.buf;
 809         while (len > 2) {
 810                 if ((line[0] == '?') && (line[1] == '?')) {
 811                         dirty_submodule |= DIRTY_SUBMODULE_UNTRACKED;
 812                         if (dirty_submodule & DIRTY_SUBMODULE_MODIFIED)
 813                                 break;
 814                 } else {
 815                         dirty_submodule |= DIRTY_SUBMODULE_MODIFIED;
 816                         if (ignore_untracked ||
 817                             (dirty_submodule & DIRTY_SUBMODULE_UNTRACKED))
 818                                 break;
 819                 }
 820                 next_line = strchr(line, '\n');
 821                 if (!next_line)
 822                         break;
 823                 next_line++;
 824                 len -= (next_line - line);
 825                 line = next_line;
 826         }
 827         close(cp.out);
 828
 829         if (finish_command(&cp))
 830                 die("'git status --porcelain' failed in submodule %s", path);
 831
 832         strbuf_release(&buf);
 833         return dirty_submodule;
 834 }
 835
 836 int submodule_uses_gitfile(const char *path)
 837 {
 838         struct child_process cp = CHILD_PROCESS_INIT;
 839         const char *argv[] = {
 840                 "submodule",
 841                 "foreach",
 842                 "--quiet",
 843                 "--recursive",
 844                 "test -f .git",
 845                 NULL,
 846         };
 847         struct strbuf buf = STRBUF_INIT;
 848         const char *git_dir;
 849
 850         strbuf_addf(&buf, "%s/.git", path);
 851         git_dir = read_gitfile(buf.buf);
 852         if (!git_dir) {
 853                 strbuf_release(&buf);
 854                 return 0;
 855         }
 856         strbuf_release(&buf);
 857
 858         /* Now test that all nested submodules use a gitfile too */
 859         cp.argv = argv;
 860         prepare_submodule_repo_env(&cp.env_array);
 861         cp.git_cmd = 1;
 862         cp.no_stdin = 1;
 863         cp.no_stderr = 1;
 864         cp.no_stdout = 1;
 865         cp.dir = path;
 866         if (run_command(&cp))
 867                 return 0;
 868
 869         return 1;
 870 }
 871
 872 int ok_to_remove_submodule(const char *path)
 873 {
 874         ssize_t len;
 875         struct child_process cp = CHILD_PROCESS_INIT;
 876         const char *argv[] = {
 877                 "status",
 878                 "--porcelain",
 879                 "-u",
 880                 "--ignore-submodules=none",
 881                 NULL,
 882         };
 883         struct strbuf buf = STRBUF_INIT;
 884         int ok_to_remove = 1;
 885
 886         if (!file_exists(path) || is_empty_dir(path))
 887                 return 1;
 888
 889         if (!submodule_uses_gitfile(path))
 890                 return 0;
 891
 892         cp.argv = argv;
 893         prepare_submodule_repo_env(&cp.env_array);
 894         cp.git_cmd = 1;
 895         cp.no_stdin = 1;
 896         cp.out = -1;
 897         cp.dir = path;
 898         if (start_command(&cp))
 899                 die("Could not run 'git status --porcelain -uall --ignore-submodules=none' in submodule %s", path);
 900
 901         len = strbuf_read(&buf, cp.out, 1024);
 902         if (len > 2)
 903                 ok_to_remove = 0;
 904         close(cp.out);
 905
 906         if (finish_command(&cp))
 907                 die("'git status --porcelain -uall --ignore-submodules=none' failed in submodule %s", path);
 908
 909         strbuf_release(&buf);
 910         return ok_to_remove;
 911 }
 912
 913 static int find_first_merges(struct object_array *result, const char *path,
 914                 struct commit *a, struct commit *b)
 915 {
 916         int i, j;
 917         struct object_array merges = OBJECT_ARRAY_INIT;
 918         struct commit *commit;
 919         int contains_another;
 920
 921         char merged_revision[42];
 922         const char *rev_args[] = { "rev-list", "--merges", "--ancestry-path",
 923                                    "--all", merged_revision, NULL };
 924         struct rev_info revs;
 925         struct setup_revision_opt rev_opts;
 926
 927         memset(result, 0, sizeof(struct object_array));
 928         memset(&rev_opts, 0, sizeof(rev_opts));
 929
 930         /* get all revisions that merge commit a */
 931         snprintf(merged_revision, sizeof(merged_revision), "^%s",
 932                         oid_to_hex(&a->object.oid));
 933         init_revisions(&revs, NULL);
 934         rev_opts.submodule = path;
 935         setup_revisions(ARRAY_SIZE(rev_args)-1, rev_args, &revs, &rev_opts);
 936
 937         /* save all revisions from the above list that contain b */
 938         if (prepare_revision_walk(&revs))
 939                 die("revision walk setup failed");
 940         while ((commit = get_revision(&revs)) != NULL) {
 941                 struct object *o = &(commit->object);
 942                 if (in_merge_bases(b, commit))
 943                         add_object_array(o, NULL, &merges);
 944         }
 945         reset_revision_walk();
 946
 947         /* Now we've got all merges that contain a and b. Prune all
 948          * merges that contain another found merge and save them in
 949          * result.
 950          */
 951         for (i = 0; i < merges.nr; i++) {
 952                 struct commit *m1 = (struct commit *) merges.objects[i].item;
 953
 954                 contains_another = 0;
 955                 for (j = 0; j < merges.nr; j++) {
 956                         struct commit *m2 = (struct commit *) merges.objects[j].item;
 957                         if (i != j && in_merge_bases(m2, m1)) {
 958                                 contains_another = 1;
 959                                 break;
 960                         }
 961                 }
 962
 963                 if (!contains_another)
 964                         add_object_array(merges.objects[i].item, NULL, result);
 965         }
 966
 967         free(merges.objects);
 968         return result->nr;
 969 }
 970
 971 static void print_commit(struct commit *commit)
 972 {
 973         struct strbuf sb = STRBUF_INIT;
 974         struct pretty_print_context ctx = {0};
 975         ctx.date_mode.type = DATE_NORMAL;
 976         format_commit_message(commit, " %h: %m %s", &sb, &ctx);
 977         fprintf(stderr, "%s\n", sb.buf);
 978         strbuf_release(&sb);
 979 }
 980
 981 #define MERGE_WARNING(path, msg) \
 982         warning("Failed to merge submodule %s (%s)", path, msg);
 983
 984 int merge_submodule(unsigned char result[20], const char *path,
 985                     const unsigned char base[20], const unsigned char a[20],
 986                     const unsigned char b[20], int search)
 987 {
 988         struct commit *commit_base, *commit_a, *commit_b;
 989         int parent_count;
 990         struct object_array merges;
 991
 992         int i;
 993
 994         /* store a in result in case we fail */
 995         hashcpy(result, a);
 996
 997         /* we can not handle deletion conflicts */
 998         if (is_null_sha1(base))
 999                 return 0;
1000         if (is_null_sha1(a))
1001                 return 0;
1002         if (is_null_sha1(b))
1003                 return 0;
1004
1005         if (add_submodule_odb(path)) {
1006                 MERGE_WARNING(path, "not checked out");
1007                 return 0;
1008         }
1009
1010         if (!(commit_base = lookup_commit_reference(base)) ||
1011             !(commit_a = lookup_commit_reference(a)) ||
1012             !(commit_b = lookup_commit_reference(b))) {
1013                 MERGE_WARNING(path, "commits not present");
1014                 return 0;
1015         }
1016
1017         /* check whether both changes are forward */
1018         if (!in_merge_bases(commit_base, commit_a) ||
1019             !in_merge_bases(commit_base, commit_b)) {
1020                 MERGE_WARNING(path, "commits don't follow merge-base");
1021                 return 0;
1022         }
1023
1024         /* Case #1: a is contained in b or vice versa */
1025         if (in_merge_bases(commit_a, commit_b)) {
1026                 hashcpy(result, b);
1027                 return 1;
1028         }
1029         if (in_merge_bases(commit_b, commit_a)) {
1030                 hashcpy(result, a);
1031                 return 1;
1032         }
1033
1034         /*
1035          * Case #2: There are one or more merges that contain a and b in
1036          * the submodule. If there is only one, then present it as a
1037          * suggestion to the user, but leave it marked unmerged so the
1038          * user needs to confirm the resolution.
1039          */
1040
1041         /* Skip the search if makes no sense to the calling context.  */
1042         if (!search)
1043                 return 0;
1044
1045         /* find commit which merges them */
1046         parent_count = find_first_merges(&merges, path, commit_a, commit_b);
1047         switch (parent_count) {
1048         case 0:
1049                 MERGE_WARNING(path, "merge following commits not found");
1050                 break;
1051
1052         case 1:
1053                 MERGE_WARNING(path, "not fast-forward");
1054                 fprintf(stderr, "Found a possible merge resolution "
1055                                 "for the submodule:\n");
1056                 print_commit((struct commit *) merges.objects[0].item);
1057                 fprintf(stderr,
1058                         "If this is correct simply add it to the index "
1059                         "for example\n"
1060                         "by using:\n\n"
1061                         "  git update-index --cacheinfo 160000 %s \"%s\"\n\n"
1062                         "which will accept this suggestion.\n",
1063                         oid_to_hex(&merges.objects[0].item->oid), path);
1064                 break;
1065
1066         default:
1067                 MERGE_WARNING(path, "multiple merges found");
1068                 for (i = 0; i < merges.nr; i++)
1069                         print_commit((struct commit *) merges.objects[i].item);
1070         }
1071
1072         free(merges.objects);
1073         return 0;
1074 }
1075
1076 /* Update gitfile and core.worktree setting to connect work tree and git dir */
1077 void connect_work_tree_and_git_dir(const char *work_tree, const char *git_dir)
1078 {
1079         struct strbuf file_name = STRBUF_INIT;
1080         struct strbuf rel_path = STRBUF_INIT;
1081         const char *real_work_tree = xstrdup(real_path(work_tree));
1082
1083         /* Update gitfile */
1084         strbuf_addf(&file_name, "%s/.git", work_tree);
1085         write_file(file_name.buf, "gitdir: %s",
1086                    relative_path(git_dir, real_work_tree, &rel_path));
1087
1088         /* Update core.worktree setting */
1089         strbuf_reset(&file_name);
1090         strbuf_addf(&file_name, "%s/config", git_dir);
1091         if (git_config_set_in_file(file_name.buf, "core.worktree",
1092                                    relative_path(real_work_tree, git_dir,
1093                                                  &rel_path)))
1094                 die(_("Could not set core.worktree in %s"),
1095                     file_name.buf);
1096
1097         strbuf_release(&file_name);
1098         strbuf_release(&rel_path);
1099         free((void *)real_work_tree);
1100 }
1101
1102 void prepare_submodule_repo_env(struct argv_array *out)
1103 {
1104         const char * const *var;
1105
1106         for (var = local_repo_env; *var; var++) {
1107                 if (strcmp(*var, CONFIG_DATA_ENVIRONMENT))
1108                         argv_array_push(out, *var);
1109         }
1110 }