int hiredis_backend__write(git_oid *id, git_odb_backend *_backend, const void *data, size_t len, git_otype type)
{
hiredis_backend *backend;
int error;
redisReply *reply;
assert(id && _backend && data);
backend = (hiredis_backend *) _backend;
error = GIT_ERROR;
if ((error = git_odb_hash(id, data, len, type)) < 0)
return error;
reply = redisCommand(backend->db, "HMSET %b "
"type %d "
"size %d "
"data %b ", id->id, GIT_OID_RAWSZ,
(int) type, len, data, len);
error = (reply == NULL || reply->type == REDIS_REPLY_ERROR) ? GIT_ERROR : GIT_OK;
freeReplyObject(reply);
return error;
}
int git_diff_file_content__init_from_raw(
git_diff_file_content *fc,
git_repository *repo,
const git_diff_options *opts,
const char *buf,
size_t buflen,
git_diff_file *as_file)
{
memset(fc, 0, sizeof(*fc));
fc->repo = repo;
fc->file = as_file;
if (!buf) {
fc->flags |= GIT_DIFF_FLAG__NO_DATA;
} else {
fc->flags |= GIT_DIFF_FLAG__LOADED;
fc->file->flags |= GIT_DIFF_FLAG_VALID_OID;
fc->file->size = buflen;
fc->file->mode = GIT_FILEMODE_BLOB;
git_odb_hash(&fc->file->oid, buf, buflen, GIT_OBJ_BLOB);
fc->map.len = buflen;
fc->map.data = (char *)buf;
}
return diff_file_content_init_common(fc, opts);
}
static int diff_file_content_load_workdir(git_diff_file_content *fc)
{
int error = 0;
git_buf path = GIT_BUF_INIT;
if (fc->file->mode == GIT_FILEMODE_COMMIT)
return diff_file_content_commit_to_str(fc, true);
if (fc->file->mode == GIT_FILEMODE_TREE)
return 0;
if (git_buf_joinpath(
&path, git_repository_workdir(fc->repo), fc->file->path) < 0)
return -1;
if (S_ISLNK(fc->file->mode))
error = diff_file_content_load_workdir_symlink(fc, &path);
else
error = diff_file_content_load_workdir_file(fc, &path);
/* once data is loaded, update OID if we didn't have it previously */
if (!error && (fc->file->flags & GIT_DIFF_FLAG_VALID_OID) == 0) {
error = git_odb_hash(
&fc->file->oid, fc->map.data, fc->map.len, GIT_OBJ_BLOB);
fc->file->flags |= GIT_DIFF_FLAG_VALID_OID;
}
git_buf_free(&path);
return error;
}
int git_odb__hashfd_filtered(
git_oid *out, git_file fd, size_t size, git_otype type, git_filter_list *fl)
{
int error;
git_buf raw = GIT_BUF_INIT;
if (!fl)
return git_odb__hashfd(out, fd, size, type);
/* size of data is used in header, so we have to read the whole file
* into memory to apply filters before beginning to calculate the hash
*/
if (!(error = git_futils_readbuffer_fd(&raw, fd, size))) {
git_buf post = GIT_BUF_INIT;
error = git_filter_list_apply_to_data(&post, fl, &raw);
git_buf_free(&raw);
if (!error)
error = git_odb_hash(out, post.ptr, post.size, type);
git_buf_free(&post);
}
return error;
}
PyObject *
hash(PyObject *self, PyObject *args)
{
git_oid oid;
const char *data;
Py_ssize_t size;
int err;
if (!PyArg_ParseTuple(args, "s#", &data, &size))
return NULL;
err = git_odb_hash(&oid, data, size, GIT_OBJ_BLOB);
if (err < 0) {
return Error_set(err);
}
return git_oid_to_python(&oid);
}
int git_odb__hashlink(git_oid *out, const char *path)
{
struct stat st;
git_off_t size;
int result;
if (git_path_lstat(path, &st) < 0)
return -1;
size = st.st_size;
if (!git__is_sizet(size)) {
giterr_set(GITERR_OS, "File size overflow for 32-bit systems");
return -1;
}
if (S_ISLNK(st.st_mode)) {
char *link_data;
ssize_t read_len;
link_data = (char*) git__malloc((size_t)(size + 1));
GITERR_CHECK_ALLOC(link_data);
read_len = p_readlink(path, link_data, (size_t)size);
link_data[size] = '\0';
if (read_len != (ssize_t)size) {
giterr_set(GITERR_OS, "Failed to read symlink data for '%s'", path);
git__free(link_data);
return -1;
}
result = git_odb_hash(out, link_data, (size_t)size, GIT_OBJ_BLOB);
git__free(link_data);
} else {
int fd = git_futils_open_ro(path);
if (fd < 0)
return -1;
result = git_odb__hashfd(out, fd, (size_t)size, GIT_OBJ_BLOB);
p_close(fd);
}
return result;
}
int git_odb_write(
git_oid *oid, git_odb *db, const void *data, size_t len, git_otype type)
{
size_t i;
int error = GIT_ERROR;
git_odb_stream *stream;
assert(oid && db);
git_odb_hash(oid, data, len, type);
if (git_odb_exists(db, oid))
return 0;
for (i = 0; i < db->backends.length && error < 0; ++i) {
backend_internal *internal = (backend_internal *) git_vector_get(&db->backends, i);
git_odb_backend *b = internal->backend;
/* we don't write in alternates! */
if (internal->is_alternate)
continue;
if (b->write != NULL)
error = b->write(b, oid, data, len, type);
}
if (!error || error == GIT_PASSTHROUGH)
return 0;
/* if no backends were able to write the object directly, we try a
* streaming write to the backends; just write the whole object into the
* stream in one push
*/
if ((error = git_odb_open_wstream(&stream, db, len, type)) != 0)
return error;
stream->write(stream, (char*) data, len);
error = stream->finalize_write(stream, oid);
git_odb_stream_free(stream);
return error;
}
int git_diff_file_content__init_from_src(
git_diff_file_content *fc,
git_repository *repo,
const git_diff_options *opts,
const git_diff_file_content_src *src,
git_diff_file *as_file)
{
memset(fc, 0, sizeof(*fc));
fc->repo = repo;
fc->file = as_file;
if (!src->blob && !src->buf) {
fc->flags |= GIT_DIFF_FLAG__NO_DATA;
} else {
fc->flags |= GIT_DIFF_FLAG__LOADED;
fc->file->flags |= GIT_DIFF_FLAG_VALID_ID;
fc->file->mode = GIT_FILEMODE_BLOB;
if (src->blob) {
git_blob_dup((git_blob **)&fc->blob, (git_blob *) src->blob);
fc->file->size = git_blob_rawsize(src->blob);
git_oid_cpy(&fc->file->id, git_blob_id(src->blob));
fc->file->id_abbrev = GIT_OID_HEXSZ;
fc->map.len = (size_t)fc->file->size;
fc->map.data = (char *)git_blob_rawcontent(src->blob);
fc->flags |= GIT_DIFF_FLAG__FREE_BLOB;
} else {
fc->file->size = src->buflen;
git_odb_hash(&fc->file->id, src->buf, src->buflen, GIT_OBJECT_BLOB);
fc->file->id_abbrev = GIT_OID_HEXSZ;
fc->map.len = src->buflen;
fc->map.data = (char *)src->buf;
}
}
return diff_file_content_init_common(fc, opts);
}
int
main(int argc, char *argv[])
{
int i;
for (i = 1; i < argc; i++) {
const char *arg = argv[i];
char buf[64] = "----------------------------------------";
#ifdef GIT2
git_oid oid;
git_odb_hash(&oid, arg, strlen(arg), GIT_OBJ_BLOB);
git_oid_fmt(buf, &oid);
#endif
buf[40] = '\0';
printf("%s: %s\n", arg, buf);
}
return 0;
}
static int workdir_reader_read(
git_buf *out,
git_oid *out_id,
git_filemode_t *out_filemode,
git_reader *_reader,
const char *filename)
{
workdir_reader *reader = (workdir_reader *)_reader;
git_buf path = GIT_BUF_INIT;
struct stat st;
git_filemode_t filemode;
git_filter_list *filters = NULL;
const git_index_entry *idx_entry;
git_oid id;
int error;
if ((error = git_buf_joinpath(&path,
git_repository_workdir(reader->repo), filename)) < 0)
goto done;
if ((error = p_lstat(path.ptr, &st)) < 0) {
if (error == -1 && errno == ENOENT)
error = GIT_ENOTFOUND;
giterr_set(GITERR_OS, "could not stat '%s'", path.ptr);
goto done;
}
filemode = git_futils_canonical_mode(st.st_mode);
/*
* Patch application - for example - uses the filtered version of
* the working directory data to match git. So we will run the
* workdir -> ODB filter on the contents in this workdir reader.
*/
if ((error = git_filter_list_load(&filters, reader->repo, NULL, filename,
GIT_FILTER_TO_ODB, GIT_FILTER_DEFAULT)) < 0)
goto done;
if ((error = git_filter_list_apply_to_file(out,
filters, reader->repo, path.ptr)) < 0)
goto done;
if (out_id || reader->index) {
if ((error = git_odb_hash(&id, out->ptr, out->size, GIT_OBJ_BLOB)) < 0)
goto done;
}
if (reader->index) {
if (!(idx_entry = git_index_get_bypath(reader->index, filename, 0)) ||
filemode != idx_entry->mode ||
!git_oid_equal(&id, &idx_entry->id)) {
error = GIT_READER_MISMATCH;
goto done;
}
}
if (out_id)
git_oid_cpy(out_id, &id);
if (out_filemode)
*out_filemode = filemode;
done:
git_filter_list_free(filters);
git_buf_dispose(&path);
return error;
}
static void hash_object_pass(git_oid *oid, git_rawobj *obj)
{
cl_git_pass(git_odb_hash(oid, obj->data, obj->len, obj->type));
}
BOOL CTortoiseProcApp::InitInstance()
{
CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": InitInstance\n"));
CheckUpgrade();
CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManagerWindows));
CMFCButton::EnableWindowsTheming();
CHistoryCombo::m_nGitIconIndex = SYS_IMAGE_LIST().AddIcon((HICON)LoadImage(AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_GITCONFIG), IMAGE_ICON, 0, 0, LR_DEFAULTSIZE));
Gdiplus::GdiplusStartupInput gdiplusStartupInput;
Gdiplus::GdiplusStartup(&m_gdiplusToken,&gdiplusStartupInput,NULL);
//set the resource dll for the required language
CRegDWORD loc = CRegDWORD(_T("Software\\TortoiseGit\\LanguageID"), 1033);
long langId = loc;
{
CString langStr;
langStr.Format(_T("%ld"), langId);
CCrashReport::Instance().AddUserInfoToReport(L"LanguageID", langStr);
}
CString langDll;
CStringA langpath = CStringA(CPathUtils::GetAppParentDirectory());
langpath += "Languages";
do
{
langDll.Format(_T("%sLanguages\\TortoiseProc%ld.dll"), (LPCTSTR)CPathUtils::GetAppParentDirectory(), langId);
CString sVer = _T(STRPRODUCTVER);
CString sFileVer = CPathUtils::GetVersionFromFile(langDll);
if (sFileVer == sVer)
{
HINSTANCE hInst = LoadLibrary(langDll);
if (hInst != NULL)
{
CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": Load Language DLL %s\n"), langDll);
AfxSetResourceHandle(hInst);
break;
}
}
{
DWORD lid = SUBLANGID(langId);
lid--;
if (lid > 0)
{
langId = MAKELANGID(PRIMARYLANGID(langId), lid);
}
else
langId = 0;
}
} while (langId != 0);
TCHAR buf[6] = { 0 };
_tcscpy_s(buf, _T("en"));
langId = loc;
// MFC uses a help file with the same name as the application by default,
// which means we have to change that default to our language specific help files
CString sHelppath = CPathUtils::GetAppDirectory() + _T("TortoiseGit_en.chm");
free((void*)m_pszHelpFilePath);
m_pszHelpFilePath=_tcsdup(sHelppath);
sHelppath = CPathUtils::GetAppParentDirectory() + _T("Languages\\TortoiseGit_en.chm");
do
{
CString sLang = _T("_");
if (GetLocaleInfo(MAKELCID(langId, SORT_DEFAULT), LOCALE_SISO639LANGNAME, buf, _countof(buf)))
{
sLang += buf;
sHelppath.Replace(_T("_en"), sLang);
if (PathFileExists(sHelppath))
{
free((void*)m_pszHelpFilePath);
m_pszHelpFilePath=_tcsdup(sHelppath);
break;
}
}
sHelppath.Replace(sLang, _T("_en"));
if (GetLocaleInfo(MAKELCID(langId, SORT_DEFAULT), LOCALE_SISO3166CTRYNAME, buf, _countof(buf)))
{
sLang += _T("_");
sLang += buf;
sHelppath.Replace(_T("_en"), sLang);
if (PathFileExists(sHelppath))
{
free((void*)m_pszHelpFilePath);
m_pszHelpFilePath=_tcsdup(sHelppath);
break;
}
}
sHelppath.Replace(sLang, _T("_en"));
DWORD lid = SUBLANGID(langId);
lid--;
if (lid > 0)
{
langId = MAKELANGID(PRIMARYLANGID(langId), lid);
}
else
langId = 0;
} while (langId);
CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": Set Help Filename %s\n"), m_pszHelpFilePath);
setlocale(LC_ALL, "");
if (!g_Git.CheckMsysGitDir())
{
UINT ret = CMessageBox::Show(NULL, IDS_PROC_NOMSYSGIT, IDS_APPNAME, 3, IDI_HAND, IDS_PROC_SETMSYSGITPATH, IDS_PROC_GOTOMSYSGITWEBSITE, IDS_ABORTBUTTON);
if(ret == 2)
{
ShellExecute(NULL, NULL, _T("http://msysgit.github.io/"), NULL, NULL, SW_SHOW);
}
else if(ret == 1)
{
// open settings dialog
CSinglePropSheetDlg(CString(MAKEINTRESOURCE(IDS_PROC_SETTINGS_TITLE)), new CSetMainPage(), this->GetMainWnd()).DoModal();
}
return FALSE;
}
if (CAppUtils::GetMsysgitVersion() < 0x01070a00)
{
int ret = CMessageBox::ShowCheck(NULL, IDS_PROC_OLDMSYSGIT, IDS_APPNAME, 1, IDI_EXCLAMATION, IDS_PROC_GOTOMSYSGITWEBSITE, IDS_ABORTBUTTON, IDS_IGNOREBUTTON, _T("OldMsysgitVersionWarning"), IDS_PROC_NOTSHOWAGAINIGNORE);
if (ret == 1)
{
CMessageBox::RemoveRegistryKey(_T("OldMsysgitVersionWarning")); // only store answer if it is "Ignore"
ShellExecute(NULL, NULL, _T("http://msysgit.github.io/"), NULL, NULL, SW_SHOW);
return FALSE;
}
else if (ret == 2)
{
CMessageBox::RemoveRegistryKey(_T("OldMsysgitVersionWarning")); // only store answer if it is "Ignore"
return FALSE;
}
}
{
CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": Registering Crash Report ...\n"));
CCrashReport::Instance().AddUserInfoToReport(L"msysGitDir", CGit::ms_LastMsysGitDir);
CString versionString;
versionString.Format(_T("%d"), CGit::ms_LastMsysGitVersion);
CCrashReport::Instance().AddUserInfoToReport(L"msysGitVersion", versionString);
}
CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": Initializing UI components ...\n"));
// InitCommonControls() is required on Windows XP if an application
// manifest specifies use of ComCtl32.dll version 6 or later to enable
// visual styles. Otherwise, any window creation will fail.
INITCOMMONCONTROLSEX used = {
sizeof(INITCOMMONCONTROLSEX),
ICC_ANIMATE_CLASS | ICC_BAR_CLASSES | ICC_COOL_CLASSES | ICC_DATE_CLASSES |
ICC_HOTKEY_CLASS | ICC_INTERNET_CLASSES | ICC_LISTVIEW_CLASSES |
ICC_NATIVEFNTCTL_CLASS | ICC_PAGESCROLLER_CLASS | ICC_PROGRESS_CLASS |
ICC_TAB_CLASSES | ICC_TREEVIEW_CLASSES | ICC_UPDOWN_CLASS |
ICC_USEREX_CLASSES | ICC_WIN95_CLASSES
};
InitCommonControlsEx(&used);
AfxOleInit();
AfxEnableControlContainer();
AfxInitRichEdit5();
CWinAppEx::InitInstance();
SetRegistryKey(_T("TortoiseGit"));
AfxGetApp()->m_pszProfileName = _tcsdup(_T("TortoiseProc")); // w/o this ResizableLib will store data under TortoiseGitProc which is not compatible with older versions
CCmdLineParser parser(AfxGetApp()->m_lpCmdLine);
hWndExplorer = NULL;
CString sVal = parser.GetVal(_T("hwnd"));
if (!sVal.IsEmpty())
hWndExplorer = (HWND)_wcstoui64(sVal, nullptr, 16);
while (GetParent(hWndExplorer)!=NULL)
hWndExplorer = GetParent(hWndExplorer);
if (!IsWindow(hWndExplorer))
{
hWndExplorer = NULL;
}
// if HKCU\Software\TortoiseGit\Debug is not 0, show our command line
// in a message box
if (CRegDWORD(_T("Software\\TortoiseGit\\Debug"), FALSE)==TRUE)
AfxMessageBox(AfxGetApp()->m_lpCmdLine, MB_OK | MB_ICONINFORMATION);
if (parser.HasKey(_T("urlhandler")))
{
CString url = parser.GetVal(_T("urlhandler"));
if (url.Find(_T("tgit://clone/")) == 0)
{
url = url.Mid(13); // 21 = "tgit://clone/".GetLength()
}
else if (url.Find(_T("github-windows://openRepo/")) == 0)
{
url = url.Mid(26); // 26 = "github-windows://openRepo/".GetLength()
int questioMark = url.Find('?');
if (questioMark > 0)
url = url.Left(questioMark);
}
else if (url.Find(_T("smartgit://cloneRepo/")) == 0)
{
url = url.Mid(21); // 21 = "smartgit://cloneRepo/".GetLength()
}
else
{
CMessageBox::Show(NULL, IDS_ERR_INVALIDPATH, IDS_APPNAME, MB_ICONERROR);
return FALSE;
}
CString newCmd;
newCmd.Format(_T("/command:clone /url:\"%s\" /hasurlhandler"), url);
parser = CCmdLineParser(newCmd);
}
if ( parser.HasKey(_T("path")) && parser.HasKey(_T("pathfile")))
{
CMessageBox::Show(NULL, IDS_ERR_INVALIDPATH, IDS_APPNAME, MB_ICONERROR);
return FALSE;
}
CTGitPath cmdLinePath;
CTGitPathList pathList;
if (g_sGroupingUUID.IsEmpty())
g_sGroupingUUID = parser.GetVal(L"groupuuid");
if ( parser.HasKey(_T("pathfile")) )
{
CString sPathfileArgument = CPathUtils::GetLongPathname(parser.GetVal(_T("pathfile")));
cmdLinePath.SetFromUnknown(sPathfileArgument);
if (pathList.LoadFromFile(cmdLinePath)==false)
return FALSE; // no path specified!
if ( parser.HasKey(_T("deletepathfile")) )
{
// We can delete the temporary path file, now that we've loaded it
::DeleteFile(cmdLinePath.GetWinPath());
}
// This was a path to a temporary file - it's got no meaning now, and
// anybody who uses it again is in for a problem...
cmdLinePath.Reset();
}
else
{
CString sPathArgument = CPathUtils::GetLongPathname(parser.GetVal(_T("path")));
if (parser.HasKey(_T("expaths")))
{
// an /expaths param means we're started via the buttons in our Win7 library
// and that means the value of /expaths is the current directory, and
// the selected paths are then added as additional parameters but without a key, only a value
// because of the "strange treatment of quotation marks and backslashes by CommandLineToArgvW"
// we have to escape the backslashes first. Since we're only dealing with paths here, that's
// a save bet.
// Without this, a command line like:
// /command:commit /expaths:"D:\" "D:\Utils"
// would fail because the "D:\" is treated as the backslash being the escape char for the quotation
// mark and we'd end up with:
// argv[1] = /command:commit
// argv[2] = /expaths:D:" D:\Utils
// See here for more details: http://blogs.msdn.com/b/oldnewthing/archive/2010/09/17/10063629.aspx
CString cmdLine = GetCommandLineW();
cmdLine.Replace(L"\\", L"\\\\");
int nArgs = 0;
LPWSTR *szArglist = CommandLineToArgvW(cmdLine, &nArgs);
if (szArglist)
{
// argument 0 is the process path, so start with 1
for (int i = 1; i < nArgs; ++i)
{
if (szArglist[i][0] != '/')
{
if (!sPathArgument.IsEmpty())
sPathArgument += '*';
sPathArgument += szArglist[i];
}
}
sPathArgument.Replace(L"\\\\", L"\\");
}
LocalFree(szArglist);
}
if (sPathArgument.IsEmpty() && parser.HasKey(L"path"))
{
CMessageBox::Show(hWndExplorer, IDS_ERR_INVALIDPATH, IDS_APPNAME, MB_ICONERROR);
return FALSE;
}
int asterisk = sPathArgument.Find('*');
cmdLinePath.SetFromUnknown(asterisk >= 0 ? sPathArgument.Left(asterisk) : sPathArgument);
pathList.LoadFromAsteriskSeparatedString(sPathArgument);
}
if (pathList.IsEmpty()) {
pathList.AddPath(CTGitPath::CTGitPath(g_Git.m_CurrentDir));
}
// Set CWD to temporary dir, and restore it later
{
DWORD len = GetCurrentDirectory(0, NULL);
if (len)
{
std::unique_ptr<TCHAR[]> originalCurrentDirectory(new TCHAR[len]);
if (GetCurrentDirectory(len, originalCurrentDirectory.get()))
{
sOrigCWD = originalCurrentDirectory.get();
sOrigCWD = CPathUtils::GetLongPathname(sOrigCWD);
}
}
TCHAR pathbuf[MAX_PATH] = {0};
GetTortoiseGitTempPath(MAX_PATH, pathbuf);
SetCurrentDirectory(pathbuf);
}
CheckForNewerVersion();
CAutoGeneralHandle TGitMutex = ::CreateMutex(NULL, FALSE, _T("TortoiseGitProc.exe"));
if (!g_Git.SetCurrentDir(cmdLinePath.GetWinPathString(), parser.HasKey(_T("submodule")) == TRUE))
{
for (int i = 0; i < pathList.GetCount(); ++i)
if(g_Git.SetCurrentDir(pathList[i].GetWinPath()))
break;
}
if(!g_Git.m_CurrentDir.IsEmpty())
{
sOrigCWD = g_Git.m_CurrentDir;
SetCurrentDirectory(g_Git.m_CurrentDir);
}
if (g_sGroupingUUID.IsEmpty())
{
CRegStdDWORD groupSetting = CRegStdDWORD(_T("Software\\TortoiseGit\\GroupTaskbarIconsPerRepo"), 3);
switch (DWORD(groupSetting))
{
case 1:
case 2:
// implemented differently to TortoiseSVN atm
break;
case 3:
case 4:
{
CString wcroot;
if (g_GitAdminDir.HasAdminDir(g_Git.m_CurrentDir, true, &wcroot))
{
git_oid oid;
CStringA wcRootA(wcroot + CPathUtils::GetAppDirectory());
if (!git_odb_hash(&oid, wcRootA, wcRootA.GetLength(), GIT_OBJ_BLOB))
{
CStringA hash;
git_oid_tostr(hash.GetBufferSetLength(GIT_OID_HEXSZ + 1), GIT_OID_HEXSZ + 1, &oid);
hash.ReleaseBuffer();
g_sGroupingUUID = hash;
}
ProjectProperties pp;
pp.ReadProps();
CString icon = pp.sIcon;
icon.Replace('/', '\\');
if (icon.IsEmpty())
g_bGroupingRemoveIcon = true;
g_sGroupingIcon = icon;
}
}
}
}
CString sAppID = GetTaskIDPerUUID(g_sGroupingUUID).c_str();
InitializeJumpList(sAppID);
EnsureGitLibrary(false);
{
CString err;
try
{
// requires CWD to be set
CGit::m_LogEncode = CAppUtils::GetLogOutputEncode();
// make sure all config files are read in order to check that none contains an error
g_Git.GetConfigValue(_T("doesnot.exist"));
}
catch (char* msg)
{
err = CString(msg);
}
if (!err.IsEmpty())
{
UINT choice = CMessageBox::Show(hWndExplorer, err, _T("TortoiseGit"), 1, IDI_ERROR, CString(MAKEINTRESOURCE(IDS_PROC_EDITLOCALGITCONFIG)), CString(MAKEINTRESOURCE(IDS_PROC_EDITGLOBALGITCONFIG)), CString(MAKEINTRESOURCE(IDS_ABORTBUTTON)));
if (choice == 1)
{
// open the config file with alternative editor
CAppUtils::LaunchAlternativeEditor(g_Git.GetGitLocalConfig());
}
else if (choice == 2)
{
// open the global config file with alternative editor
CAppUtils::LaunchAlternativeEditor(g_Git.GetGitGlobalConfig());
}
return FALSE;
}
}
// execute the requested command
CommandServer server;
Command * cmd = server.GetCommand(parser.GetVal(_T("command")));
if (cmd)
{
cmd->SetExplorerHwnd(hWndExplorer);
cmd->SetParser(parser);
cmd->SetPaths(pathList, cmdLinePath);
retSuccess = cmd->Execute();
delete cmd;
}
// Look for temporary files left around by TortoiseSVN and
// remove them. But only delete 'old' files because some
// apps might still be needing the recent ones.
{
DWORD len = GetTortoiseGitTempPath(0, NULL);
std::unique_ptr<TCHAR[]> path(new TCHAR[len + 100]);
len = GetTortoiseGitTempPath (len + 100, path.get());
if (len != 0)
{
CDirFileEnum finder(path.get());
FILETIME systime_;
::GetSystemTimeAsFileTime(&systime_);
__int64 systime = (((_int64)systime_.dwHighDateTime)<<32) | ((__int64)systime_.dwLowDateTime);
bool isDir;
CString filepath;
while (finder.NextFile(filepath, &isDir))
{
HANDLE hFile = ::CreateFile(filepath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, isDir ? FILE_FLAG_BACKUP_SEMANTICS : NULL, NULL);
if (hFile != INVALID_HANDLE_VALUE)
{
FILETIME createtime_;
if (::GetFileTime(hFile, &createtime_, NULL, NULL))
{
::CloseHandle(hFile);
__int64 createtime = (((_int64)createtime_.dwHighDateTime)<<32) | ((__int64)createtime_.dwLowDateTime);
if ((createtime + 864000000000) < systime) //only delete files older than a day
{
::SetFileAttributes(filepath, FILE_ATTRIBUTE_NORMAL);
if (isDir)
::RemoveDirectory(filepath);
else
::DeleteFile(filepath);
}
}
else
::CloseHandle(hFile);
}
}
}
}
// Since the dialog has been closed, return FALSE so that we exit the
// application, rather than start the application's message pump.
return FALSE;
}
