void test_refs_branches_move__can_not_move_a_branch_if_its_destination_name_collide_with_an_existing_one(void) { git_reference *original_ref, *new_ref; git_config *config; git_buf buf = GIT_BUF_INIT; char *original_remote, *original_merge; const char *str; cl_git_pass(git_repository_config_snapshot(&config, repo)); cl_git_pass(git_config_get_string_buf(&buf, config, "branch.master.remote")); original_remote = git_buf_detach(&buf); cl_git_pass(git_config_get_string_buf(&buf, config, "branch.master.merge")); original_merge = git_buf_detach(&buf); git_config_free(config); cl_git_pass(git_reference_lookup(&original_ref, repo, "refs/heads/br2")); cl_assert_equal_i(GIT_EEXISTS, git_branch_move(&new_ref, original_ref, "master", 0)); cl_assert(giterr_last()->message != NULL); cl_git_pass(git_repository_config_snapshot(&config, repo)); cl_git_pass(git_config_get_string(&str, config, "branch.master.remote")); cl_assert_equal_s(original_remote, str); cl_git_pass(git_config_get_string(&str, config, "branch.master.merge")); cl_assert_equal_s(original_merge, str); git_config_free(config); cl_assert_equal_i(GIT_EEXISTS, git_branch_move(&new_ref, original_ref, "cannot-fetch", 0)); cl_assert(giterr_last()->message != NULL); cl_git_pass(git_repository_config_snapshot(&config, repo)); cl_git_pass(git_config_get_string(&str, config, "branch.master.remote")); cl_assert_equal_s(original_remote, str); cl_git_pass(git_config_get_string(&str, config, "branch.master.merge")); cl_assert_equal_s(original_merge, str); git_config_free(config); git_reference_free(original_ref); cl_git_pass(git_reference_lookup(&original_ref, repo, "refs/heads/track-local")); cl_assert_equal_i(GIT_EEXISTS, git_branch_move(&new_ref, original_ref, "master", 0)); cl_assert(giterr_last()->message != NULL); cl_git_pass(git_repository_config_snapshot(&config, repo)); cl_git_pass(git_config_get_string(&str, config, "branch.master.remote")); cl_assert_equal_s(original_remote, str); cl_git_pass(git_config_get_string(&str, config, "branch.master.merge")); cl_assert_equal_s(original_merge, str); git__free(original_remote); git__free(original_merge); git_reference_free(original_ref); git_config_free(config); }
void test_config_write__value_containing_quotes(void) { git_config *cfg; git_buf buf = GIT_BUF_INIT; cl_git_pass(git_config_open_ondisk(&cfg, "config9")); cl_git_pass(git_config_set_string(cfg, "core.somevar", "this \"has\" quotes")); cl_git_pass(git_config_get_string_buf(&buf, cfg, "core.somevar")); cl_assert_equal_s("this \"has\" quotes", git_buf_cstr(&buf)); git_buf_clear(&buf); git_config_free(cfg); cl_git_pass(git_config_open_ondisk(&cfg, "config9")); cl_git_pass(git_config_get_string_buf(&buf, cfg, "core.somevar")); cl_assert_equal_s("this \"has\" quotes", git_buf_cstr(&buf)); git_buf_clear(&buf); git_config_free(cfg); /* The code path for values that already exist is different, check that one as well */ cl_git_pass(git_config_open_ondisk(&cfg, "config9")); cl_git_pass(git_config_set_string(cfg, "core.somevar", "this also \"has\" quotes")); cl_git_pass(git_config_get_string_buf(&buf, cfg, "core.somevar")); cl_assert_equal_s("this also \"has\" quotes", git_buf_cstr(&buf)); git_buf_clear(&buf); git_config_free(cfg); cl_git_pass(git_config_open_ondisk(&cfg, "config9")); cl_git_pass(git_config_get_string_buf(&buf, cfg, "core.somevar")); cl_assert_equal_s("this also \"has\" quotes", git_buf_cstr(&buf)); git_buf_free(&buf); git_config_free(cfg); }
void test_config_read__single_line(void) { git_buf buf = GIT_BUF_INIT; git_config *cfg; cl_set_cleanup(&clean_test_config, NULL); cl_git_mkfile("./testconfig", "[some] var = value\n[some \"OtheR\"] var = value"); cl_git_pass(git_config_open_ondisk(&cfg, "./testconfig")); cl_git_pass(git_config_get_string_buf(&buf, cfg, "some.var")); cl_assert_equal_s(buf.ptr, "value"); git_buf_clear(&buf); cl_git_pass(git_config_get_string_buf(&buf, cfg, "some.OtheR.var")); cl_assert_equal_s(buf.ptr, "value"); git_config_free(cfg); cl_git_mkfile("./testconfig", "[some] var = value\n[some \"OtheR\"]var = value"); cl_git_pass(git_config_open_ondisk(&cfg, "./testconfig")); git_buf_clear(&buf); cl_git_pass(git_config_get_string_buf(&buf, cfg, "some.var")); cl_assert_equal_s(buf.ptr, "value"); git_buf_clear(&buf); cl_git_pass(git_config_get_string_buf(&buf, cfg, "some.OtheR.var")); cl_assert_equal_s(buf.ptr, "value"); git_config_free(cfg); git_buf_dispose(&buf); }
void test_config_new__write_new_config(void) { git_config *config; git_buf buf = GIT_BUF_INIT; cl_git_mkfile(TEST_CONFIG, ""); cl_git_pass(git_config_open_ondisk(&config, TEST_CONFIG)); cl_git_pass(git_config_set_string(config, "color.ui", "auto")); cl_git_pass(git_config_set_string(config, "core.editor", "ed")); git_config_free(config); cl_git_pass(git_config_open_ondisk(&config, TEST_CONFIG)); cl_git_pass(git_config_get_string_buf(&buf, config, "color.ui")); cl_assert_equal_s("auto", git_buf_cstr(&buf)); git_buf_clear(&buf); cl_git_pass(git_config_get_string_buf(&buf, config, "core.editor")); cl_assert_equal_s("ed", git_buf_cstr(&buf)); git_buf_free(&buf); git_config_free(config); p_unlink(TEST_CONFIG); }
void test_config_read__prefixes(void) { git_config *cfg; cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config9"))); cl_git_pass(git_config_get_string_buf(&buf, cfg, "remote.ab.url")); cl_assert_equal_s("http://example.com/git/ab", git_buf_cstr(&buf)); git_buf_clear(&buf); cl_git_pass(git_config_get_string_buf(&buf, cfg, "remote.abba.url")); cl_assert_equal_s("http://example.com/git/abba", git_buf_cstr(&buf)); git_config_free(cfg); }
/* * This kind of subsection declaration is case-insensitive */ void test_config_read__subsection_header(void) { git_config *cfg; cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config3"))); cl_git_pass(git_config_get_string_buf(&buf, cfg, "section.subsection.var")); cl_assert_equal_s("hello", git_buf_cstr(&buf)); /* The subsection is transformed to lower-case */ cl_must_fail(git_config_get_string_buf(&buf, cfg, "section.subSectIon.var")); git_config_free(cfg); }
void test_config_read__whitespace_not_required_around_assignment(void) { git_config *cfg; cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config14"))); cl_git_pass(git_config_get_string_buf(&buf, cfg, "a.b")); cl_assert_equal_s("c", git_buf_cstr(&buf)); git_buf_clear(&buf); cl_git_pass(git_config_get_string_buf(&buf, cfg, "d.e")); cl_assert_equal_s("f", git_buf_cstr(&buf)); git_config_free(cfg); }
static int notes_ref_lookup(git_buf *out, git_rebase *rebase) { git_config *config = NULL; int do_rewrite, error; if (rebase->options.rewrite_notes_ref) { git_buf_attach_notowned(out, rebase->options.rewrite_notes_ref, strlen(rebase->options.rewrite_notes_ref)); return 0; } if ((error = git_repository_config(&config, rebase->repo)) < 0 || (error = git_config_get_bool(&do_rewrite, config, "notes.rewrite.rebase")) < 0) { if (error != GIT_ENOTFOUND) goto done; giterr_clear(); do_rewrite = 1; } error = do_rewrite ? git_config_get_string_buf(out, config, "notes.rewriteref") : GIT_ENOTFOUND; done: git_config_free(config); return error; }
/* * At the beginning of the test, config18 has: * int32global = 28 * int64global = 9223372036854775803 * boolglobal = true * stringglobal = I'm a global config value! * * And config19 has: * int32global = -1 * int64global = -2 * boolglobal = false * stringglobal = don't find me! * */ void test_config_read__simple_read_from_specific_level(void) { git_config *cfg, *cfg_specific; int i; int64_t l, expected = +9223372036854775803; cl_git_pass(git_config_new(&cfg)); cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config18"), GIT_CONFIG_LEVEL_GLOBAL, NULL, 0)); cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config19"), GIT_CONFIG_LEVEL_SYSTEM, NULL, 0)); cl_git_pass(git_config_open_level(&cfg_specific, cfg, GIT_CONFIG_LEVEL_GLOBAL)); cl_git_pass(git_config_get_int32(&i, cfg_specific, "core.int32global")); cl_assert_equal_i(28, i); cl_git_pass(git_config_get_int64(&l, cfg_specific, "core.int64global")); cl_assert(l == expected); cl_git_pass(git_config_get_bool(&i, cfg_specific, "core.boolglobal")); cl_assert_equal_b(true, i); cl_git_pass(git_config_get_string_buf(&buf, cfg_specific, "core.stringglobal")); cl_assert_equal_s("I'm a global config value!", git_buf_cstr(&buf)); git_config_free(cfg_specific); git_config_free(cfg); }
void test_config_write__escape_value(void) { git_config *cfg; git_buf buf = GIT_BUF_INIT; cl_git_pass(git_config_open_ondisk(&cfg, "config9")); cl_git_pass(git_config_set_string(cfg, "core.somevar", "this \"has\" quotes and \t")); cl_git_pass(git_config_get_string_buf(&buf, cfg, "core.somevar")); cl_assert_equal_s("this \"has\" quotes and \t", git_buf_cstr(&buf)); git_buf_clear(&buf); git_config_free(cfg); cl_git_pass(git_config_open_ondisk(&cfg, "config9")); cl_git_pass(git_config_get_string_buf(&buf, cfg, "core.somevar")); cl_assert_equal_s("this \"has\" quotes and \t", git_buf_cstr(&buf)); git_buf_free(&buf); git_config_free(cfg); }
void test_config_read__escaping_quotes(void) { git_config *cfg; cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config13"))); cl_git_pass(git_config_get_string_buf(&buf, cfg, "core.editor")); cl_assert_equal_s("\"C:/Program Files/Nonsense/bah.exe\" \"--some option\"", git_buf_cstr(&buf)); git_config_free(cfg); }
/* * If \ is the last non-space character on the line, we read the next * one, separating each line with SP. */ void test_config_read__multiline_value(void) { git_config *cfg; cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config2"))); cl_git_pass(git_config_get_string_buf(&buf, cfg, "this.That.and")); cl_assert_equal_s("one one one two two three three", git_buf_cstr(&buf)); git_config_free(cfg); }
void test_config_global__open_programdata(void) { git_config *cfg; git_repository *repo; git_buf config_path = GIT_BUF_INIT; git_buf var_contents = GIT_BUF_INIT; if (cl_is_env_set("GITTEST_INVASIVE_FS_STRUCTURE")) cl_skip(); cl_git_pass(git_libgit2_opts(GIT_OPT_GET_SEARCH_PATH, GIT_CONFIG_LEVEL_PROGRAMDATA, &config_path)); if (!git_path_isdir(config_path.ptr)) cl_git_pass(p_mkdir(config_path.ptr, 0777)); cl_git_pass(git_buf_puts(&config_path, "/config")); cl_git_pass(git_config_open_ondisk(&cfg, config_path.ptr)); cl_git_pass(git_config_set_string(cfg, "programdata.var", "even higher level")); git_buf_free(&config_path); git_config_free(cfg); git_config_open_default(&cfg); cl_git_pass(git_config_get_string_buf(&var_contents, cfg, "programdata.var")); cl_assert_equal_s("even higher level", var_contents.ptr); git_config_free(cfg); git_buf_free(&var_contents); cl_git_pass(git_repository_init(&repo, "./foo.git", true)); cl_git_pass(git_repository_config(&cfg, repo)); cl_git_pass(git_config_get_string_buf(&var_contents, cfg, "programdata.var")); cl_assert_equal_s("even higher level", var_contents.ptr); git_config_free(cfg); git_buf_free(&var_contents); git_repository_free(repo); cl_fixture_cleanup("./foo.git"); }
void test_config_read__multiline_eof(void) { git_config *cfg; cl_set_cleanup(&clean_test_config, NULL); cl_git_mkfile("./testconfig", "[header]\n key1 = \\\n"); cl_git_pass(git_config_open_ondisk(&cfg, "./testconfig")); cl_git_pass(git_config_get_string_buf(&buf, cfg, "header.key1")); cl_assert_equal_s("", git_buf_cstr(&buf)); git_config_free(cfg); }
void test_config_read__override_variable(void) { git_config *cfg; cl_set_cleanup(&clean_test_config, NULL); cl_git_mkfile("./testconfig", "[some] var = one\nvar = two"); cl_git_pass(git_config_open_ondisk(&cfg, "./testconfig")); cl_git_pass(git_config_get_string_buf(&buf, cfg, "some.var")); cl_assert_equal_s("two", git_buf_cstr(&buf)); git_config_free(cfg); }
void test_config_read__crlf_style_line_endings(void) { git_buf buf = GIT_BUF_INIT; git_config *cfg; cl_set_cleanup(&clean_test_config, NULL); cl_git_mkfile("./testconfig", "[some]\r\n var = value\r\n"); cl_git_pass(git_config_open_ondisk(&cfg, "./testconfig")); cl_git_pass(git_config_get_string_buf(&buf, cfg, "some.var")); cl_assert_equal_s(buf.ptr, "value"); git_config_free(cfg); git_buf_free(&buf); }
void test_config_read__bom(void) { git_buf buf = GIT_BUF_INIT; git_config *cfg; cl_set_cleanup(&clean_test_config, NULL); cl_git_mkfile("./testconfig", "\xEF\xBB\xBF[some]\n var = value\n"); cl_git_pass(git_config_open_ondisk(&cfg, "./testconfig")); cl_git_pass(git_config_get_string_buf(&buf, cfg, "some.var")); cl_assert_equal_s(buf.ptr, "value"); git_config_free(cfg); git_buf_dispose(&buf); }
void test_config_read__lone_variable(void) { git_config *cfg; int i; cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config4"))); cl_git_fail(git_config_get_int32(&i, cfg, "some.section.variable")); cl_git_pass(git_config_get_string_buf(&buf, cfg, "some.section.variable")); cl_assert_equal_s("", git_buf_cstr(&buf)); git_buf_clear(&buf); cl_git_pass(git_config_get_bool(&i, cfg, "some.section.variable")); cl_assert(i == 1); cl_git_pass(git_config_get_string_buf(&buf, cfg, "some.section.variableeq")); cl_assert_equal_s("", git_buf_cstr(&buf)); cl_git_pass(git_config_get_bool(&i, cfg, "some.section.variableeq")); cl_assert(i == 0); git_config_free(cfg); }
void test_config_read__case_sensitive(void) { git_config *cfg; int i; cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config1"))); cl_git_pass(git_config_get_string_buf(&buf, cfg, "this.that.other")); cl_assert_equal_s("true", git_buf_cstr(&buf)); git_buf_clear(&buf); cl_git_pass(git_config_get_string_buf(&buf, cfg, "this.That.other")); cl_assert_equal_s("yes", git_buf_cstr(&buf)); cl_git_pass(git_config_get_bool(&i, cfg, "this.that.other")); cl_assert(i == 1); cl_git_pass(git_config_get_bool(&i, cfg, "this.That.other")); cl_assert(i == 1); /* This one doesn't exist */ cl_must_fail(git_config_get_bool(&i, cfg, "this.thaT.other")); git_config_free(cfg); }
void test_config_write__write_subsection(void) { git_config *cfg; git_buf buf = GIT_BUF_INIT; cl_git_pass(git_config_open_ondisk(&cfg, "config9")); cl_git_pass(git_config_set_string(cfg, "my.own.var", "works")); git_config_free(cfg); cl_git_pass(git_config_open_ondisk(&cfg, "config9")); cl_git_pass(git_config_get_string_buf(&buf, cfg, "my.own.var")); cl_assert_equal_s("works", git_buf_cstr(&buf)); git_buf_free(&buf); git_config_free(cfg); }
static int retrieve_upstream_configuration( git_buf *out, const git_config *config, const char *canonical_branch_name, const char *format) { git_buf buf = GIT_BUF_INIT; int error; if (git_buf_printf(&buf, format, canonical_branch_name + strlen(GIT_REFS_HEADS_DIR)) < 0) return -1; error = git_config_get_string_buf(out, config, git_buf_cstr(&buf)); git_buf_free(&buf); return error; }
void test_config_configlevel__can_replace_a_config_file_at_an_existing_level(void) { git_config *cfg; git_buf buf = {0}; cl_git_pass(git_config_new(&cfg)); cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config18"), GIT_CONFIG_LEVEL_LOCAL, 1)); cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config19"), GIT_CONFIG_LEVEL_LOCAL, 1)); cl_git_pass(git_config_get_string_buf(&buf, cfg, "core.stringglobal")); cl_assert_equal_s("don't find me!", buf.ptr); git_buf_free(&buf); git_config_free(cfg); }
void test_config_write__can_set_an_empty_value(void) { git_repository *repository; git_config *config; git_buf buf = {0}; repository = cl_git_sandbox_init("testrepo.git"); cl_git_pass(git_repository_config(&config, repository)); cl_git_pass(git_config_set_string(config, "core.somevar", "")); cl_git_pass(git_config_get_string_buf(&buf, config, "core.somevar")); cl_assert_equal_s("", buf.ptr); git_buf_free(&buf); git_config_free(config); cl_git_sandbox_cleanup(); }
void test_config_configlevel__can_read_from_a_single_level_focused_file_after_parent_config_has_been_freed(void) { git_config *cfg; git_config *single_level_cfg; git_buf buf = {0}; cl_git_pass(git_config_new(&cfg)); cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config18"), GIT_CONFIG_LEVEL_GLOBAL, 0)); cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config19"), GIT_CONFIG_LEVEL_LOCAL, 0)); cl_git_pass(git_config_open_level(&single_level_cfg, cfg, GIT_CONFIG_LEVEL_LOCAL)); git_config_free(cfg); cl_git_pass(git_config_get_string_buf(&buf, single_level_cfg, "core.stringglobal")); cl_assert_equal_s("don't find me!", buf.ptr); git_buf_free(&buf); git_config_free(single_level_cfg); }
void test_config_global__open_xdg(void) { git_config *cfg, *xdg, *selected; const char *str = "teststring"; const char *key = "this.variable"; git_buf buf = {0}; cl_git_mkfile("xdg/git/config", "# XDG config\n[core]\n test = 1\n"); cl_git_pass(git_config_open_default(&cfg)); cl_git_pass(git_config_open_level(&xdg, cfg, GIT_CONFIG_LEVEL_XDG)); cl_git_pass(git_config_open_global(&selected, cfg)); cl_git_pass(git_config_set_string(xdg, key, str)); cl_git_pass(git_config_get_string_buf(&buf, selected, key)); cl_assert_equal_s(str, buf.ptr); git_buf_free(&buf); git_config_free(selected); git_config_free(xdg); git_config_free(cfg); }
void test_repo_setters__setting_a_workdir_creates_a_gitlink(void) { git_config *cfg; git_buf buf = GIT_BUF_INIT; git_buf content = GIT_BUF_INIT; cl_git_pass(git_repository_set_workdir(repo, "./new_workdir", true)); cl_assert(git_path_isfile("./new_workdir/.git")); cl_git_pass(git_futils_readbuffer(&content, "./new_workdir/.git")); cl_assert(git__prefixcmp(git_buf_cstr(&content), "gitdir: ") == 0); cl_assert(git__suffixcmp(git_buf_cstr(&content), "testrepo.git/") == 0); git_buf_free(&content); cl_git_pass(git_repository_config(&cfg, repo)); cl_git_pass(git_config_get_string_buf(&buf, cfg, "core.worktree")); cl_assert(git__suffixcmp(git_buf_cstr(&buf), "new_workdir/") == 0); git_buf_free(&buf); git_config_free(cfg); }
void test_config_write__add_value_at_specific_level(void) { git_config *cfg, *cfg_specific; int i; int64_t l, expected = +9223372036854775803; git_buf buf = GIT_BUF_INIT; // open config15 as global level config file cl_git_pass(git_config_new(&cfg)); cl_git_pass(git_config_add_file_ondisk(cfg, "config9", GIT_CONFIG_LEVEL_LOCAL, 0)); cl_git_pass(git_config_add_file_ondisk(cfg, "config15", GIT_CONFIG_LEVEL_GLOBAL, 0)); cl_git_pass(git_config_open_level(&cfg_specific, cfg, GIT_CONFIG_LEVEL_GLOBAL)); cl_git_pass(git_config_set_int32(cfg_specific, "core.int32global", 28)); cl_git_pass(git_config_set_int64(cfg_specific, "core.int64global", expected)); cl_git_pass(git_config_set_bool(cfg_specific, "core.boolglobal", true)); cl_git_pass(git_config_set_string(cfg_specific, "core.stringglobal", "I'm a global config value!")); git_config_free(cfg_specific); git_config_free(cfg); // open config15 as local level config file cl_git_pass(git_config_open_ondisk(&cfg, "config15")); cl_git_pass(git_config_get_int32(&i, cfg, "core.int32global")); cl_assert_equal_i(28, i); cl_git_pass(git_config_get_int64(&l, cfg, "core.int64global")); cl_assert(l == expected); cl_git_pass(git_config_get_bool(&i, cfg, "core.boolglobal")); cl_assert_equal_b(true, i); cl_git_pass(git_config_get_string_buf(&buf, cfg, "core.stringglobal")); cl_assert_equal_s("I'm a global config value!", git_buf_cstr(&buf)); git_buf_free(&buf); git_config_free(cfg); }
/* This would ideally issue a warning, if we had a way to do so. */ void test_config_read__nosection(void) { git_config *cfg; git_buf buf = GIT_BUF_INIT; int seen = 0; cl_git_pass(git_config_open_ondisk(&cfg, cl_fixture("config/config-nosection"))); /* * Given a key with no section, we do not allow reading it, * but we do include it in an iteration over the config * store. This appears to match how git's own APIs (and * git-config(1)) behave. */ cl_git_fail_with(git_config_get_string_buf(&buf, cfg, "key"), GIT_EINVALIDSPEC); cl_git_pass(git_config_foreach(cfg, read_nosection_cb, &seen)); cl_assert_equal_i(seen, 1); git_buf_dispose(&buf); git_config_free(cfg); }
static int filter_apply( git_filter *self, void **payload, /* may be read and/or set */ git_buf *to, const git_buf *from, const git_filter_source *src) { struct filter_filter *ffs = (struct filter_filter *)self; git_config *config; git_buf configKey = GIT_BUF_INIT; int isRequired = FALSE; int error; git_buf cmd = GIT_BUF_INIT; wchar_t *wide_cmd; COMMAND_HANDLE commandHandle; git_buf errBuf = GIT_BUF_INIT; DWORD exitCode; if (!*payload) return GIT_PASSTHROUGH; if (git_repository_config__weakptr(&config, git_filter_source_repo(src))) return -1; git_buf_join3(&configKey, '.', "filter", *payload, "required"); if (git_buf_oom(&configKey)) { giterr_set_oom(); return -1; } error = git_config_get_bool(&isRequired, config, configKey.ptr); git_buf_free(&configKey); if (error && error != GIT_ENOTFOUND) return -1; git_buf_join(&configKey, '.', "filter", *payload); if (git_filter_source_mode(src) == GIT_FILTER_SMUDGE) { git_buf_puts(&configKey, ".smudge"); } else { git_buf_puts(&configKey, ".clean"); } if (git_buf_oom(&configKey)) { giterr_set_oom(); return -1; } error = git_config_get_string_buf(&cmd, config, configKey.ptr); git_buf_free(&configKey); if (error && error != GIT_ENOTFOUND) return -1; if (error == GIT_ENOTFOUND) { if (isRequired) return -1; return GIT_PASSTHROUGH; } if (expandPerCentF(&cmd, git_filter_source_path(src))) return -1; if (ffs->shexepath) { // build params for sh.exe git_buf shParams = GIT_BUF_INIT; git_buf_puts(&shParams, " -c \""); git_buf_text_puts_escaped(&shParams, cmd.ptr, "\"\\", "\\"); git_buf_puts(&shParams, "\""); if (git_buf_oom(&shParams)) { git_buf_free(&cmd); giterr_set_oom(); return -1; } git_buf_swap(&shParams, &cmd); git_buf_free(&shParams); } if (git__utf8_to_16_alloc(&wide_cmd, cmd.ptr) < 0) { git_buf_free(&cmd); giterr_set_oom(); return -1; } git_buf_free(&cmd); if (ffs->shexepath) { // build cmd, i.e. shexepath + params size_t len = wcslen(ffs->shexepath) + wcslen(wide_cmd) + 1; wchar_t *tmp = git__calloc(len, sizeof(wchar_t)); if (!tmp) { git__free(wide_cmd); giterr_set_oom(); return -1; } wcscat_s(tmp, len, ffs->shexepath); wcscat_s(tmp, len, wide_cmd); git__free(wide_cmd); wide_cmd = tmp; } command_init(&commandHandle); commandHandle.errBuf = &errBuf; if (command_start(wide_cmd, &commandHandle, ffs->pEnv, 0)) { git__free(wide_cmd); if (isRequired) return -1; return GIT_PASSTHROUGH; } git__free(wide_cmd); if (commmand_start_stdout_reading_thread(&commandHandle, to)) { command_close(&commandHandle); return -1; } if (command_write_gitbuf(&commandHandle, from)) { DWORD exitCode = command_close(&commandHandle); if (exitCode) setProcessError(exitCode, &errBuf); git_buf_free(&errBuf); if (isRequired) return -1; return GIT_PASSTHROUGH; } command_close_stdin(&commandHandle); if (command_wait_stdout_reading_thread(&commandHandle)) { DWORD exitCode = command_close(&commandHandle); if (exitCode) setProcessError(exitCode, &errBuf); git_buf_free(&errBuf); if (isRequired) return -1; return GIT_PASSTHROUGH; } exitCode = command_close(&commandHandle); if (exitCode) { if (isRequired) { setProcessError(exitCode, &errBuf); git_buf_free(&errBuf); return -1; } git_buf_free(&errBuf); return GIT_PASSTHROUGH; } git_buf_free(&errBuf); return 0; }