BOOL CFirstStartWizardUser::OnInitDialog()
{
CFirstStartWizardBasePage::OnInitDialog();
AdjustControlSize(IDC_DONTSAVE);
CAutoConfig config(true);
if (git_config_add_file_ondisk(config, CGit::GetGitPathStringA(g_Git.GetGitGlobalConfig()), GIT_CONFIG_LEVEL_GLOBAL, nullptr, FALSE))
MessageBox(g_Git.GetLibGit2LastErr(), L"TortoiseGit", MB_ICONEXCLAMATION);
else
{
if (git_config_add_file_ondisk(config, CGit::GetGitPathStringA(g_Git.GetGitGlobalXDGConfig()), GIT_CONFIG_LEVEL_XDG, nullptr, FALSE))
MessageBox(g_Git.GetLibGit2LastErr(), L"TortoiseGit", MB_ICONEXCLAMATION);
}
if (!g_Git.ms_bCygwinGit && !g_Git.ms_bMsys2Git)
{
if (git_config_add_file_ondisk(config, CGit::GetGitPathStringA(g_Git.GetGitProgramDataConfig()), GIT_CONFIG_LEVEL_PROGRAMDATA, nullptr, FALSE))
MessageBox(g_Git.GetLibGit2LastErr(), L"TortoiseGit", MB_ICONEXCLAMATION);
}
if (git_config_add_file_ondisk(config, CGit::GetGitPathStringA(g_Git.GetGitSystemConfig()), GIT_CONFIG_LEVEL_SYSTEM, nullptr, FALSE))
MessageBox(g_Git.GetLibGit2LastErr(), L"TortoiseGit", MB_ICONEXCLAMATION);
config.GetString(L"user.name", m_sUsername);
config.GetString(L"user.email", m_sUseremail);
UpdateData(FALSE);
return TRUE;
}
/*
* 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 CSettingGitCredential::OnBnClickedButtonRemove()
{
int index = m_ctrlUrlList.GetCurSel();
if (index >= 0)
{
CString str;
m_ctrlUrlList.GetText(index, str);
CString msg;
msg.Format(IDS_WARN_REMOVE, (LPCTSTR)str);
if (CMessageBox::Show(GetSafeHwnd(), msg, L"TortoiseGit", MB_YESNO | MB_ICONQUESTION) == IDYES)
{
CAutoConfig config(true);
int pos = str.Find(L':');
CString prefix = pos >= 0 ? str.Left(pos) : str;
CString url = pos >= 0 ? str.Mid(pos + 1) : L"";
CONFIG_TYPE configLevel = CONFIG_LOCAL;
switch (prefix[0])
{
case L'L':
{
configLevel = CONFIG_LOCAL;
git_config_add_file_ondisk(config, CGit::GetGitPathStringA(g_Git.GetGitLocalConfig()), GIT_CONFIG_LEVEL_LOCAL, FALSE);
break;
}
case L'G':
case L'X':
{
configLevel = CONFIG_GLOBAL;
git_config_add_file_ondisk(config, CGit::GetGitPathStringA(g_Git.GetGitGlobalConfig()), GIT_CONFIG_LEVEL_GLOBAL, FALSE);
git_config_add_file_ondisk(config, CGit::GetGitPathStringA(g_Git.GetGitGlobalXDGConfig()), GIT_CONFIG_LEVEL_XDG, FALSE);
break;
}
case L'P':
case L'S':
{
if (!CAppUtils::IsAdminLogin())
{
RunUAC();
EndDialog(0);
return;
}
configLevel = CONFIG_SYSTEM;
git_config_add_file_ondisk(config, CGit::GetGitPathStringA(g_Git.GetGitSystemConfig()), GIT_CONFIG_LEVEL_SYSTEM, FALSE);
if (!g_Git.ms_bCygwinGit && !g_Git.ms_bMsys2Git)
git_config_add_file_ondisk(config, CGit::GetGitPathStringA(g_Git.GetGitProgramDataConfig()), GIT_CONFIG_LEVEL_PROGRAMDATA, FALSE);
break;
}
}
STRING_VECTOR list;
CStringA urlA = CUnicodeUtils::GetUTF8(url);
CStringA pattern = urlA.IsEmpty() ? "^credential\\.[^.]+$" : ("credential\\." + RegexEscape(urlA) + "\\..*");
git_config_foreach_match(config, pattern, GetCredentialEntryCallback, &list);
for (size_t i = 0; i < list.size(); ++i)
g_Git.UnsetConfigValue(list[i], configLevel);
m_ctrlUrlList.DeleteString(index);
OnLbnSelchangeListUrl();
}
}
}
LRESULT CFirstStartWizardUser::OnWizardNext()
{
UpdateData();
if (!m_bNoSave)
{
if (m_sUsername.Trim().IsEmpty() || m_sUseremail.Trim().IsEmpty())
{
MessageBox(L"Username and email must not be empty.", L"TortoiseGit", MB_ICONERROR);
return -1;
}
CAutoConfig config(true);
int err = git_config_add_file_ondisk(config, CGit::GetGitPathStringA(g_Git.GetGitGlobalXDGConfig()), GIT_CONFIG_LEVEL_XDG, nullptr, FALSE);
if (!err && (PathFileExists(g_Git.GetGitGlobalConfig()) || !PathFileExists(g_Git.GetGitGlobalXDGConfig())))
err = git_config_add_file_ondisk(config, CGit::GetGitPathStringA(g_Git.GetGitGlobalConfig()), GIT_CONFIG_LEVEL_GLOBAL, nullptr, FALSE);
if (err)
{
MessageBox(g_Git.GetLibGit2LastErr(), L"TortoiseGit", MB_ICONEXCLAMATION);
return -1;
}
if (git_config_set_string(config, "user.name", CUnicodeUtils::GetUTF8(m_sUsername)))
{
MessageBox(g_Git.GetLibGit2LastErr(), L"TortoiseGit", MB_ICONEXCLAMATION);
return -1;
}
if (git_config_set_string(config, "user.email", CUnicodeUtils::GetUTF8(m_sUseremail)))
{
MessageBox(g_Git.GetLibGit2LastErr(), L"TortoiseGit", MB_ICONEXCLAMATION);
return -1;
}
}
return __super::OnWizardNext();
}
void test_config_read__iterator(void)
{
git_config *cfg;
git_config_iterator *iter;
git_config_entry *entry;
int count, ret;
cl_git_pass(git_config_new(&cfg));
cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config9"),
GIT_CONFIG_LEVEL_SYSTEM, NULL, 0));
cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config15"),
GIT_CONFIG_LEVEL_GLOBAL, NULL, 0));
count = 0;
cl_git_pass(git_config_iterator_new(&iter, cfg));
while ((ret = git_config_next(&entry, iter)) == 0) {
count++;
}
git_config_iterator_free(iter);
cl_assert_equal_i(GIT_ITEROVER, ret);
cl_assert_equal_i(7, count);
count = 3;
cl_git_pass(git_config_iterator_new(&iter, cfg));
git_config_iterator_free(iter);
git_config_free(cfg);
}
/*
* At the beginning of the test:
* - config9 has: core.dummy2=42
* - config15 has: core.dummy2=7
*/
void test_config_write__delete_value_at_specific_level(void)
{
git_config *cfg, *cfg_specific;
int32_t i;
cl_git_pass(git_config_open_ondisk(&cfg, "config15"));
cl_git_pass(git_config_get_int32(&i, cfg, "core.dummy2"));
cl_assert(i == 7);
git_config_free(cfg);
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_delete_entry(cfg_specific, "core.dummy2"));
git_config_free(cfg);
cl_git_pass(git_config_open_ondisk(&cfg, "config15"));
cl_assert(git_config_get_int32(&i, cfg, "core.dummy2") == GIT_ENOTFOUND);
cl_git_pass(git_config_set_int32(cfg, "core.dummy2", 7));
git_config_free(cfg_specific);
git_config_free(cfg);
}
CString CSettingGitCredential::Load(CString key)
{
CString cmd;
if (m_strUrl.IsEmpty())
cmd.Format(_T("credential.%s"), key);
else
cmd.Format(_T("credential.%s.%s"), m_strUrl, key);
CAutoConfig config(true);
int sel = m_ctrlConfigType.GetCurSel();
if (sel == ConfigType::Local)
{
git_config_add_file_ondisk(config, CGit::GetGitPathStringA(g_Git.GetGitLocalConfig()), GIT_CONFIG_LEVEL_LOCAL, FALSE);
}
else if (sel == ConfigType::Global)
{
git_config_add_file_ondisk(config, CGit::GetGitPathStringA(g_Git.GetGitGlobalConfig()), GIT_CONFIG_LEVEL_GLOBAL, FALSE);
git_config_add_file_ondisk(config, CGit::GetGitPathStringA(g_Git.GetGitGlobalXDGConfig()), GIT_CONFIG_LEVEL_XDG, FALSE);
}
else if (sel == ConfigType::System)
{
git_config_add_file_ondisk(config, CGit::GetGitPathStringA(g_Git.GetGitSystemConfig()), GIT_CONFIG_LEVEL_SYSTEM, FALSE);
}
CStringA cmdA = CUnicodeUtils::GetUTF8(cmd);
CStringA valueA;
git_config_entry* entry;
if (!git_config_get_entry(&entry, config, cmdA))
valueA = CStringA(entry->value);
git_config_entry_free(entry);
return CUnicodeUtils::GetUnicode(valueA);
}
/*
* At the beginning of the test:
* - config9 has: core.dummy2=42
* - config15 has: core.dummy2=7
* - config16 has: core.dummy2=28
*/
void test_config_read__local_config_overrides_global_config_overrides_system_config(void)
{
git_config *cfg;
int32_t i;
cl_git_pass(git_config_new(&cfg));
cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config9"),
GIT_CONFIG_LEVEL_SYSTEM, NULL, 0));
cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config15"),
GIT_CONFIG_LEVEL_GLOBAL, NULL, 0));
cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config16"),
GIT_CONFIG_LEVEL_LOCAL, NULL, 0));
cl_git_pass(git_config_get_int32(&i, cfg, "core.dummy2"));
cl_assert_equal_i(28, i);
git_config_free(cfg);
cl_git_pass(git_config_new(&cfg));
cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config9"),
GIT_CONFIG_LEVEL_SYSTEM, NULL, 0));
cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config15"),
GIT_CONFIG_LEVEL_GLOBAL, NULL, 0));
cl_git_pass(git_config_get_int32(&i, cfg, "core.dummy2"));
cl_assert_equal_i(7, i);
git_config_free(cfg);
}
static int DeleteOtherKeys(int type)
{
CString match;
if (type == SimpleCredentialType::LocalWincred)
match = _T("L\ncredential.helper\nwincred");
else if (type == SimpleCredentialType::LocalWinstore)
match = _T("L\ncredential.helper\n") + GetWinstorePath();
else if (type == SimpleCredentialType::GlobalWincred)
match = _T("G\ncredential.helper\nwincred");
else if (type == SimpleCredentialType::GlobalWinstore)
match = _T("G\ncredential.helper\n") + GetWinstorePath();
else if (type == SimpleCredentialType::SystemWincred)
match = _T("S\ncredential.helper\nwincred");
CAutoConfig config(true);
git_config_add_file_ondisk(config, CGit::GetGitPathStringA(g_Git.GetGitLocalConfig()), GIT_CONFIG_LEVEL_LOCAL, FALSE);
git_config_add_file_ondisk(config, CGit::GetGitPathStringA(g_Git.GetGitGlobalConfig()), GIT_CONFIG_LEVEL_GLOBAL, FALSE);
git_config_add_file_ondisk(config, CGit::GetGitPathStringA(g_Git.GetGitGlobalXDGConfig()), GIT_CONFIG_LEVEL_XDG, FALSE);
git_config_add_file_ondisk(config, CGit::GetGitPathStringA(g_Git.GetGitSystemConfig()), GIT_CONFIG_LEVEL_SYSTEM, FALSE);
STRING_VECTOR list;
git_config_foreach_match(config, "credential\\..*", GetCredentialAnyEntryCallback, &list);
for (size_t i = 0; i < list.size(); ++i)
{
int pos = 0;
CString prefix = list[i].Tokenize(_T("\n"), pos);
if (prefix == _T("S") && !CAppUtils::IsAdminLogin())
{
RunUAC();
return -1;
}
}
int result = 0;
// workaround gitdll bug
// TODO: switch to libgit2
bool old = g_Git.m_IsUseGitDLL;
g_Git.m_IsUseGitDLL = false;
for (size_t i = 0; i < list.size(); ++i)
{
if (list[i] != match)
{
int pos = 0;
CString prefix = list[i].Tokenize(_T("\n"), pos);
CString key = list[i].Tokenize(_T("\n"), pos);
CONFIG_TYPE configLevel = prefix == _T("S") ? CONFIG_SYSTEM : prefix == _T("G") || prefix == _T("X") ? CONFIG_GLOBAL : CONFIG_LOCAL;
if (g_Git.UnsetConfigValue(key, configLevel))
{
CString msg;
msg.Format(IDS_PROC_SAVECONFIGFAILED, key, _T(""));
CMessageBox::Show(NULL, msg, _T("TortoiseGit"), MB_OK | MB_ICONERROR);
result = 1;
break;
}
}
}
g_Git.m_IsUseGitDLL = old;
return result;
}
int CGitIndexList::ReadIndex(CString dgitdir)
{
this->clear();
m_critRepoSec.Lock();
if (repository.Open(dgitdir))
{
m_critRepoSec.Unlock();
return -1;
}
// add config files
CAutoConfig config(true);
CString projectConfig = dgitdir + _T("config");
CString globalConfig = g_Git.GetGitGlobalConfig();
CString globalXDGConfig = g_Git.GetGitGlobalXDGConfig();
CString systemConfig(CRegString(REG_SYSTEM_GITCONFIGPATH, _T(""), FALSE));
git_config_add_file_ondisk(config, CGit::GetGitPathStringA(projectConfig), GIT_CONFIG_LEVEL_LOCAL, FALSE);
git_config_add_file_ondisk(config, CGit::GetGitPathStringA(globalConfig), GIT_CONFIG_LEVEL_GLOBAL, FALSE);
git_config_add_file_ondisk(config, CGit::GetGitPathStringA(globalXDGConfig), GIT_CONFIG_LEVEL_XDG, FALSE);
if (!systemConfig.IsEmpty())
git_config_add_file_ondisk(config, CGit::GetGitPathStringA(systemConfig), GIT_CONFIG_LEVEL_SYSTEM, FALSE);
git_repository_set_config(repository, config);
CAutoIndex index;
// load index in order to enumerate files
if (git_repository_index(index.GetPointer(), repository))
{
repository.Free();
m_critRepoSec.Unlock();
return -1;
}
size_t ecount = git_index_entrycount(index);
resize(ecount);
for (size_t i = 0; i < ecount; ++i)
{
const git_index_entry *e = git_index_get_byindex(index, i);
this->at(i).m_FileName.Empty();
this->at(i).m_FileName = CUnicodeUtils::GetUnicode(e->path);
this->at(i).m_FileName.MakeLower();
this->at(i).m_ModifyTime = e->mtime.seconds;
this->at(i).m_Flags = e->flags | e->flags_extended;
this->at(i).m_IndexHash = e->id.id;
this->at(i).m_Size = e->file_size;
}
g_Git.GetFileModifyTime(dgitdir + _T("index"), &this->m_LastModifyTime);
std::sort(this->begin(), this->end(), SortIndex);
m_critRepoSec.Unlock();
return 0;
}
static int load_config(
git_config **out,
git_repository *repo,
const char *global_config_path,
const char *xdg_config_path,
const char *system_config_path)
{
int error;
git_buf config_path = GIT_BUF_INIT;
git_config *cfg = NULL;
assert(repo && out);
if ((error = git_config_new(&cfg)) < 0)
return error;
error = git_buf_joinpath(
&config_path, repo->path_repository, GIT_CONFIG_FILENAME_INREPO);
if (error < 0)
goto on_error;
if ((error = git_config_add_file_ondisk(
cfg, config_path.ptr, GIT_CONFIG_LEVEL_LOCAL, 0)) < 0 &&
error != GIT_ENOTFOUND)
goto on_error;
git_buf_free(&config_path);
if (global_config_path != NULL &&
(error = git_config_add_file_ondisk(
cfg, global_config_path, GIT_CONFIG_LEVEL_GLOBAL, 0)) < 0 &&
error != GIT_ENOTFOUND)
goto on_error;
if (xdg_config_path != NULL &&
(error = git_config_add_file_ondisk(
cfg, xdg_config_path, GIT_CONFIG_LEVEL_XDG, 0)) < 0 &&
error != GIT_ENOTFOUND)
goto on_error;
if (system_config_path != NULL &&
(error = git_config_add_file_ondisk(
cfg, system_config_path, GIT_CONFIG_LEVEL_SYSTEM, 0)) < 0 &&
error != GIT_ENOTFOUND)
goto on_error;
giterr_clear(); /* clear any lingering ENOTFOUND errors */
*out = cfg;
return 0;
on_error:
git_buf_free(&config_path);
git_config_free(cfg);
*out = NULL;
return error;
}
bool CGitIgnoreList::CheckAndUpdateCoreExcludefile(const CString &adminDir)
{
CString projectConfig = adminDir + _T("config");
CString globalConfig = g_Git.GetGitGlobalConfig();
CString globalXDGConfig = g_Git.GetGitGlobalXDGConfig();
CAutoWriteLock lock(m_coreExcludefilesSharedMutex);
bool hasChanged = CheckAndUpdateGitSystemConfigPath();
hasChanged = hasChanged || CheckFileChanged(projectConfig);
hasChanged = hasChanged || CheckFileChanged(globalConfig);
hasChanged = hasChanged || CheckFileChanged(globalXDGConfig);
if (!m_sGitSystemConfigPath.IsEmpty())
hasChanged = hasChanged || CheckFileChanged(m_sGitSystemConfigPath);
CString excludesFile;
{
CAutoReadLock lock2(m_SharedMutex);
excludesFile = m_CoreExcludesfiles[adminDir];
}
if (!excludesFile.IsEmpty())
hasChanged = hasChanged || CheckFileChanged(excludesFile);
if (!hasChanged)
return false;
CAutoConfig config(true);
git_config_add_file_ondisk(config, CGit::GetGitPathStringA(projectConfig), GIT_CONFIG_LEVEL_LOCAL, FALSE);
git_config_add_file_ondisk(config, CGit::GetGitPathStringA(globalConfig), GIT_CONFIG_LEVEL_GLOBAL, FALSE);
git_config_add_file_ondisk(config, CGit::GetGitPathStringA(globalXDGConfig), GIT_CONFIG_LEVEL_XDG, FALSE);
if (!m_sGitSystemConfigPath.IsEmpty())
git_config_add_file_ondisk(config, CGit::GetGitPathStringA(m_sGitSystemConfigPath), GIT_CONFIG_LEVEL_SYSTEM, FALSE);
config.GetString(_T("core.excludesfile"), excludesFile);
if (excludesFile.IsEmpty())
excludesFile = GetWindowsHome() + _T("\\.config\\git\\ignore");
else if (excludesFile.Find(_T("~/")) == 0)
excludesFile = GetWindowsHome() + excludesFile.Mid(1);
CAutoWriteLock lockMap(m_SharedMutex);
g_Git.GetFileModifyTime(projectConfig, &m_Map[projectConfig].m_LastModifyTime);
g_Git.GetFileModifyTime(globalXDGConfig, &m_Map[globalXDGConfig].m_LastModifyTime);
if (m_Map[globalXDGConfig].m_LastModifyTime == 0)
m_Map.erase(globalXDGConfig);
g_Git.GetFileModifyTime(globalConfig, &m_Map[globalConfig].m_LastModifyTime);
if (m_Map[globalConfig].m_LastModifyTime == 0)
m_Map.erase(globalConfig);
if (!m_sGitSystemConfigPath.IsEmpty())
g_Git.GetFileModifyTime(m_sGitSystemConfigPath, &m_Map[m_sGitSystemConfigPath].m_LastModifyTime);
if (m_Map[m_sGitSystemConfigPath].m_LastModifyTime == 0 || m_sGitSystemConfigPath.IsEmpty())
m_Map.erase(m_sGitSystemConfigPath);
m_CoreExcludesfiles[adminDir] = excludesFile;
return true;
}
/**
* ggit_config_add_file:
* @config: a #GgitConfig.
* @file: a #GFile.
* @level: a #GgitConfigLevel.
* @force: if a config file already exists for the given priority level, replace it.
* @error: a #GError for error reporting, or %NULL.
*
* Add an on-disk config file instance to an existing config
*
* The on-disk file pointed at by @file will be opened and
* parsed; it's expected to be a native Git config file following
* the default Git config syntax (see man git-config).
*
* Further queries on this config object will access each
* of the config file instances in order (instances with
* a higher priority level will be accessed first).
*/
void
ggit_config_add_file (GgitConfig *config,
GFile *file,
GgitConfigLevel level,
gboolean force,
GError **error)
{
gint ret;
gchar *path;
g_return_if_fail (GGIT_IS_CONFIG (config));
g_return_if_fail (G_IS_FILE (file));
g_return_if_fail (error == NULL || *error == NULL);
path = g_file_get_path (file);
ret = git_config_add_file_ondisk (_ggit_native_get (config),
path,
(git_config_level_t)level,
force);
g_free (path);
if (ret != GIT_OK)
{
_ggit_error_set (error, ret);
}
}
void test_config_configlevel__can_replace_a_config_file_at_an_existing_level(void)
{
git_config *cfg;
const char *s;
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(&s, cfg, "core.stringglobal"));
cl_assert_equal_s("don't find me!", s);
git_config_free(cfg);
}
int CTGitPath::GetAdminDirMask() const
{
int status = 0;
CString topdir;
if (!GitAdminDir::HasAdminDir(GetWinPathString(), &topdir))
{
return status;
}
// ITEMIS_INGIT will be revoked if necessary in TortoiseShell/ContextMenu.cpp
status |= ITEMIS_INGIT|ITEMIS_INVERSIONEDFOLDER;
if (IsDirectory())
{
status |= ITEMIS_FOLDERINGIT;
if (IsWCRoot())
{
status |= ITEMIS_WCROOT;
CString topProjectDir;
if (GitAdminDir::HasAdminDir(GetWinPathString(), false, &topProjectDir))
{
if (PathFileExists(topProjectDir + _T("\\.gitmodules")))
{
CAutoConfig config(true);
git_config_add_file_ondisk(config, CGit::GetGitPathStringA(topProjectDir + _T("\\.gitmodules")), GIT_CONFIG_LEVEL_APP, FALSE);
CString relativePath = GetWinPathString().Mid(topProjectDir.GetLength());
relativePath.Replace(_T("\\"), _T("/"));
relativePath.Trim(_T("/"));
CStringA submodulePath = CUnicodeUtils::GetUTF8(relativePath);
if (git_config_foreach_match(config, "submodule\\..*\\.path",
[](const git_config_entry *entry, void *data) { return entry->value == *(CStringA *)data ? GIT_EUSER : 0; }, &submodulePath) == GIT_EUSER)
status |= ITEMIS_SUBMODULE;
}
}
}
}
CString dotGitPath;
GitAdminDir::GetAdminDirPath(topdir, dotGitPath);
if (PathFileExists(dotGitPath + _T("BISECT_START")))
status |= ITEMIS_BISECT;
if (PathFileExists(dotGitPath + _T("MERGE_HEAD")))
status |= ITEMIS_MERGEACTIVE;
if (PathFileExists(dotGitPath + _T("refs\\stash")))
status |= ITEMIS_STASH;
if (PathFileExists(dotGitPath + _T("svn")))
status |= ITEMIS_GITSVN;
if (PathFileExists(topdir + _T("\\.gitmodules")))
status |= ITEMIS_SUBMODULECONTAINER;
return status;
}
void test_config_configlevel__adding_the_same_level_twice_returns_EEXISTS(void)
{
int error;
git_config *cfg;
cl_git_pass(git_config_new(&cfg));
cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config9"),
GIT_CONFIG_LEVEL_LOCAL, 0));
cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config15"),
GIT_CONFIG_LEVEL_GLOBAL, 0));
error = git_config_add_file_ondisk(cfg, cl_fixture("config/config16"),
GIT_CONFIG_LEVEL_GLOBAL, 0);
cl_git_fail(error);
cl_assert_equal_i(GIT_EEXISTS, error);
git_config_free(cfg);
}
CString CSettingGitCredential::Load(CString key)
{
CString cmd;
if (m_strUrl.IsEmpty())
cmd.Format(_T("credential.%s"), key);
else
cmd.Format(_T("credential.%s.%s"), m_strUrl, key);
git_config * config;
git_config_new(&config);
int sel = m_ctrlConfigType.GetCurSel();
if (sel == ConfigType::Local)
{
CStringA projectConfigA = CUnicodeUtils::GetUTF8(g_Git.GetGitLocalConfig());
git_config_add_file_ondisk(config, projectConfigA.GetBuffer(), GIT_CONFIG_LEVEL_LOCAL, FALSE);
projectConfigA.ReleaseBuffer();
}
else if (sel == ConfigType::Global)
{
CStringA globalConfigA = CUnicodeUtils::GetUTF8(g_Git.GetGitGlobalConfig());
git_config_add_file_ondisk(config, globalConfigA.GetBuffer(), GIT_CONFIG_LEVEL_GLOBAL, FALSE);
globalConfigA.ReleaseBuffer();
CStringA globalXDGConfigA = CUnicodeUtils::GetUTF8(g_Git.GetGitGlobalXDGConfig());
git_config_add_file_ondisk(config, globalXDGConfigA.GetBuffer(), GIT_CONFIG_LEVEL_XDG, FALSE);
globalXDGConfigA.ReleaseBuffer();
}
else if (sel == ConfigType::System)
{
CStringA systemConfigA = CUnicodeUtils::GetUTF8(g_Git.GetGitSystemConfig());
git_config_add_file_ondisk(config, systemConfigA.GetBuffer(), GIT_CONFIG_LEVEL_SYSTEM, FALSE);
systemConfigA.ReleaseBuffer();
}
CStringA cmdA = CUnicodeUtils::GetUTF8(cmd);
CStringA valueA;
const git_config_entry *entry;
if (!git_config_get_entry(&entry, config, cmdA))
valueA = CStringA(entry->value);
cmdA.ReleaseBuffer();
git_config_free(config);
return CUnicodeUtils::GetUnicode(valueA);
}
MAP_STRING_STRING GetBranchDescriptions()
{
MAP_STRING_STRING descriptions;
git_config * config;
git_config_new(&config);
git_config_add_file_ondisk(config, CGit::GetGitPathStringA(g_Git.GetGitLocalConfig()), GIT_CONFIG_LEVEL_LOCAL, FALSE);
git_config_foreach_match(config, "branch\\..*\\.description", GetBranchDescriptionsCallback, &descriptions);
git_config_free(config);
return descriptions;
}
BOOL CFirstStartWizardAuthentication::OnWizardFinish()
{
UpdateData();
CString sshclient = CRegString(L"Software\\TortoiseGit\\SSH");
if (sshclient.IsEmpty())
sshclient = CRegString(L"Software\\TortoiseGit\\SSH", L"", FALSE, HKEY_LOCAL_MACHINE);
if (m_ctrlSSHClient.GetCurSel() == 0 && !(sshclient.IsEmpty() || IsTool(L"tortoisegitplink", sshclient) || IsTool(L"tortoiseplink", sshclient)))
CRegString(L"Software\\TortoiseGit\\SSH") = CPathUtils::GetAppDirectory() + L"TortoiseGitPlink.exe";
else if (m_ctrlSSHClient.GetCurSel() == 1 && !IsTool(L"ssh", sshclient))
CRegString(L"Software\\TortoiseGit\\SSH") = L"ssh.exe";
if (m_ctrlSimpleCredential.IsWindowEnabled() && !m_bNoSave && m_ctrlSimpleCredential.GetCurSel() != -1)
{
CAutoConfig config(true);
int err = git_config_add_file_ondisk(config, CGit::GetGitPathStringA(g_Git.GetGitGlobalXDGConfig()), GIT_CONFIG_LEVEL_XDG, nullptr, FALSE);
if (!err && (PathFileExists(g_Git.GetGitGlobalConfig()) || !PathFileExists(g_Git.GetGitGlobalXDGConfig())))
err = git_config_add_file_ondisk(config, CGit::GetGitPathStringA(g_Git.GetGitGlobalConfig()), GIT_CONFIG_LEVEL_GLOBAL, nullptr, FALSE);
if (err)
{
MessageBox(g_Git.GetLibGit2LastErr(), L"TortoiseGit", MB_ICONEXCLAMATION);
return FALSE;
}
if (m_ctrlSimpleCredential.GetCurSel() == 0 && m_availableHelpers.at(0) == CString(MAKEINTRESOURCE(IDS_NONE)))
{
int ret = git_config_delete_entry(config, "credential.helper");
if (ret != 0 && ret != GIT_ENOTFOUND)
{
MessageBox(g_Git.GetLibGit2LastErr(), L"TortoiseGit", MB_ICONEXCLAMATION);
return FALSE;
}
}
else if (git_config_set_string(config, "credential.helper", CUnicodeUtils::GetUTF8(m_availableHelpers.at(m_ctrlSimpleCredential.GetCurSel()))))
{
MessageBox(g_Git.GetLibGit2LastErr(), L"TortoiseGit", MB_ICONEXCLAMATION);
return FALSE;
}
}
return __super::OnWizardFinish();
}
static int load_config(
git_config **out,
git_repository *repo,
const char *global_config_path,
const char *system_config_path)
{
git_buf config_path = GIT_BUF_INIT;
git_config *cfg = NULL;
assert(repo && out);
if (git_config_new(&cfg) < 0)
return -1;
if (git_buf_joinpath(
&config_path, repo->path_repository, GIT_CONFIG_FILENAME_INREPO) < 0)
goto on_error;
if (git_config_add_file_ondisk(cfg, config_path.ptr, 3) < 0)
goto on_error;
git_buf_free(&config_path);
if (global_config_path != NULL) {
if (git_config_add_file_ondisk(cfg, global_config_path, 2) < 0)
goto on_error;
}
if (system_config_path != NULL) {
if (git_config_add_file_ondisk(cfg, system_config_path, 1) < 0)
goto on_error;
}
*out = cfg;
return 0;
on_error:
git_buf_free(&config_path);
git_config_free(cfg);
*out = NULL;
return -1;
}
/*
* At the beginning of the test:
* - config9 has: core.global does not exist
* - config15 has: core.global=17
* - config16 has: core.global=29
*
* And also:
* - config9 has: core.system does not exist
* - config15 has: core.system does not exist
* - config16 has: core.system=11
*/
void test_config_read__fallback_from_local_to_global_and_from_global_to_system(void)
{
git_config *cfg;
int32_t i;
cl_git_pass(git_config_new(&cfg));
cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config9"),
GIT_CONFIG_LEVEL_SYSTEM, NULL, 0));
cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config15"),
GIT_CONFIG_LEVEL_GLOBAL, NULL, 0));
cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config16"),
GIT_CONFIG_LEVEL_LOCAL, NULL, 0));
cl_git_pass(git_config_get_int32(&i, cfg, "core.global"));
cl_assert_equal_i(17, i);
cl_git_pass(git_config_get_int32(&i, cfg, "core.system"));
cl_assert_equal_i(11, i);
git_config_free(cfg);
}
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;
const char *s;
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(&s, single_level_cfg, "core.stringglobal"));
cl_assert_equal_s("don't find me!", s);
git_config_free(single_level_cfg);
}
MAP_STRING_STRING GetBranchDescriptions()
{
MAP_STRING_STRING descriptions;
git_config * config;
git_config_new(&config);
CStringA projectConfigA = CUnicodeUtils::GetMulti(g_Git.GetGitLocalConfig(), CP_UTF8);
git_config_add_file_ondisk(config, projectConfigA.GetBuffer(), 3);
projectConfigA.ReleaseBuffer();
git_config_foreach_match(config, "branch\\..*\\.description", GetBranchDescriptionsCallback, &descriptions);
git_config_free(config);
return descriptions;
}
void test_config_read__foreach(void)
{
git_config *cfg;
int count, ret;
cl_git_pass(git_config_new(&cfg));
cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config9"),
GIT_CONFIG_LEVEL_SYSTEM, NULL, 0));
cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config15"),
GIT_CONFIG_LEVEL_GLOBAL, NULL, 0));
count = 0;
cl_git_pass(git_config_foreach(cfg, count_cfg_entries_and_compare_levels, &count));
cl_assert_equal_i(7, count);
count = 3;
cl_git_fail(ret = git_config_foreach(cfg, cfg_callback_countdown, &count));
cl_assert_equal_i(-100, ret);
git_config_free(cfg);
}
void test_config_read__iterator(void)
{
const char *keys[] = {
"core.dummy2",
"core.verylong",
"core.dummy",
"remote.ab.url",
"remote.abba.url",
"core.dummy2",
"core.global"
};
git_config *cfg;
git_config_iterator *iter;
git_config_entry *entry;
int count, ret;
cl_git_pass(git_config_new(&cfg));
cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config9"),
GIT_CONFIG_LEVEL_SYSTEM, NULL, 0));
cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config15"),
GIT_CONFIG_LEVEL_GLOBAL, NULL, 0));
count = 0;
cl_git_pass(git_config_iterator_new(&iter, cfg));
while ((ret = git_config_next(&entry, iter)) == 0) {
cl_assert_equal_s(entry->name, keys[count]);
count++;
}
git_config_iterator_free(iter);
cl_assert_equal_i(GIT_ITEROVER, ret);
cl_assert_equal_i(7, count);
count = 3;
cl_git_pass(git_config_iterator_new(&iter, cfg));
git_config_iterator_free(iter);
git_config_free(cfg);
}
bool CSettingGitRemote::IsRemoteCollideWithRefspec(CString remote)
{
CheckRefspecStruct crs = { CUnicodeUtils::GetUTF8(remote), false };
CAutoConfig config(true);
git_config_add_file_ondisk(config, CGit::GetGitPathStringA(g_Git.GetGitLocalConfig()), GIT_CONFIG_LEVEL_LOCAL, g_Git.GetGitRepository(), FALSE);
for (const auto pattern : { "remote\\..*\\.fetch", "svn-remote\\..*\\.fetch", "svn-remote\\..*\\.branches", "svn-remote\\..*\\.tags" })
{
git_config_foreach_match(config, pattern, CheckRemoteCollideWithRefspec, &crs);
if (crs.result)
return true;
}
return false;
}
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);
}
int git_config_open_ondisk(git_config **cfg, const char *path)
{
int error;
error = git_config_new(cfg);
if (error < GIT_SUCCESS)
return error;
error = git_config_add_file_ondisk(*cfg, path, 1);
if (error < GIT_SUCCESS)
git_config_free(*cfg);
return error;
}
TEST(libgit2, Config)
{
CAutoTempDir tempdir;
CString testFile = tempdir.GetTempDir() + L"\\config";
EXPECT_TRUE(CStringUtils::WriteStringToTextFile(testFile, L"[core]\[email protected]\ntrue=true\nfalse=false\n"));
CAutoConfig config(true);
EXPECT_EQ(0, git_config_add_file_ondisk(config, CUnicodeUtils::GetUTF8(testFile), GIT_CONFIG_LEVEL_LOCAL, 1));
bool ret = false;
EXPECT_EQ(0, config.GetBool(L"core.true", ret));
EXPECT_EQ(true, ret);
EXPECT_EQ(0, config.GetBool(L"core.false", ret));
EXPECT_EQ(false, ret);
EXPECT_EQ(-3, config.GetBool(L"core.not-exist", ret));
CString value;
EXPECT_EQ(0, config.GetString(L"core.email", value));
EXPECT_STREQ(L"*****@*****.**", value);
}
void test_config_read__read_git_config_entry(void)
{
git_config *cfg;
git_config_entry *entry;
cl_git_pass(git_config_new(&cfg));
cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config9"),
GIT_CONFIG_LEVEL_SYSTEM, NULL, 0));
cl_git_pass(git_config_get_entry(&entry, cfg, "core.dummy2"));
cl_assert_equal_s("core.dummy2", entry->name);
cl_assert_equal_s("42", entry->value);
cl_assert_equal_i(GIT_CONFIG_LEVEL_SYSTEM, entry->level);
git_config_entry_free(entry);
git_config_free(cfg);
}
