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