submodule.con commit Make sha1_array_append take a struct object_id * (98a72dd)
   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#include "worktree.h"
  18
  19static int config_fetch_recurse_submodules = RECURSE_SUBMODULES_ON_DEMAND;
  20static int parallel_jobs = 1;
  21static struct string_list changed_submodule_paths = STRING_LIST_INIT_NODUP;
  22static int initialized_fetch_ref_tips;
  23static struct sha1_array ref_tips_before_fetch;
  24static struct sha1_array ref_tips_after_fetch;
  25
  26/*
  27 * The following flag is set if the .gitmodules file is unmerged. We then
  28 * disable recursion for all submodules where .git/config doesn't have a
  29 * matching config entry because we can't guess what might be configured in
  30 * .gitmodules unless the user resolves the conflict. When a command line
  31 * option is given (which always overrides configuration) this flag will be
  32 * ignored.
  33 */
  34static int gitmodules_is_unmerged;
  35
  36/*
  37 * This flag is set if the .gitmodules file had unstaged modifications on
  38 * startup. This must be checked before allowing modifications to the
  39 * .gitmodules file with the intention to stage them later, because when
  40 * continuing we would stage the modifications the user didn't stage herself
  41 * too. That might change in a future version when we learn to stage the
  42 * changes we do ourselves without staging any previous modifications.
  43 */
  44static int gitmodules_is_modified;
  45
  46int is_staging_gitmodules_ok(void)
  47{
  48        return !gitmodules_is_modified;
  49}
  50
  51/*
  52 * Try to update the "path" entry in the "submodule.<name>" section of the
  53 * .gitmodules file. Return 0 only if a .gitmodules file was found, a section
  54 * with the correct path=<oldpath> setting was found and we could update it.
  55 */
  56int update_path_in_gitmodules(const char *oldpath, const char *newpath)
  57{
  58        struct strbuf entry = STRBUF_INIT;
  59        const struct submodule *submodule;
  60
  61        if (!file_exists(".gitmodules")) /* Do nothing without .gitmodules */
  62                return -1;
  63
  64        if (gitmodules_is_unmerged)
  65                die(_("Cannot change unmerged .gitmodules, resolve merge conflicts first"));
  66
  67        submodule = submodule_from_path(null_sha1, oldpath);
  68        if (!submodule || !submodule->name) {
  69                warning(_("Could not find section in .gitmodules where path=%s"), oldpath);
  70                return -1;
  71        }
  72        strbuf_addstr(&entry, "submodule.");
  73        strbuf_addstr(&entry, submodule->name);
  74        strbuf_addstr(&entry, ".path");
  75        if (git_config_set_in_file_gently(".gitmodules", entry.buf, newpath) < 0) {
  76                /* Maybe the user already did that, don't error out here */
  77                warning(_("Could not update .gitmodules entry %s"), entry.buf);
  78                strbuf_release(&entry);
  79                return -1;
  80        }
  81        strbuf_release(&entry);
  82        return 0;
  83}
  84
  85/*
  86 * Try to remove the "submodule.<name>" section from .gitmodules where the given
  87 * path is configured. Return 0 only if a .gitmodules file was found, a section
  88 * with the correct path=<path> setting was found and we could remove it.
  89 */
  90int remove_path_from_gitmodules(const char *path)
  91{
  92        struct strbuf sect = STRBUF_INIT;
  93        const struct submodule *submodule;
  94
  95        if (!file_exists(".gitmodules")) /* Do nothing without .gitmodules */
  96                return -1;
  97
  98        if (gitmodules_is_unmerged)
  99                die(_("Cannot change unmerged .gitmodules, resolve merge conflicts first"));
 100
 101        submodule = submodule_from_path(null_sha1, path);
 102        if (!submodule || !submodule->name) {
 103                warning(_("Could not find section in .gitmodules where path=%s"), path);
 104                return -1;
 105        }
 106        strbuf_addstr(&sect, "submodule.");
 107        strbuf_addstr(&sect, submodule->name);
 108        if (git_config_rename_section_in_file(".gitmodules", sect.buf, NULL) < 0) {
 109                /* Maybe the user already did that, don't error out here */
 110                warning(_("Could not remove .gitmodules entry for %s"), path);
 111                strbuf_release(&sect);
 112                return -1;
 113        }
 114        strbuf_release(&sect);
 115        return 0;
 116}
 117
 118void stage_updated_gitmodules(void)
 119{
 120        if (add_file_to_cache(".gitmodules", 0))
 121                die(_("staging updated .gitmodules failed"));
 122}
 123
 124static int add_submodule_odb(const char *path)
 125{
 126        struct strbuf objects_directory = STRBUF_INIT;
 127        int ret = 0;
 128
 129        ret = strbuf_git_path_submodule(&objects_directory, path, "objects/");
 130        if (ret)
 131                goto done;
 132        if (!is_directory(objects_directory.buf)) {
 133                ret = -1;
 134                goto done;
 135        }
 136        add_to_alternates_memory(objects_directory.buf);
 137done:
 138        strbuf_release(&objects_directory);
 139        return ret;
 140}
 141
 142void set_diffopt_flags_from_submodule_config(struct diff_options *diffopt,
 143                                             const char *path)
 144{
 145        const struct submodule *submodule = submodule_from_path(null_sha1, path);
 146        if (submodule) {
 147                if (submodule->ignore)
 148                        handle_ignore_submodules_arg(diffopt, submodule->ignore);
 149                else if (gitmodules_is_unmerged)
 150                        DIFF_OPT_SET(diffopt, IGNORE_SUBMODULES);
 151        }
 152}
 153
 154int submodule_config(const char *var, const char *value, void *cb)
 155{
 156        if (!strcmp(var, "submodule.fetchjobs")) {
 157                parallel_jobs = git_config_int(var, value);
 158                if (parallel_jobs < 0)
 159                        die(_("negative values not allowed for submodule.fetchJobs"));
 160                return 0;
 161        } else if (starts_with(var, "submodule."))
 162                return parse_submodule_config_option(var, value);
 163        else if (!strcmp(var, "fetch.recursesubmodules")) {
 164                config_fetch_recurse_submodules = parse_fetch_recurse_submodules_arg(var, value);
 165                return 0;
 166        }
 167        return 0;
 168}
 169
 170void gitmodules_config(void)
 171{
 172        const char *work_tree = get_git_work_tree();
 173        if (work_tree) {
 174                struct strbuf gitmodules_path = STRBUF_INIT;
 175                int pos;
 176                strbuf_addstr(&gitmodules_path, work_tree);
 177                strbuf_addstr(&gitmodules_path, "/.gitmodules");
 178                if (read_cache() < 0)
 179                        die("index file corrupt");
 180                pos = cache_name_pos(".gitmodules", 11);
 181                if (pos < 0) { /* .gitmodules not found or isn't merged */
 182                        pos = -1 - pos;
 183                        if (active_nr > pos) {  /* there is a .gitmodules */
 184                                const struct cache_entry *ce = active_cache[pos];
 185                                if (ce_namelen(ce) == 11 &&
 186                                    !memcmp(ce->name, ".gitmodules", 11))
 187                                        gitmodules_is_unmerged = 1;
 188                        }
 189                } else if (pos < active_nr) {
 190                        struct stat st;
 191                        if (lstat(".gitmodules", &st) == 0 &&
 192                            ce_match_stat(active_cache[pos], &st, 0) & DATA_CHANGED)
 193                                gitmodules_is_modified = 1;
 194                }
 195
 196                if (!gitmodules_is_unmerged)
 197                        git_config_from_file(submodule_config, gitmodules_path.buf, NULL);
 198                strbuf_release(&gitmodules_path);
 199        }
 200}
 201
 202void gitmodules_config_sha1(const unsigned char *commit_sha1)
 203{
 204        struct strbuf rev = STRBUF_INIT;
 205        unsigned char sha1[20];
 206
 207        if (gitmodule_sha1_from_commit(commit_sha1, sha1, &rev)) {
 208                git_config_from_blob_sha1(submodule_config, rev.buf,
 209                                          sha1, NULL);
 210        }
 211        strbuf_release(&rev);
 212}
 213
 214/*
 215 * Determine if a submodule has been initialized at a given 'path'
 216 */
 217int is_submodule_initialized(const char *path)
 218{
 219        int ret = 0;
 220        const struct submodule *module = NULL;
 221
 222        module = submodule_from_path(null_sha1, path);
 223
 224        if (module) {
 225                char *key = xstrfmt("submodule.%s.url", module->name);
 226                char *value = NULL;
 227
 228                ret = !git_config_get_string(key, &value);
 229
 230                free(value);
 231                free(key);
 232        }
 233
 234        return ret;
 235}
 236
 237/*
 238 * Determine if a submodule has been populated at a given 'path'
 239 */
 240int is_submodule_populated(const char *path)
 241{
 242        int ret = 0;
 243        char *gitdir = xstrfmt("%s/.git", path);
 244
 245        if (resolve_gitdir(gitdir))
 246                ret = 1;
 247
 248        free(gitdir);
 249        return ret;
 250}
 251
 252int parse_submodule_update_strategy(const char *value,
 253                struct submodule_update_strategy *dst)
 254{
 255        free((void*)dst->command);
 256        dst->command = NULL;
 257        if (!strcmp(value, "none"))
 258                dst->type = SM_UPDATE_NONE;
 259        else if (!strcmp(value, "checkout"))
 260                dst->type = SM_UPDATE_CHECKOUT;
 261        else if (!strcmp(value, "rebase"))
 262                dst->type = SM_UPDATE_REBASE;
 263        else if (!strcmp(value, "merge"))
 264                dst->type = SM_UPDATE_MERGE;
 265        else if (skip_prefix(value, "!", &value)) {
 266                dst->type = SM_UPDATE_COMMAND;
 267                dst->command = xstrdup(value);
 268        } else
 269                return -1;
 270        return 0;
 271}
 272
 273const char *submodule_strategy_to_string(const struct submodule_update_strategy *s)
 274{
 275        struct strbuf sb = STRBUF_INIT;
 276        switch (s->type) {
 277        case SM_UPDATE_CHECKOUT:
 278                return "checkout";
 279        case SM_UPDATE_MERGE:
 280                return "merge";
 281        case SM_UPDATE_REBASE:
 282                return "rebase";
 283        case SM_UPDATE_NONE:
 284                return "none";
 285        case SM_UPDATE_UNSPECIFIED:
 286                return NULL;
 287        case SM_UPDATE_COMMAND:
 288                strbuf_addf(&sb, "!%s", s->command);
 289                return strbuf_detach(&sb, NULL);
 290        }
 291        return NULL;
 292}
 293
 294void handle_ignore_submodules_arg(struct diff_options *diffopt,
 295                                  const char *arg)
 296{
 297        DIFF_OPT_CLR(diffopt, IGNORE_SUBMODULES);
 298        DIFF_OPT_CLR(diffopt, IGNORE_UNTRACKED_IN_SUBMODULES);
 299        DIFF_OPT_CLR(diffopt, IGNORE_DIRTY_SUBMODULES);
 300
 301        if (!strcmp(arg, "all"))
 302                DIFF_OPT_SET(diffopt, IGNORE_SUBMODULES);
 303        else if (!strcmp(arg, "untracked"))
 304                DIFF_OPT_SET(diffopt, IGNORE_UNTRACKED_IN_SUBMODULES);
 305        else if (!strcmp(arg, "dirty"))
 306                DIFF_OPT_SET(diffopt, IGNORE_DIRTY_SUBMODULES);
 307        else if (strcmp(arg, "none"))
 308                die("bad --ignore-submodules argument: %s", arg);
 309}
 310
 311static int prepare_submodule_summary(struct rev_info *rev, const char *path,
 312                struct commit *left, struct commit *right,
 313                struct commit_list *merge_bases)
 314{
 315        struct commit_list *list;
 316
 317        init_revisions(rev, NULL);
 318        setup_revisions(0, NULL, rev, NULL);
 319        rev->left_right = 1;
 320        rev->first_parent_only = 1;
 321        left->object.flags |= SYMMETRIC_LEFT;
 322        add_pending_object(rev, &left->object, path);
 323        add_pending_object(rev, &right->object, path);
 324        for (list = merge_bases; list; list = list->next) {
 325                list->item->object.flags |= UNINTERESTING;
 326                add_pending_object(rev, &list->item->object,
 327                        oid_to_hex(&list->item->object.oid));
 328        }
 329        return prepare_revision_walk(rev);
 330}
 331
 332static void print_submodule_summary(struct rev_info *rev, FILE *f,
 333                const char *line_prefix,
 334                const char *del, const char *add, const char *reset)
 335{
 336        static const char format[] = "  %m %s";
 337        struct strbuf sb = STRBUF_INIT;
 338        struct commit *commit;
 339
 340        while ((commit = get_revision(rev))) {
 341                struct pretty_print_context ctx = {0};
 342                ctx.date_mode = rev->date_mode;
 343                ctx.output_encoding = get_log_output_encoding();
 344                strbuf_setlen(&sb, 0);
 345                strbuf_addstr(&sb, line_prefix);
 346                if (commit->object.flags & SYMMETRIC_LEFT) {
 347                        if (del)
 348                                strbuf_addstr(&sb, del);
 349                }
 350                else if (add)
 351                        strbuf_addstr(&sb, add);
 352                format_commit_message(commit, format, &sb, &ctx);
 353                if (reset)
 354                        strbuf_addstr(&sb, reset);
 355                strbuf_addch(&sb, '\n');
 356                fprintf(f, "%s", sb.buf);
 357        }
 358        strbuf_release(&sb);
 359}
 360
 361/* Helper function to display the submodule header line prior to the full
 362 * summary output. If it can locate the submodule objects directory it will
 363 * attempt to lookup both the left and right commits and put them into the
 364 * left and right pointers.
 365 */
 366static void show_submodule_header(FILE *f, const char *path,
 367                const char *line_prefix,
 368                struct object_id *one, struct object_id *two,
 369                unsigned dirty_submodule, const char *meta,
 370                const char *reset,
 371                struct commit **left, struct commit **right,
 372                struct commit_list **merge_bases)
 373{
 374        const char *message = NULL;
 375        struct strbuf sb = STRBUF_INIT;
 376        int fast_forward = 0, fast_backward = 0;
 377
 378        if (dirty_submodule & DIRTY_SUBMODULE_UNTRACKED)
 379                fprintf(f, "%sSubmodule %s contains untracked content\n",
 380                        line_prefix, path);
 381        if (dirty_submodule & DIRTY_SUBMODULE_MODIFIED)
 382                fprintf(f, "%sSubmodule %s contains modified content\n",
 383                        line_prefix, path);
 384
 385        if (is_null_oid(one))
 386                message = "(new submodule)";
 387        else if (is_null_oid(two))
 388                message = "(submodule deleted)";
 389
 390        if (add_submodule_odb(path)) {
 391                if (!message)
 392                        message = "(not initialized)";
 393                goto output_header;
 394        }
 395
 396        /*
 397         * Attempt to lookup the commit references, and determine if this is
 398         * a fast forward or fast backwards update.
 399         */
 400        *left = lookup_commit_reference(one->hash);
 401        *right = lookup_commit_reference(two->hash);
 402
 403        /*
 404         * Warn about missing commits in the submodule project, but only if
 405         * they aren't null.
 406         */
 407        if ((!is_null_oid(one) && !*left) ||
 408             (!is_null_oid(two) && !*right))
 409                message = "(commits not present)";
 410
 411        *merge_bases = get_merge_bases(*left, *right);
 412        if (*merge_bases) {
 413                if ((*merge_bases)->item == *left)
 414                        fast_forward = 1;
 415                else if ((*merge_bases)->item == *right)
 416                        fast_backward = 1;
 417        }
 418
 419        if (!oidcmp(one, two)) {
 420                strbuf_release(&sb);
 421                return;
 422        }
 423
 424output_header:
 425        strbuf_addf(&sb, "%s%sSubmodule %s ", line_prefix, meta, path);
 426        strbuf_add_unique_abbrev(&sb, one->hash, DEFAULT_ABBREV);
 427        strbuf_addstr(&sb, (fast_backward || fast_forward) ? ".." : "...");
 428        strbuf_add_unique_abbrev(&sb, two->hash, DEFAULT_ABBREV);
 429        if (message)
 430                strbuf_addf(&sb, " %s%s\n", message, reset);
 431        else
 432                strbuf_addf(&sb, "%s:%s\n", fast_backward ? " (rewind)" : "", reset);
 433        fwrite(sb.buf, sb.len, 1, f);
 434
 435        strbuf_release(&sb);
 436}
 437
 438void show_submodule_summary(FILE *f, const char *path,
 439                const char *line_prefix,
 440                struct object_id *one, struct object_id *two,
 441                unsigned dirty_submodule, const char *meta,
 442                const char *del, const char *add, const char *reset)
 443{
 444        struct rev_info rev;
 445        struct commit *left = NULL, *right = NULL;
 446        struct commit_list *merge_bases = NULL;
 447
 448        show_submodule_header(f, path, line_prefix, one, two, dirty_submodule,
 449                              meta, reset, &left, &right, &merge_bases);
 450
 451        /*
 452         * If we don't have both a left and a right pointer, there is no
 453         * reason to try and display a summary. The header line should contain
 454         * all the information the user needs.
 455         */
 456        if (!left || !right)
 457                goto out;
 458
 459        /* Treat revision walker failure the same as missing commits */
 460        if (prepare_submodule_summary(&rev, path, left, right, merge_bases)) {
 461                fprintf(f, "%s(revision walker failed)\n", line_prefix);
 462                goto out;
 463        }
 464
 465        print_submodule_summary(&rev, f, line_prefix, del, add, reset);
 466
 467out:
 468        if (merge_bases)
 469                free_commit_list(merge_bases);
 470        clear_commit_marks(left, ~0);
 471        clear_commit_marks(right, ~0);
 472}
 473
 474void show_submodule_inline_diff(FILE *f, const char *path,
 475                const char *line_prefix,
 476                struct object_id *one, struct object_id *two,
 477                unsigned dirty_submodule, const char *meta,
 478                const char *del, const char *add, const char *reset,
 479                const struct diff_options *o)
 480{
 481        const struct object_id *old = &empty_tree_oid, *new = &empty_tree_oid;
 482        struct commit *left = NULL, *right = NULL;
 483        struct commit_list *merge_bases = NULL;
 484        struct strbuf submodule_dir = STRBUF_INIT;
 485        struct child_process cp = CHILD_PROCESS_INIT;
 486
 487        show_submodule_header(f, path, line_prefix, one, two, dirty_submodule,
 488                              meta, reset, &left, &right, &merge_bases);
 489
 490        /* We need a valid left and right commit to display a difference */
 491        if (!(left || is_null_oid(one)) ||
 492            !(right || is_null_oid(two)))
 493                goto done;
 494
 495        if (left)
 496                old = one;
 497        if (right)
 498                new = two;
 499
 500        fflush(f);
 501        cp.git_cmd = 1;
 502        cp.dir = path;
 503        cp.out = dup(fileno(f));
 504        cp.no_stdin = 1;
 505
 506        /* TODO: other options may need to be passed here. */
 507        argv_array_push(&cp.args, "diff");
 508        argv_array_pushf(&cp.args, "--line-prefix=%s", line_prefix);
 509        if (DIFF_OPT_TST(o, REVERSE_DIFF)) {
 510                argv_array_pushf(&cp.args, "--src-prefix=%s%s/",
 511                                 o->b_prefix, path);
 512                argv_array_pushf(&cp.args, "--dst-prefix=%s%s/",
 513                                 o->a_prefix, path);
 514        } else {
 515                argv_array_pushf(&cp.args, "--src-prefix=%s%s/",
 516                                 o->a_prefix, path);
 517                argv_array_pushf(&cp.args, "--dst-prefix=%s%s/",
 518                                 o->b_prefix, path);
 519        }
 520        argv_array_push(&cp.args, oid_to_hex(old));
 521        /*
 522         * If the submodule has modified content, we will diff against the
 523         * work tree, under the assumption that the user has asked for the
 524         * diff format and wishes to actually see all differences even if they
 525         * haven't yet been committed to the submodule yet.
 526         */
 527        if (!(dirty_submodule & DIRTY_SUBMODULE_MODIFIED))
 528                argv_array_push(&cp.args, oid_to_hex(new));
 529
 530        if (run_command(&cp))
 531                fprintf(f, "(diff failed)\n");
 532
 533done:
 534        strbuf_release(&submodule_dir);
 535        if (merge_bases)
 536                free_commit_list(merge_bases);
 537        if (left)
 538                clear_commit_marks(left, ~0);
 539        if (right)
 540                clear_commit_marks(right, ~0);
 541}
 542
 543void set_config_fetch_recurse_submodules(int value)
 544{
 545        config_fetch_recurse_submodules = value;
 546}
 547
 548static int has_remote(const char *refname, const struct object_id *oid,
 549                      int flags, void *cb_data)
 550{
 551        return 1;
 552}
 553
 554static int append_sha1_to_argv(const unsigned char sha1[20], void *data)
 555{
 556        struct argv_array *argv = data;
 557        argv_array_push(argv, sha1_to_hex(sha1));
 558        return 0;
 559}
 560
 561static int check_has_commit(const unsigned char sha1[20], void *data)
 562{
 563        int *has_commit = data;
 564
 565        if (!lookup_commit_reference(sha1))
 566                *has_commit = 0;
 567
 568        return 0;
 569}
 570
 571static int submodule_has_commits(const char *path, struct sha1_array *commits)
 572{
 573        int has_commit = 1;
 574
 575        if (add_submodule_odb(path))
 576                return 0;
 577
 578        sha1_array_for_each_unique(commits, check_has_commit, &has_commit);
 579        return has_commit;
 580}
 581
 582static int submodule_needs_pushing(const char *path, struct sha1_array *commits)
 583{
 584        if (!submodule_has_commits(path, commits))
 585                /*
 586                 * NOTE: We do consider it safe to return "no" here. The
 587                 * correct answer would be "We do not know" instead of
 588                 * "No push needed", but it is quite hard to change
 589                 * the submodule pointer without having the submodule
 590                 * around. If a user did however change the submodules
 591                 * without having the submodule around, this indicates
 592                 * an expert who knows what they are doing or a
 593                 * maintainer integrating work from other people. In
 594                 * both cases it should be safe to skip this check.
 595                 */
 596                return 0;
 597
 598        if (for_each_remote_ref_submodule(path, has_remote, NULL) > 0) {
 599                struct child_process cp = CHILD_PROCESS_INIT;
 600                struct strbuf buf = STRBUF_INIT;
 601                int needs_pushing = 0;
 602
 603                argv_array_push(&cp.args, "rev-list");
 604                sha1_array_for_each_unique(commits, append_sha1_to_argv, &cp.args);
 605                argv_array_pushl(&cp.args, "--not", "--remotes", "-n", "1" , NULL);
 606
 607                prepare_submodule_repo_env(&cp.env_array);
 608                cp.git_cmd = 1;
 609                cp.no_stdin = 1;
 610                cp.out = -1;
 611                cp.dir = path;
 612                if (start_command(&cp))
 613                        die("Could not run 'git rev-list <commits> --not --remotes -n 1' command in submodule %s",
 614                                        path);
 615                if (strbuf_read(&buf, cp.out, 41))
 616                        needs_pushing = 1;
 617                finish_command(&cp);
 618                close(cp.out);
 619                strbuf_release(&buf);
 620                return needs_pushing;
 621        }
 622
 623        return 0;
 624}
 625
 626static struct sha1_array *submodule_commits(struct string_list *submodules,
 627                                            const char *path)
 628{
 629        struct string_list_item *item;
 630
 631        item = string_list_insert(submodules, path);
 632        if (item->util)
 633                return (struct sha1_array *) item->util;
 634
 635        /* NEEDSWORK: should we have sha1_array_init()? */
 636        item->util = xcalloc(1, sizeof(struct sha1_array));
 637        return (struct sha1_array *) item->util;
 638}
 639
 640static void collect_submodules_from_diff(struct diff_queue_struct *q,
 641                                         struct diff_options *options,
 642                                         void *data)
 643{
 644        int i;
 645        struct string_list *submodules = data;
 646
 647        for (i = 0; i < q->nr; i++) {
 648                struct diff_filepair *p = q->queue[i];
 649                struct sha1_array *commits;
 650                if (!S_ISGITLINK(p->two->mode))
 651                        continue;
 652                commits = submodule_commits(submodules, p->two->path);
 653                sha1_array_append(commits, &p->two->oid);
 654        }
 655}
 656
 657static void find_unpushed_submodule_commits(struct commit *commit,
 658                struct string_list *needs_pushing)
 659{
 660        struct rev_info rev;
 661
 662        init_revisions(&rev, NULL);
 663        rev.diffopt.output_format |= DIFF_FORMAT_CALLBACK;
 664        rev.diffopt.format_callback = collect_submodules_from_diff;
 665        rev.diffopt.format_callback_data = needs_pushing;
 666        diff_tree_combined_merge(commit, 1, &rev);
 667}
 668
 669static void free_submodules_sha1s(struct string_list *submodules)
 670{
 671        struct string_list_item *item;
 672        for_each_string_list_item(item, submodules)
 673                sha1_array_clear((struct sha1_array *) item->util);
 674        string_list_clear(submodules, 1);
 675}
 676
 677int find_unpushed_submodules(struct sha1_array *commits,
 678                const char *remotes_name, struct string_list *needs_pushing)
 679{
 680        struct rev_info rev;
 681        struct commit *commit;
 682        struct string_list submodules = STRING_LIST_INIT_DUP;
 683        struct string_list_item *submodule;
 684        struct argv_array argv = ARGV_ARRAY_INIT;
 685
 686        init_revisions(&rev, NULL);
 687
 688        /* argv.argv[0] will be ignored by setup_revisions */
 689        argv_array_push(&argv, "find_unpushed_submodules");
 690        sha1_array_for_each_unique(commits, append_sha1_to_argv, &argv);
 691        argv_array_push(&argv, "--not");
 692        argv_array_pushf(&argv, "--remotes=%s", remotes_name);
 693
 694        setup_revisions(argv.argc, argv.argv, &rev, NULL);
 695        if (prepare_revision_walk(&rev))
 696                die("revision walk setup failed");
 697
 698        while ((commit = get_revision(&rev)) != NULL)
 699                find_unpushed_submodule_commits(commit, &submodules);
 700
 701        reset_revision_walk();
 702        argv_array_clear(&argv);
 703
 704        for_each_string_list_item(submodule, &submodules) {
 705                struct sha1_array *commits = (struct sha1_array *) submodule->util;
 706
 707                if (submodule_needs_pushing(submodule->string, commits))
 708                        string_list_insert(needs_pushing, submodule->string);
 709        }
 710        free_submodules_sha1s(&submodules);
 711
 712        return needs_pushing->nr;
 713}
 714
 715static int push_submodule(const char *path, int dry_run)
 716{
 717        if (add_submodule_odb(path))
 718                return 1;
 719
 720        if (for_each_remote_ref_submodule(path, has_remote, NULL) > 0) {
 721                struct child_process cp = CHILD_PROCESS_INIT;
 722                argv_array_push(&cp.args, "push");
 723                if (dry_run)
 724                        argv_array_push(&cp.args, "--dry-run");
 725
 726                prepare_submodule_repo_env(&cp.env_array);
 727                cp.git_cmd = 1;
 728                cp.no_stdin = 1;
 729                cp.dir = path;
 730                if (run_command(&cp))
 731                        return 0;
 732                close(cp.out);
 733        }
 734
 735        return 1;
 736}
 737
 738int push_unpushed_submodules(struct sha1_array *commits,
 739                             const char *remotes_name,
 740                             int dry_run)
 741{
 742        int i, ret = 1;
 743        struct string_list needs_pushing = STRING_LIST_INIT_DUP;
 744
 745        if (!find_unpushed_submodules(commits, remotes_name, &needs_pushing))
 746                return 1;
 747
 748        for (i = 0; i < needs_pushing.nr; i++) {
 749                const char *path = needs_pushing.items[i].string;
 750                fprintf(stderr, "Pushing submodule '%s'\n", path);
 751                if (!push_submodule(path, dry_run)) {
 752                        fprintf(stderr, "Unable to push submodule '%s'\n", path);
 753                        ret = 0;
 754                }
 755        }
 756
 757        string_list_clear(&needs_pushing, 0);
 758
 759        return ret;
 760}
 761
 762static int is_submodule_commit_present(const char *path, unsigned char sha1[20])
 763{
 764        int is_present = 0;
 765        if (!add_submodule_odb(path) && lookup_commit_reference(sha1)) {
 766                /* Even if the submodule is checked out and the commit is
 767                 * present, make sure it is reachable from a ref. */
 768                struct child_process cp = CHILD_PROCESS_INIT;
 769                const char *argv[] = {"rev-list", "-n", "1", NULL, "--not", "--all", NULL};
 770                struct strbuf buf = STRBUF_INIT;
 771
 772                argv[3] = sha1_to_hex(sha1);
 773                cp.argv = argv;
 774                prepare_submodule_repo_env(&cp.env_array);
 775                cp.git_cmd = 1;
 776                cp.no_stdin = 1;
 777                cp.dir = path;
 778                if (!capture_command(&cp, &buf, 1024) && !buf.len)
 779                        is_present = 1;
 780
 781                strbuf_release(&buf);
 782        }
 783        return is_present;
 784}
 785
 786static void submodule_collect_changed_cb(struct diff_queue_struct *q,
 787                                         struct diff_options *options,
 788                                         void *data)
 789{
 790        int i;
 791        for (i = 0; i < q->nr; i++) {
 792                struct diff_filepair *p = q->queue[i];
 793                if (!S_ISGITLINK(p->two->mode))
 794                        continue;
 795
 796                if (S_ISGITLINK(p->one->mode)) {
 797                        /* NEEDSWORK: We should honor the name configured in
 798                         * the .gitmodules file of the commit we are examining
 799                         * here to be able to correctly follow submodules
 800                         * being moved around. */
 801                        struct string_list_item *path;
 802                        path = unsorted_string_list_lookup(&changed_submodule_paths, p->two->path);
 803                        if (!path && !is_submodule_commit_present(p->two->path, p->two->oid.hash))
 804                                string_list_append(&changed_submodule_paths, xstrdup(p->two->path));
 805                } else {
 806                        /* Submodule is new or was moved here */
 807                        /* NEEDSWORK: When the .git directories of submodules
 808                         * live inside the superprojects .git directory some
 809                         * day we should fetch new submodules directly into
 810                         * that location too when config or options request
 811                         * that so they can be checked out from there. */
 812                        continue;
 813                }
 814        }
 815}
 816
 817static int add_sha1_to_array(const char *ref, const struct object_id *oid,
 818                             int flags, void *data)
 819{
 820        sha1_array_append(data, oid);
 821        return 0;
 822}
 823
 824void check_for_new_submodule_commits(struct object_id *oid)
 825{
 826        if (!initialized_fetch_ref_tips) {
 827                for_each_ref(add_sha1_to_array, &ref_tips_before_fetch);
 828                initialized_fetch_ref_tips = 1;
 829        }
 830
 831        sha1_array_append(&ref_tips_after_fetch, oid);
 832}
 833
 834static int add_sha1_to_argv(const unsigned char sha1[20], void *data)
 835{
 836        argv_array_push(data, sha1_to_hex(sha1));
 837        return 0;
 838}
 839
 840static void calculate_changed_submodule_paths(void)
 841{
 842        struct rev_info rev;
 843        struct commit *commit;
 844        struct argv_array argv = ARGV_ARRAY_INIT;
 845
 846        /* No need to check if there are no submodules configured */
 847        if (!submodule_from_path(NULL, NULL))
 848                return;
 849
 850        init_revisions(&rev, NULL);
 851        argv_array_push(&argv, "--"); /* argv[0] program name */
 852        sha1_array_for_each_unique(&ref_tips_after_fetch,
 853                                   add_sha1_to_argv, &argv);
 854        argv_array_push(&argv, "--not");
 855        sha1_array_for_each_unique(&ref_tips_before_fetch,
 856                                   add_sha1_to_argv, &argv);
 857        setup_revisions(argv.argc, argv.argv, &rev, NULL);
 858        if (prepare_revision_walk(&rev))
 859                die("revision walk setup failed");
 860
 861        /*
 862         * Collect all submodules (whether checked out or not) for which new
 863         * commits have been recorded upstream in "changed_submodule_paths".
 864         */
 865        while ((commit = get_revision(&rev))) {
 866                struct commit_list *parent = commit->parents;
 867                while (parent) {
 868                        struct diff_options diff_opts;
 869                        diff_setup(&diff_opts);
 870                        DIFF_OPT_SET(&diff_opts, RECURSIVE);
 871                        diff_opts.output_format |= DIFF_FORMAT_CALLBACK;
 872                        diff_opts.format_callback = submodule_collect_changed_cb;
 873                        diff_setup_done(&diff_opts);
 874                        diff_tree_sha1(parent->item->object.oid.hash, commit->object.oid.hash, "", &diff_opts);
 875                        diffcore_std(&diff_opts);
 876                        diff_flush(&diff_opts);
 877                        parent = parent->next;
 878                }
 879        }
 880
 881        argv_array_clear(&argv);
 882        sha1_array_clear(&ref_tips_before_fetch);
 883        sha1_array_clear(&ref_tips_after_fetch);
 884        initialized_fetch_ref_tips = 0;
 885}
 886
 887struct submodule_parallel_fetch {
 888        int count;
 889        struct argv_array args;
 890        const char *work_tree;
 891        const char *prefix;
 892        int command_line_option;
 893        int quiet;
 894        int result;
 895};
 896#define SPF_INIT {0, ARGV_ARRAY_INIT, NULL, NULL, 0, 0, 0}
 897
 898static int get_next_submodule(struct child_process *cp,
 899                              struct strbuf *err, void *data, void **task_cb)
 900{
 901        int ret = 0;
 902        struct submodule_parallel_fetch *spf = data;
 903
 904        for (; spf->count < active_nr; spf->count++) {
 905                struct strbuf submodule_path = STRBUF_INIT;
 906                struct strbuf submodule_git_dir = STRBUF_INIT;
 907                struct strbuf submodule_prefix = STRBUF_INIT;
 908                const struct cache_entry *ce = active_cache[spf->count];
 909                const char *git_dir, *default_argv;
 910                const struct submodule *submodule;
 911
 912                if (!S_ISGITLINK(ce->ce_mode))
 913                        continue;
 914
 915                submodule = submodule_from_path(null_sha1, ce->name);
 916                if (!submodule)
 917                        submodule = submodule_from_name(null_sha1, ce->name);
 918
 919                default_argv = "yes";
 920                if (spf->command_line_option == RECURSE_SUBMODULES_DEFAULT) {
 921                        if (submodule &&
 922                            submodule->fetch_recurse !=
 923                                                RECURSE_SUBMODULES_NONE) {
 924                                if (submodule->fetch_recurse ==
 925                                                RECURSE_SUBMODULES_OFF)
 926                                        continue;
 927                                if (submodule->fetch_recurse ==
 928                                                RECURSE_SUBMODULES_ON_DEMAND) {
 929                                        if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name))
 930                                                continue;
 931                                        default_argv = "on-demand";
 932                                }
 933                        } else {
 934                                if ((config_fetch_recurse_submodules == RECURSE_SUBMODULES_OFF) ||
 935                                    gitmodules_is_unmerged)
 936                                        continue;
 937                                if (config_fetch_recurse_submodules == RECURSE_SUBMODULES_ON_DEMAND) {
 938                                        if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name))
 939                                                continue;
 940                                        default_argv = "on-demand";
 941                                }
 942                        }
 943                } else if (spf->command_line_option == RECURSE_SUBMODULES_ON_DEMAND) {
 944                        if (!unsorted_string_list_lookup(&changed_submodule_paths, ce->name))
 945                                continue;
 946                        default_argv = "on-demand";
 947                }
 948
 949                strbuf_addf(&submodule_path, "%s/%s", spf->work_tree, ce->name);
 950                strbuf_addf(&submodule_git_dir, "%s/.git", submodule_path.buf);
 951                strbuf_addf(&submodule_prefix, "%s%s/", spf->prefix, ce->name);
 952                git_dir = read_gitfile(submodule_git_dir.buf);
 953                if (!git_dir)
 954                        git_dir = submodule_git_dir.buf;
 955                if (is_directory(git_dir)) {
 956                        child_process_init(cp);
 957                        cp->dir = strbuf_detach(&submodule_path, NULL);
 958                        prepare_submodule_repo_env(&cp->env_array);
 959                        cp->git_cmd = 1;
 960                        if (!spf->quiet)
 961                                strbuf_addf(err, "Fetching submodule %s%s\n",
 962                                            spf->prefix, ce->name);
 963                        argv_array_init(&cp->args);
 964                        argv_array_pushv(&cp->args, spf->args.argv);
 965                        argv_array_push(&cp->args, default_argv);
 966                        argv_array_push(&cp->args, "--submodule-prefix");
 967                        argv_array_push(&cp->args, submodule_prefix.buf);
 968                        ret = 1;
 969                }
 970                strbuf_release(&submodule_path);
 971                strbuf_release(&submodule_git_dir);
 972                strbuf_release(&submodule_prefix);
 973                if (ret) {
 974                        spf->count++;
 975                        return 1;
 976                }
 977        }
 978        return 0;
 979}
 980
 981static int fetch_start_failure(struct strbuf *err,
 982                               void *cb, void *task_cb)
 983{
 984        struct submodule_parallel_fetch *spf = cb;
 985
 986        spf->result = 1;
 987
 988        return 0;
 989}
 990
 991static int fetch_finish(int retvalue, struct strbuf *err,
 992                        void *cb, void *task_cb)
 993{
 994        struct submodule_parallel_fetch *spf = cb;
 995
 996        if (retvalue)
 997                spf->result = 1;
 998
 999        return 0;
1000}
1001
1002int fetch_populated_submodules(const struct argv_array *options,
1003                               const char *prefix, int command_line_option,
1004                               int quiet, int max_parallel_jobs)
1005{
1006        int i;
1007        struct submodule_parallel_fetch spf = SPF_INIT;
1008
1009        spf.work_tree = get_git_work_tree();
1010        spf.command_line_option = command_line_option;
1011        spf.quiet = quiet;
1012        spf.prefix = prefix;
1013
1014        if (!spf.work_tree)
1015                goto out;
1016
1017        if (read_cache() < 0)
1018                die("index file corrupt");
1019
1020        argv_array_push(&spf.args, "fetch");
1021        for (i = 0; i < options->argc; i++)
1022                argv_array_push(&spf.args, options->argv[i]);
1023        argv_array_push(&spf.args, "--recurse-submodules-default");
1024        /* default value, "--submodule-prefix" and its value are added later */
1025
1026        if (max_parallel_jobs < 0)
1027                max_parallel_jobs = parallel_jobs;
1028
1029        calculate_changed_submodule_paths();
1030        run_processes_parallel(max_parallel_jobs,
1031                               get_next_submodule,
1032                               fetch_start_failure,
1033                               fetch_finish,
1034                               &spf);
1035
1036        argv_array_clear(&spf.args);
1037out:
1038        string_list_clear(&changed_submodule_paths, 1);
1039        return spf.result;
1040}
1041
1042unsigned is_submodule_modified(const char *path, int ignore_untracked)
1043{
1044        ssize_t len;
1045        struct child_process cp = CHILD_PROCESS_INIT;
1046        const char *argv[] = {
1047                "status",
1048                "--porcelain",
1049                NULL,
1050                NULL,
1051        };
1052        struct strbuf buf = STRBUF_INIT;
1053        unsigned dirty_submodule = 0;
1054        const char *line, *next_line;
1055        const char *git_dir;
1056
1057        strbuf_addf(&buf, "%s/.git", path);
1058        git_dir = read_gitfile(buf.buf);
1059        if (!git_dir)
1060                git_dir = buf.buf;
1061        if (!is_directory(git_dir)) {
1062                strbuf_release(&buf);
1063                /* The submodule is not checked out, so it is not modified */
1064                return 0;
1065
1066        }
1067        strbuf_reset(&buf);
1068
1069        if (ignore_untracked)
1070                argv[2] = "-uno";
1071
1072        cp.argv = argv;
1073        prepare_submodule_repo_env(&cp.env_array);
1074        cp.git_cmd = 1;
1075        cp.no_stdin = 1;
1076        cp.out = -1;
1077        cp.dir = path;
1078        if (start_command(&cp))
1079                die("Could not run 'git status --porcelain' in submodule %s", path);
1080
1081        len = strbuf_read(&buf, cp.out, 1024);
1082        line = buf.buf;
1083        while (len > 2) {
1084                if ((line[0] == '?') && (line[1] == '?')) {
1085                        dirty_submodule |= DIRTY_SUBMODULE_UNTRACKED;
1086                        if (dirty_submodule & DIRTY_SUBMODULE_MODIFIED)
1087                                break;
1088                } else {
1089                        dirty_submodule |= DIRTY_SUBMODULE_MODIFIED;
1090                        if (ignore_untracked ||
1091                            (dirty_submodule & DIRTY_SUBMODULE_UNTRACKED))
1092                                break;
1093                }
1094                next_line = strchr(line, '\n');
1095                if (!next_line)
1096                        break;
1097                next_line++;
1098                len -= (next_line - line);
1099                line = next_line;
1100        }
1101        close(cp.out);
1102
1103        if (finish_command(&cp))
1104                die("'git status --porcelain' failed in submodule %s", path);
1105
1106        strbuf_release(&buf);
1107        return dirty_submodule;
1108}
1109
1110int submodule_uses_gitfile(const char *path)
1111{
1112        struct child_process cp = CHILD_PROCESS_INIT;
1113        const char *argv[] = {
1114                "submodule",
1115                "foreach",
1116                "--quiet",
1117                "--recursive",
1118                "test -f .git",
1119                NULL,
1120        };
1121        struct strbuf buf = STRBUF_INIT;
1122        const char *git_dir;
1123
1124        strbuf_addf(&buf, "%s/.git", path);
1125        git_dir = read_gitfile(buf.buf);
1126        if (!git_dir) {
1127                strbuf_release(&buf);
1128                return 0;
1129        }
1130        strbuf_release(&buf);
1131
1132        /* Now test that all nested submodules use a gitfile too */
1133        cp.argv = argv;
1134        prepare_submodule_repo_env(&cp.env_array);
1135        cp.git_cmd = 1;
1136        cp.no_stdin = 1;
1137        cp.no_stderr = 1;
1138        cp.no_stdout = 1;
1139        cp.dir = path;
1140        if (run_command(&cp))
1141                return 0;
1142
1143        return 1;
1144}
1145
1146/*
1147 * Check if it is a bad idea to remove a submodule, i.e. if we'd lose data
1148 * when doing so.
1149 *
1150 * Return 1 if we'd lose data, return 0 if the removal is fine,
1151 * and negative values for errors.
1152 */
1153int bad_to_remove_submodule(const char *path, unsigned flags)
1154{
1155        ssize_t len;
1156        struct child_process cp = CHILD_PROCESS_INIT;
1157        struct strbuf buf = STRBUF_INIT;
1158        int ret = 0;
1159
1160        if (!file_exists(path) || is_empty_dir(path))
1161                return 0;
1162
1163        if (!submodule_uses_gitfile(path))
1164                return 1;
1165
1166        argv_array_pushl(&cp.args, "status", "--porcelain",
1167                                   "--ignore-submodules=none", NULL);
1168
1169        if (flags & SUBMODULE_REMOVAL_IGNORE_UNTRACKED)
1170                argv_array_push(&cp.args, "-uno");
1171        else
1172                argv_array_push(&cp.args, "-uall");
1173
1174        if (!(flags & SUBMODULE_REMOVAL_IGNORE_IGNORED_UNTRACKED))
1175                argv_array_push(&cp.args, "--ignored");
1176
1177        prepare_submodule_repo_env(&cp.env_array);
1178        cp.git_cmd = 1;
1179        cp.no_stdin = 1;
1180        cp.out = -1;
1181        cp.dir = path;
1182        if (start_command(&cp)) {
1183                if (flags & SUBMODULE_REMOVAL_DIE_ON_ERROR)
1184                        die(_("could not start 'git status in submodule '%s'"),
1185                                path);
1186                ret = -1;
1187                goto out;
1188        }
1189
1190        len = strbuf_read(&buf, cp.out, 1024);
1191        if (len > 2)
1192                ret = 1;
1193        close(cp.out);
1194
1195        if (finish_command(&cp)) {
1196                if (flags & SUBMODULE_REMOVAL_DIE_ON_ERROR)
1197                        die(_("could not run 'git status in submodule '%s'"),
1198                                path);
1199                ret = -1;
1200        }
1201out:
1202        strbuf_release(&buf);
1203        return ret;
1204}
1205
1206static int find_first_merges(struct object_array *result, const char *path,
1207                struct commit *a, struct commit *b)
1208{
1209        int i, j;
1210        struct object_array merges = OBJECT_ARRAY_INIT;
1211        struct commit *commit;
1212        int contains_another;
1213
1214        char merged_revision[42];
1215        const char *rev_args[] = { "rev-list", "--merges", "--ancestry-path",
1216                                   "--all", merged_revision, NULL };
1217        struct rev_info revs;
1218        struct setup_revision_opt rev_opts;
1219
1220        memset(result, 0, sizeof(struct object_array));
1221        memset(&rev_opts, 0, sizeof(rev_opts));
1222
1223        /* get all revisions that merge commit a */
1224        snprintf(merged_revision, sizeof(merged_revision), "^%s",
1225                        oid_to_hex(&a->object.oid));
1226        init_revisions(&revs, NULL);
1227        rev_opts.submodule = path;
1228        setup_revisions(ARRAY_SIZE(rev_args)-1, rev_args, &revs, &rev_opts);
1229
1230        /* save all revisions from the above list that contain b */
1231        if (prepare_revision_walk(&revs))
1232                die("revision walk setup failed");
1233        while ((commit = get_revision(&revs)) != NULL) {
1234                struct object *o = &(commit->object);
1235                if (in_merge_bases(b, commit))
1236                        add_object_array(o, NULL, &merges);
1237        }
1238        reset_revision_walk();
1239
1240        /* Now we've got all merges that contain a and b. Prune all
1241         * merges that contain another found merge and save them in
1242         * result.
1243         */
1244        for (i = 0; i < merges.nr; i++) {
1245                struct commit *m1 = (struct commit *) merges.objects[i].item;
1246
1247                contains_another = 0;
1248                for (j = 0; j < merges.nr; j++) {
1249                        struct commit *m2 = (struct commit *) merges.objects[j].item;
1250                        if (i != j && in_merge_bases(m2, m1)) {
1251                                contains_another = 1;
1252                                break;
1253                        }
1254                }
1255
1256                if (!contains_another)
1257                        add_object_array(merges.objects[i].item, NULL, result);
1258        }
1259
1260        free(merges.objects);
1261        return result->nr;
1262}
1263
1264static void print_commit(struct commit *commit)
1265{
1266        struct strbuf sb = STRBUF_INIT;
1267        struct pretty_print_context ctx = {0};
1268        ctx.date_mode.type = DATE_NORMAL;
1269        format_commit_message(commit, " %h: %m %s", &sb, &ctx);
1270        fprintf(stderr, "%s\n", sb.buf);
1271        strbuf_release(&sb);
1272}
1273
1274#define MERGE_WARNING(path, msg) \
1275        warning("Failed to merge submodule %s (%s)", path, msg);
1276
1277int merge_submodule(unsigned char result[20], const char *path,
1278                    const unsigned char base[20], const unsigned char a[20],
1279                    const unsigned char b[20], int search)
1280{
1281        struct commit *commit_base, *commit_a, *commit_b;
1282        int parent_count;
1283        struct object_array merges;
1284
1285        int i;
1286
1287        /* store a in result in case we fail */
1288        hashcpy(result, a);
1289
1290        /* we can not handle deletion conflicts */
1291        if (is_null_sha1(base))
1292                return 0;
1293        if (is_null_sha1(a))
1294                return 0;
1295        if (is_null_sha1(b))
1296                return 0;
1297
1298        if (add_submodule_odb(path)) {
1299                MERGE_WARNING(path, "not checked out");
1300                return 0;
1301        }
1302
1303        if (!(commit_base = lookup_commit_reference(base)) ||
1304            !(commit_a = lookup_commit_reference(a)) ||
1305            !(commit_b = lookup_commit_reference(b))) {
1306                MERGE_WARNING(path, "commits not present");
1307                return 0;
1308        }
1309
1310        /* check whether both changes are forward */
1311        if (!in_merge_bases(commit_base, commit_a) ||
1312            !in_merge_bases(commit_base, commit_b)) {
1313                MERGE_WARNING(path, "commits don't follow merge-base");
1314                return 0;
1315        }
1316
1317        /* Case #1: a is contained in b or vice versa */
1318        if (in_merge_bases(commit_a, commit_b)) {
1319                hashcpy(result, b);
1320                return 1;
1321        }
1322        if (in_merge_bases(commit_b, commit_a)) {
1323                hashcpy(result, a);
1324                return 1;
1325        }
1326
1327        /*
1328         * Case #2: There are one or more merges that contain a and b in
1329         * the submodule. If there is only one, then present it as a
1330         * suggestion to the user, but leave it marked unmerged so the
1331         * user needs to confirm the resolution.
1332         */
1333
1334        /* Skip the search if makes no sense to the calling context.  */
1335        if (!search)
1336                return 0;
1337
1338        /* find commit which merges them */
1339        parent_count = find_first_merges(&merges, path, commit_a, commit_b);
1340        switch (parent_count) {
1341        case 0:
1342                MERGE_WARNING(path, "merge following commits not found");
1343                break;
1344
1345        case 1:
1346                MERGE_WARNING(path, "not fast-forward");
1347                fprintf(stderr, "Found a possible merge resolution "
1348                                "for the submodule:\n");
1349                print_commit((struct commit *) merges.objects[0].item);
1350                fprintf(stderr,
1351                        "If this is correct simply add it to the index "
1352                        "for example\n"
1353                        "by using:\n\n"
1354                        "  git update-index --cacheinfo 160000 %s \"%s\"\n\n"
1355                        "which will accept this suggestion.\n",
1356                        oid_to_hex(&merges.objects[0].item->oid), path);
1357                break;
1358
1359        default:
1360                MERGE_WARNING(path, "multiple merges found");
1361                for (i = 0; i < merges.nr; i++)
1362                        print_commit((struct commit *) merges.objects[i].item);
1363        }
1364
1365        free(merges.objects);
1366        return 0;
1367}
1368
1369int parallel_submodules(void)
1370{
1371        return parallel_jobs;
1372}
1373
1374void prepare_submodule_repo_env(struct argv_array *out)
1375{
1376        const char * const *var;
1377
1378        for (var = local_repo_env; *var; var++) {
1379                if (strcmp(*var, CONFIG_DATA_ENVIRONMENT))
1380                        argv_array_push(out, *var);
1381        }
1382        argv_array_pushf(out, "%s=%s", GIT_DIR_ENVIRONMENT,
1383                         DEFAULT_GIT_DIR_ENVIRONMENT);
1384}
1385
1386/*
1387 * Embeds a single submodules git directory into the superprojects git dir,
1388 * non recursively.
1389 */
1390static void relocate_single_git_dir_into_superproject(const char *prefix,
1391                                                      const char *path)
1392{
1393        char *old_git_dir = NULL, *real_old_git_dir = NULL, *real_new_git_dir = NULL;
1394        const char *new_git_dir;
1395        const struct submodule *sub;
1396
1397        if (submodule_uses_worktrees(path))
1398                die(_("relocate_gitdir for submodule '%s' with "
1399                      "more than one worktree not supported"), path);
1400
1401        old_git_dir = xstrfmt("%s/.git", path);
1402        if (read_gitfile(old_git_dir))
1403                /* If it is an actual gitfile, it doesn't need migration. */
1404                return;
1405
1406        real_old_git_dir = real_pathdup(old_git_dir, 1);
1407
1408        sub = submodule_from_path(null_sha1, path);
1409        if (!sub)
1410                die(_("could not lookup name for submodule '%s'"), path);
1411
1412        new_git_dir = git_path("modules/%s", sub->name);
1413        if (safe_create_leading_directories_const(new_git_dir) < 0)
1414                die(_("could not create directory '%s'"), new_git_dir);
1415        real_new_git_dir = real_pathdup(new_git_dir, 1);
1416
1417        if (!prefix)
1418                prefix = get_super_prefix();
1419
1420        fprintf(stderr, _("Migrating git directory of '%s%s' from\n'%s' to\n'%s'\n"),
1421                prefix ? prefix : "", path,
1422                real_old_git_dir, real_new_git_dir);
1423
1424        relocate_gitdir(path, real_old_git_dir, real_new_git_dir);
1425
1426        free(old_git_dir);
1427        free(real_old_git_dir);
1428        free(real_new_git_dir);
1429}
1430
1431/*
1432 * Migrate the git directory of the submodule given by path from
1433 * having its git directory within the working tree to the git dir nested
1434 * in its superprojects git dir under modules/.
1435 */
1436void absorb_git_dir_into_superproject(const char *prefix,
1437                                      const char *path,
1438                                      unsigned flags)
1439{
1440        int err_code;
1441        const char *sub_git_dir;
1442        struct strbuf gitdir = STRBUF_INIT;
1443        strbuf_addf(&gitdir, "%s/.git", path);
1444        sub_git_dir = resolve_gitdir_gently(gitdir.buf, &err_code);
1445
1446        /* Not populated? */
1447        if (!sub_git_dir) {
1448                char *real_new_git_dir;
1449                const char *new_git_dir;
1450                const struct submodule *sub;
1451
1452                if (err_code == READ_GITFILE_ERR_STAT_FAILED) {
1453                        /* unpopulated as expected */
1454                        strbuf_release(&gitdir);
1455                        return;
1456                }
1457
1458                if (err_code != READ_GITFILE_ERR_NOT_A_REPO)
1459                        /* We don't know what broke here. */
1460                        read_gitfile_error_die(err_code, path, NULL);
1461
1462                /*
1463                * Maybe populated, but no git directory was found?
1464                * This can happen if the superproject is a submodule
1465                * itself and was just absorbed. The absorption of the
1466                * superproject did not rewrite the git file links yet,
1467                * fix it now.
1468                */
1469                sub = submodule_from_path(null_sha1, path);
1470                if (!sub)
1471                        die(_("could not lookup name for submodule '%s'"), path);
1472                new_git_dir = git_path("modules/%s", sub->name);
1473                if (safe_create_leading_directories_const(new_git_dir) < 0)
1474                        die(_("could not create directory '%s'"), new_git_dir);
1475                real_new_git_dir = real_pathdup(new_git_dir, 1);
1476                connect_work_tree_and_git_dir(path, real_new_git_dir);
1477
1478                free(real_new_git_dir);
1479        } else {
1480                /* Is it already absorbed into the superprojects git dir? */
1481                char *real_sub_git_dir = real_pathdup(sub_git_dir, 1);
1482                char *real_common_git_dir = real_pathdup(get_git_common_dir(), 1);
1483
1484                if (!starts_with(real_sub_git_dir, real_common_git_dir))
1485                        relocate_single_git_dir_into_superproject(prefix, path);
1486
1487                free(real_sub_git_dir);
1488                free(real_common_git_dir);
1489        }
1490        strbuf_release(&gitdir);
1491
1492        if (flags & ABSORB_GITDIR_RECURSE_SUBMODULES) {
1493                struct child_process cp = CHILD_PROCESS_INIT;
1494                struct strbuf sb = STRBUF_INIT;
1495
1496                if (flags & ~ABSORB_GITDIR_RECURSE_SUBMODULES)
1497                        die("BUG: we don't know how to pass the flags down?");
1498
1499                if (get_super_prefix())
1500                        strbuf_addstr(&sb, get_super_prefix());
1501                strbuf_addstr(&sb, path);
1502                strbuf_addch(&sb, '/');
1503
1504                cp.dir = path;
1505                cp.git_cmd = 1;
1506                cp.no_stdin = 1;
1507                argv_array_pushl(&cp.args, "--super-prefix", sb.buf,
1508                                           "submodule--helper",
1509                                           "absorb-git-dirs", NULL);
1510                prepare_submodule_repo_env(&cp.env_array);
1511                if (run_command(&cp))
1512                        die(_("could not recurse into submodule '%s'"), path);
1513
1514                strbuf_release(&sb);
1515        }
1516}
1517
1518const char *get_superproject_working_tree(void)
1519{
1520        struct child_process cp = CHILD_PROCESS_INIT;
1521        struct strbuf sb = STRBUF_INIT;
1522        const char *one_up = real_path_if_valid("../");
1523        const char *cwd = xgetcwd();
1524        const char *ret = NULL;
1525        const char *subpath;
1526        int code;
1527        ssize_t len;
1528
1529        if (!is_inside_work_tree())
1530                /*
1531                 * FIXME:
1532                 * We might have a superproject, but it is harder
1533                 * to determine.
1534                 */
1535                return NULL;
1536
1537        if (!one_up)
1538                return NULL;
1539
1540        subpath = relative_path(cwd, one_up, &sb);
1541
1542        prepare_submodule_repo_env(&cp.env_array);
1543        argv_array_pop(&cp.env_array);
1544
1545        argv_array_pushl(&cp.args, "--literal-pathspecs", "-C", "..",
1546                        "ls-files", "-z", "--stage", "--full-name", "--",
1547                        subpath, NULL);
1548        strbuf_reset(&sb);
1549
1550        cp.no_stdin = 1;
1551        cp.no_stderr = 1;
1552        cp.out = -1;
1553        cp.git_cmd = 1;
1554
1555        if (start_command(&cp))
1556                die(_("could not start ls-files in .."));
1557
1558        len = strbuf_read(&sb, cp.out, PATH_MAX);
1559        close(cp.out);
1560
1561        if (starts_with(sb.buf, "160000")) {
1562                int super_sub_len;
1563                int cwd_len = strlen(cwd);
1564                char *super_sub, *super_wt;
1565
1566                /*
1567                 * There is a superproject having this repo as a submodule.
1568                 * The format is <mode> SP <hash> SP <stage> TAB <full name> \0,
1569                 * We're only interested in the name after the tab.
1570                 */
1571                super_sub = strchr(sb.buf, '\t') + 1;
1572                super_sub_len = sb.buf + sb.len - super_sub - 1;
1573
1574                if (super_sub_len > cwd_len ||
1575                    strcmp(&cwd[cwd_len - super_sub_len], super_sub))
1576                        die (_("BUG: returned path string doesn't match cwd?"));
1577
1578                super_wt = xstrdup(cwd);
1579                super_wt[cwd_len - super_sub_len] = '\0';
1580
1581                ret = real_path(super_wt);
1582                free(super_wt);
1583        }
1584        strbuf_release(&sb);
1585
1586        code = finish_command(&cp);
1587
1588        if (code == 128)
1589                /* '../' is not a git repository */
1590                return NULL;
1591        if (code == 0 && len == 0)
1592                /* There is an unrelated git repository at '../' */
1593                return NULL;
1594        if (code)
1595                die(_("ls-tree returned unexpected return code %d"), code);
1596
1597        return ret;
1598}