?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Can sort tags in reversed order because newer versions are more useful
[TortoiseGit.git] / src / Git / Git.cpp
blob2d1961b023653eac4e5cc599cebe8ba64ad636c1
1 // TortoiseGit - a Windows shell extension for easy version control
2
3 // Copyright (C) 2008-2014 - TortoiseGit
4
5 // This program is free software; you can redistribute it and/or
6 // modify it under the terms of the GNU General Public License
7 // as published by the Free Software Foundation; either version 2
8 // of the License, or (at your option) any later version.
9
10 // This program is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 // GNU General Public License for more details.
14
15 // You should have received a copy of the GNU General Public License
16 // along with this program; if not, write to the Free Software Foundation,
17 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 //
19
20 #include "stdafx.h"
21 #include "Git.h"
22 #include "GitRev.h"
23 #include "registry.h"
24 #include "GitForWindows.h"
25 #include <map>
26 #include "UnicodeUtils.h"
27 #include "gitdll.h"
28 #include <fstream>
29 #include "FormatMessageWrapper.h"
30 #include "SmartHandle.h"
31
32 int CGit::m_LogEncode=CP_UTF8;
33 typedef CComCritSecLock<CComCriticalSection> CAutoLocker;
34
35 static LPTSTR nextpath(wchar_t *path, wchar_t *buf, size_t buflen)
36 {
37 wchar_t term, *base = path;
38
39 if (path == NULL || buf == NULL || buflen == 0)
40 return NULL;
41
42 term = (*path == L'"') ? *path++ : L';';
43
44 for (buflen--; *path && *path != term && buflen; buflen--)
45 *buf++ = *path++;
46
47 *buf = L'\0'; /* reserved a byte via initial subtract */
48
49 while (*path == term || *path == L';')
50 ++path;
51
52 return (path != base) ? path : NULL;
53 }
54
55 static inline BOOL FileExists(LPCTSTR lpszFileName)
56 {
57 struct _stat st;
58 return _tstat(lpszFileName, &st) == 0;
59 }
60
61 static BOOL FindGitPath()
62 {
63 size_t size;
64 _tgetenv_s(&size, NULL, 0, _T("PATH"));
65
66 if (!size)
67 {
68 return FALSE;
69 }
70
71 TCHAR *env = (TCHAR*)alloca(size * sizeof(TCHAR));
72 _tgetenv_s(&size, env, size, _T("PATH"));
73
74 TCHAR buf[MAX_PATH] = {0};
75
76 // search in all paths defined in PATH
77 while ((env = nextpath(env, buf, MAX_PATH - 1)) != NULL && *buf)
78 {
79 TCHAR *pfin = buf + _tcslen(buf)-1;
80
81 // ensure trailing slash
82 if (*pfin != _T('/') && *pfin != _T('\\'))
83 _tcscpy_s(++pfin, 2, _T("\\")); // we have enough space left, MAX_PATH-1 is used in nextpath above
84
85 const size_t len = _tcslen(buf);
86
87 if ((len + 7) < MAX_PATH)
88 _tcscpy_s(pfin + 1, MAX_PATH - len, _T("git.exe"));
89 else
90 break;
91
92 if ( FileExists(buf) )
93 {
94 // dir found
95 pfin[1] = 0;
96 CGit::ms_LastMsysGitDir = buf;
97 CGit::ms_LastMsysGitDir.TrimRight(_T("\\"));
98 if (CGit::ms_LastMsysGitDir.GetLength() > 4)
99 {
100 // often the msysgit\cmd folder is on the %PATH%, but
101 // that git.exe does not work, so try to guess the bin folder
102 CString binDir = CGit::ms_LastMsysGitDir.Mid(0, CGit::ms_LastMsysGitDir.GetLength() - 4) + _T("\\bin\\git.exe");
103 if (FileExists(binDir))
104 CGit::ms_LastMsysGitDir = CGit::ms_LastMsysGitDir.Mid(0, CGit::ms_LastMsysGitDir.GetLength() - 4) + _T("\\bin");
105 }
106 return TRUE;
107 }
108 }
109
110 return FALSE;
111 }
112
113 static bool g_bSortLogical;
114 static bool g_bSortLocalBranchesFirst;
115 static bool g_bSortTagsReversed;
116
117 static void GetSortOptions()
118 {
119 g_bSortLogical = !CRegDWORD(L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer\\NoStrCmpLogical", 0, false, HKEY_CURRENT_USER);
120 if (g_bSortLogical)
121 g_bSortLogical = !CRegDWORD(L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer\\NoStrCmpLogical", 0, false, HKEY_LOCAL_MACHINE);
122 g_bSortLocalBranchesFirst = !CRegDWORD(L"Software\\TortoiseGit\\NoSortLocalBranchesFirst", 0, false, HKEY_CURRENT_USER);
123 if (g_bSortLocalBranchesFirst)
124 g_bSortLocalBranchesFirst = !CRegDWORD(L"Software\\TortoiseGit\\NoSortLocalBranchesFirst", 0, false, HKEY_LOCAL_MACHINE);
125 g_bSortTagsReversed = !!CRegDWORD(L"Software\\TortoiseGit\\SortTagsReversed", 0, false, HKEY_LOCAL_MACHINE);
126 if (!g_bSortTagsReversed)
127 g_bSortTagsReversed = !!CRegDWORD(L"Software\\TortoiseGit\\SortTagsReversed", 0, false, HKEY_CURRENT_USER);
128 }
129
130 static int LogicalComparePredicate(const CString &left, const CString &right)
131 {
132 if (g_bSortLogical)
133 return StrCmpLogicalW(left, right) < 0;
134 return StrCmpI(left, right) < 0;
135 }
136
137 static int LogicalCompareReversedPredicate(const CString &left, const CString &right)
138 {
139 if (g_bSortLogical)
140 return StrCmpLogicalW(left, right) > 0;
141 return StrCmpI(left, right) > 0;
142 }
143
144 static int LogicalCompareBranchesPredicate(const CString &left, const CString &right)
145 {
146 if (g_bSortLocalBranchesFirst)
147 {
148 int leftIsRemote = left.Find(_T("remotes/"));
149 int rightIsRemote = right.Find(_T("remotes/"));
150
151 if (leftIsRemote == 0 && rightIsRemote < 0)
152 return false;
153 else if (leftIsRemote < 0 && rightIsRemote == 0)
154 return true;
155 }
156 if (g_bSortLogical)
157 return StrCmpLogicalW(left, right) < 0;
158 return StrCmpI(left, right) < 0;
159 }
160
161 #define CALL_OUTPUT_READ_CHUNK_SIZE 1024
162
163 CString CGit::ms_LastMsysGitDir;
164 int CGit::ms_LastMsysGitVersion = 0;
165 CGit g_Git;
166
167
168 CGit::CGit(void)
169 {
170 GetCurrentDirectory(MAX_PATH, m_CurrentDir.GetBuffer(MAX_PATH));
171 m_CurrentDir.ReleaseBuffer();
172 m_IsGitDllInited = false;
173 m_GitDiff=0;
174 m_GitSimpleListDiff=0;
175 m_IsUseGitDLL = !!CRegDWORD(_T("Software\\TortoiseGit\\UsingGitDLL"),1);
176 m_IsUseLibGit2 = !!CRegDWORD(_T("Software\\TortoiseGit\\UseLibgit2"), TRUE);
177 m_IsUseLibGit2_mask = CRegDWORD(_T("Software\\TortoiseGit\\UseLibgit2_mask"), (1 << GIT_CMD_MERGE_BASE) | (1 << GIT_CMD_DELETETAGBRANCH) | (1 << GIT_CMD_GETONEFILE));
178
179 SecureZeroMemory(&m_CurrentGitPi, sizeof(PROCESS_INFORMATION));
180
181 GetSortOptions();
182 this->m_bInitialized =false;
183 CheckMsysGitDir();
184 m_critGitDllSec.Init();
185 }
186
187 CGit::~CGit(void)
188 {
189 if(this->m_GitDiff)
190 {
191 git_close_diff(m_GitDiff);
192 m_GitDiff=0;
193 }
194 if(this->m_GitSimpleListDiff)
195 {
196 git_close_diff(m_GitSimpleListDiff);
197 m_GitSimpleListDiff=0;
198 }
199 }
200
201 bool CGit::IsBranchNameValid(const CString& branchname)
202 {
203 if (branchname.Left(1) == _T("-")) // branch names starting with a dash are discouraged when used with git.exe, see https://github.com/git/git/commit/6348624010888bd2353e5cebdc2b5329490b0f6d
204 return false;
205 if (branchname.FindOneOf(_T("\"|<>")) >= 0) // not valid on Windows
206 return false;
207 CStringA branchA = CUnicodeUtils::GetUTF8(_T("refs/heads/") + branchname);
208 return !!git_reference_is_valid_name(branchA);
209 }
210
211 int CGit::RunAsync(CString cmd, PROCESS_INFORMATION *piOut, HANDLE *hReadOut, HANDLE *hErrReadOut, CString *StdioFile)
212 {
213 SECURITY_ATTRIBUTES sa;
214 CAutoGeneralHandle hRead, hWrite, hReadErr, hWriteErr;
215 CAutoGeneralHandle hStdioFile;
216
217 sa.nLength = sizeof(SECURITY_ATTRIBUTES);
218 sa.lpSecurityDescriptor=NULL;
219 sa.bInheritHandle=TRUE;
220 if (!CreatePipe(hRead.GetPointer(), hWrite.GetPointer(), &sa, 0))
221 {
222 CString err = CFormatMessageWrapper();
223 CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": could not open stdout pipe: %s\n"), err.Trim());
224 return TGIT_GIT_ERROR_OPEN_PIP;
225 }
226 if (hErrReadOut && !CreatePipe(hReadErr.GetPointer(), hWriteErr.GetPointer(), &sa, 0))
227 {
228 CString err = CFormatMessageWrapper();
229 CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": could not open stderr pipe: %s\n"), err.Trim());
230 return TGIT_GIT_ERROR_OPEN_PIP;
231 }
232
233 if(StdioFile)
234 {
235 hStdioFile=CreateFile(*StdioFile,GENERIC_WRITE,FILE_SHARE_READ | FILE_SHARE_WRITE,
236 &sa,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
237 }
238
239 STARTUPINFO si;
240 PROCESS_INFORMATION pi;
241 si.cb=sizeof(STARTUPINFO);
242 GetStartupInfo(&si);
243
244 if (hErrReadOut)
245 si.hStdError = hWriteErr;
246 else
247 si.hStdError = hWrite;
248 if(StdioFile)
249 si.hStdOutput=hStdioFile;
250 else
251 si.hStdOutput=hWrite;
252
253 si.wShowWindow=SW_HIDE;
254 si.dwFlags=STARTF_USESTDHANDLES|STARTF_USESHOWWINDOW;
255
256 LPTSTR pEnv = (!m_Environment.empty()) ? &m_Environment[0]: NULL;
257 DWORD dwFlags = pEnv ? CREATE_UNICODE_ENVIRONMENT : 0;
258
259 // CREATE_NEW_CONSOLE makes ssh recognize that it has no console in order to launch askpass to ask for the password.
260 // DETACHED_PROCESS which was originally used here has the same effect, however, it prevents PowerShell from working (cf. issue #2143)
261 dwFlags |= CREATE_NEW_PROCESS_GROUP | CREATE_NEW_CONSOLE;
262
263 memset(&this->m_CurrentGitPi,0,sizeof(PROCESS_INFORMATION));
264 memset(&pi, 0, sizeof(PROCESS_INFORMATION));
265
266 if(cmd.Find(_T("git")) == 0)
267 {
268 int firstSpace = cmd.Find(_T(" "));
269 if (firstSpace > 0)
270 cmd = _T('"')+CGit::ms_LastMsysGitDir+_T("\\")+ cmd.Left(firstSpace) + _T('"')+ cmd.Mid(firstSpace);
271 else
272 cmd=_T('"')+CGit::ms_LastMsysGitDir+_T("\\")+cmd+_T('"');
273 }
274
275 CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": executing %s\n"), cmd);
276 if(!CreateProcess(NULL,(LPWSTR)cmd.GetString(), NULL,NULL,TRUE,dwFlags,pEnv,(LPWSTR)m_CurrentDir.GetString(),&si,&pi))
277 {
278 CString err = CFormatMessageWrapper();
279 CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": error while executing command: %s\n"), err.Trim());
280 return TGIT_GIT_ERROR_CREATE_PROCESS;
281 }
282
283 m_CurrentGitPi = pi;
284
285 if(piOut)
286 *piOut=pi;
287 if(hReadOut)
288 *hReadOut = hRead.Detach();
289 if(hErrReadOut)
290 *hErrReadOut = hReadErr.Detach();
291 return 0;
292
293 }
294 //Must use sperate function to convert ANSI str to union code string
295 //Becuase A2W use stack as internal convert buffer.
296 void CGit::StringAppend(CString *str, const BYTE *p, int code,int length)
297 {
298 if(str == NULL)
299 return ;
300
301 int len ;
302 if(length<0)
303 len = (int)strlen((const char*)p);
304 else
305 len=length;
306 if (len == 0)
307 return;
308 int currentContentLen = str->GetLength();
309 WCHAR * buf = str->GetBuffer(len * 4 + 1 + currentContentLen) + currentContentLen;
310 int appendedLen = MultiByteToWideChar(code, 0, (LPCSTR)p, len, buf, len * 4);
311 str->ReleaseBuffer(currentContentLen + appendedLen); // no - 1 because MultiByteToWideChar is called with a fixed length (thus no nul char included)
312 }
313
314 // This method was originally used to check for orphaned branches
315 BOOL CGit::CanParseRev(CString ref)
316 {
317 if (ref.IsEmpty())
318 ref = _T("HEAD");
319
320 CString cmdout;
321 if (Run(_T("git.exe rev-parse --revs-only ") + ref, &cmdout, CP_UTF8))
322 {
323 return FALSE;
324 }
325 if(cmdout.IsEmpty())
326 return FALSE;
327
328 return TRUE;
329 }
330
331 // Checks if we have an orphaned HEAD
332 BOOL CGit::IsInitRepos()
333 {
334 CGitHash hash;
335 // handle error on reading HEAD hash as init repo
336 if (GetHash(hash, _T("HEAD")) != 0)
337 return TRUE;
338 return hash.IsEmpty() ? TRUE : FALSE;
339 }
340
341 DWORD WINAPI CGit::AsyncReadStdErrThread(LPVOID lpParam)
342 {
343 PASYNCREADSTDERRTHREADARGS pDataArray;
344 pDataArray = (PASYNCREADSTDERRTHREADARGS)lpParam;
345
346 DWORD readnumber;
347 BYTE data[CALL_OUTPUT_READ_CHUNK_SIZE];
348 while (ReadFile(pDataArray->fileHandle, data, CALL_OUTPUT_READ_CHUNK_SIZE, &readnumber, NULL))
349 {
350 if (pDataArray->pcall->OnOutputErrData(data,readnumber))
351 break;
352 }
353
354 return 0;
355 }
356
357 int CGit::Run(CGitCall* pcall)
358 {
359 PROCESS_INFORMATION pi;
360 CAutoGeneralHandle hRead, hReadErr;
361 if (RunAsync(pcall->GetCmd(), &pi, hRead.GetPointer(), hReadErr.GetPointer()))
362 return TGIT_GIT_ERROR_CREATE_PROCESS;
363
364 CAutoGeneralHandle piThread(pi.hThread);
365 CAutoGeneralHandle piProcess(pi.hProcess);
366
367 ASYNCREADSTDERRTHREADARGS threadArguments;
368 threadArguments.fileHandle = hReadErr;
369 threadArguments.pcall = pcall;
370 CAutoGeneralHandle thread = CreateThread(NULL, 0, AsyncReadStdErrThread, &threadArguments, 0, NULL);
371
372 DWORD readnumber;
373 BYTE data[CALL_OUTPUT_READ_CHUNK_SIZE];
374 bool bAborted=false;
375 while(ReadFile(hRead,data,CALL_OUTPUT_READ_CHUNK_SIZE,&readnumber,NULL))
376 {
377 // TODO: when OnOutputData() returns 'true', abort git-command. Send CTRL-C signal?
378 if(!bAborted)//For now, flush output when command aborted.
379 if(pcall->OnOutputData(data,readnumber))
380 bAborted=true;
381 }
382 if(!bAborted)
383 pcall->OnEnd();
384
385 if (thread)
386 WaitForSingleObject(thread, INFINITE);
387
388 WaitForSingleObject(pi.hProcess, INFINITE);
389 DWORD exitcode =0;
390
391 if(!GetExitCodeProcess(pi.hProcess,&exitcode))
392 {
393 CString err = CFormatMessageWrapper();
394 CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": could not get exit code: %s\n"), err.Trim());
395 return TGIT_GIT_ERROR_GET_EXIT_CODE;
396 }
397 else
398 CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": process exited: %d\n"), exitcode);
399
400 return exitcode;
401 }
402 class CGitCall_ByteVector : public CGitCall
403 {
404 public:
405 CGitCall_ByteVector(CString cmd,BYTE_VECTOR* pvector, BYTE_VECTOR* pvectorErr = NULL):CGitCall(cmd),m_pvector(pvector),m_pvectorErr(pvectorErr){}
406 virtual bool OnOutputData(const BYTE* data, size_t size)
407 {
408 if (!m_pvector || size == 0)
409 return false;
410 size_t oldsize=m_pvector->size();
411 m_pvector->resize(m_pvector->size()+size);
412 memcpy(&*(m_pvector->begin()+oldsize),data,size);
413 return false;
414 }
415 virtual bool OnOutputErrData(const BYTE* data, size_t size)
416 {
417 if (!m_pvectorErr || size == 0)
418 return false;
419 size_t oldsize = m_pvectorErr->size();
420 m_pvectorErr->resize(m_pvectorErr->size() + size);
421 memcpy(&*(m_pvectorErr->begin() + oldsize), data, size);
422 return false;
423 }
424 BYTE_VECTOR* m_pvector;
425 BYTE_VECTOR* m_pvectorErr;
426
427 };
428 int CGit::Run(CString cmd,BYTE_VECTOR *vector, BYTE_VECTOR *vectorErr)
429 {
430 CGitCall_ByteVector call(cmd, vector, vectorErr);
431 return Run(&call);
432 }
433 int CGit::Run(CString cmd, CString* output, int code)
434 {
435 CString err;
436 int ret;
437 ret = Run(cmd, output, &err, code);
438
439 if (output && !err.IsEmpty())
440 {
441 if (!output->IsEmpty())
442 *output += _T("\n");
443 *output += err;
444 }
445
446 return ret;
447 }
448 int CGit::Run(CString cmd, CString* output, CString* outputErr, int code)
449 {
450 BYTE_VECTOR vector, vectorErr;
451 int ret;
452 if (outputErr)
453 ret = Run(cmd, &vector, &vectorErr);
454 else
455 ret = Run(cmd, &vector);
456
457 vector.push_back(0);
458 StringAppend(output, &(vector[0]), code);
459
460 if (outputErr)
461 {
462 vectorErr.push_back(0);
463 StringAppend(outputErr, &(vectorErr[0]), code);
464 }
465
466 return ret;
467 }
468
469 class CGitCallCb : public CGitCall
470 {
471 public:
472 CGitCallCb(CString cmd, const GitReceiverFunc& recv): CGitCall(cmd), m_recv(recv) {}
473
474 virtual bool OnOutputData(const BYTE* data, size_t size) override
475 {
476 // Add data
477 if (size == 0)
478 return false;
479 int oldEndPos = m_buffer.GetLength();
480 memcpy(m_buffer.GetBufferSetLength(oldEndPos + (int)size) + oldEndPos, data, size);
481 m_buffer.ReleaseBuffer(oldEndPos + (int)size);
482
483 // Break into lines and feed to m_recv
484 int eolPos;
485 while ((eolPos = m_buffer.Find('\n')) >= 0)
486 {
487 m_recv(m_buffer.Left(eolPos));
488 m_buffer = m_buffer.Mid(eolPos + 1);
489 }
490 return false;
491 }
492
493 virtual bool OnOutputErrData(const BYTE*, size_t) override
494 {
495 return false; // Ignore error output for now
496 }
497
498 virtual void OnEnd() override
499 {
500 if (!m_buffer.IsEmpty())
501 m_recv(m_buffer);
502 m_buffer.Empty(); // Just for sure
503 }
504
505 private:
506 GitReceiverFunc m_recv;
507 CStringA m_buffer;
508 };
509
510 int CGit::Run(CString cmd, const GitReceiverFunc& recv)
511 {
512 CGitCallCb call(cmd, recv);
513 return Run(&call);
514 }
515
516 CString CGit::GetUserName(void)
517 {
518 CEnvironment env;
519 env.CopyProcessEnvironment();
520 CString envname = env.GetEnv(_T("GIT_AUTHOR_NAME"));
521 if (!envname.IsEmpty())
522 return envname;
523 return GetConfigValue(L"user.name");
524 }
525 CString CGit::GetUserEmail(void)
526 {
527 CEnvironment env;
528 env.CopyProcessEnvironment();
529 CString envmail = env.GetEnv(_T("GIT_AUTHOR_EMAIL"));
530 if (!envmail.IsEmpty())
531 return envmail;
532
533 return GetConfigValue(L"user.email");
534 }
535
536 CString CGit::GetConfigValue(const CString& name)
537 {
538 CString configValue;
539 int start = 0;
540 if(this->m_IsUseGitDLL)
541 {
542 CAutoLocker lock(g_Git.m_critGitDllSec);
543
544 try
545 {
546 CheckAndInitDll();
547 }catch(...)
548 {
549 }
550 CStringA key, value;
551 key = CUnicodeUtils::GetUTF8(name);
552
553 try
554 {
555 if (git_get_config(key, value.GetBufferSetLength(4096), 4096))
556 return CString();
557 }
558 catch (const char *msg)
559 {
560 ::MessageBox(NULL, _T("Could not get config.\nlibgit reports:\n") + CString(msg), _T("TortoiseGit"), MB_OK | MB_ICONERROR);
561 return CString();
562 }
563
564 StringAppend(&configValue, (BYTE*)(LPCSTR)value);
565 return configValue.Tokenize(_T("\n"),start);
566 }
567 else
568 {
569 CString cmd;
570 cmd.Format(L"git.exe config %s", name);
571 Run(cmd, &configValue, nullptr, CP_UTF8);
572 return configValue.Tokenize(_T("\n"),start);
573 }
574 }
575
576 bool CGit::GetConfigValueBool(const CString& name)
577 {
578 CString configValue = GetConfigValue(name);
579 configValue.MakeLower();
580 configValue.Trim();
581 if(configValue == _T("true") || configValue == _T("on") || configValue == _T("yes") || StrToInt(configValue) != 0)
582 return true;
583 else
584 return false;
585 }
586
587 int CGit::SetConfigValue(const CString& key, const CString& value, CONFIG_TYPE type)
588 {
589 if(this->m_IsUseGitDLL)
590 {
591 CAutoLocker lock(g_Git.m_critGitDllSec);
592
593 try
594 {
595 CheckAndInitDll();
596
597 }catch(...)
598 {
599 }
600 CStringA keya, valuea;
601 keya = CUnicodeUtils::GetMulti(key, CP_UTF8);
602 valuea = CUnicodeUtils::GetUTF8(value);
603
604 try
605 {
606 return [=]() { return get_set_config(keya, valuea, type); }();
607 }
608 catch (const char *msg)
609 {
610 ::MessageBox(NULL, _T("Could not set config.\nlibgit reports:\n") + CString(msg), _T("TortoiseGit"), MB_OK | MB_ICONERROR);
611 return -1;
612 }
613 }
614 else
615 {
616 CString cmd;
617 CString option;
618 switch(type)
619 {
620 case CONFIG_GLOBAL:
621 option = _T("--global");
622 break;
623 case CONFIG_SYSTEM:
624 option = _T("--system");
625 break;
626 default:
627 break;
628 }
629 cmd.Format(_T("git.exe config %s %s \"%s\""), option, key, value);
630 CString out;
631 if (Run(cmd, &out, nullptr, CP_UTF8))
632 {
633 return -1;
634 }
635 }
636 return 0;
637 }
638
639 int CGit::UnsetConfigValue(const CString& key, CONFIG_TYPE type)
640 {
641 if(this->m_IsUseGitDLL)
642 {
643 CAutoLocker lock(g_Git.m_critGitDllSec);
644
645 try
646 {
647 CheckAndInitDll();
648 }catch(...)
649 {
650 }
651 CStringA keya;
652 keya = CUnicodeUtils::GetMulti(key, CP_UTF8);
653
654 try
655 {
656 return [=]() { return get_set_config(keya, nullptr, type); }();
657 }
658 catch (const char *msg)
659 {
660 ::MessageBox(NULL, _T("Could not unset config.\nlibgit reports:\n") + CString(msg), _T("TortoiseGit"), MB_OK | MB_ICONERROR);
661 return -1;
662 }
663 }
664 else
665 {
666 CString cmd;
667 CString option;
668 switch(type)
669 {
670 case CONFIG_GLOBAL:
671 option = _T("--global");
672 break;
673 case CONFIG_SYSTEM:
674 option = _T("--system");
675 break;
676 default:
677 break;
678 }
679 cmd.Format(_T("git.exe config %s --unset %s"), option, key);
680 CString out;
681 if (Run(cmd, &out, nullptr, CP_UTF8))
682 {
683 return -1;
684 }
685 }
686 return 0;
687 }
688
689 CString CGit::GetCurrentBranch(bool fallback)
690 {
691 CString output;
692 //Run(_T("git.exe branch"),&branch);
693
694 int result = GetCurrentBranchFromFile(m_CurrentDir, output, fallback);
695 if (result != 0 && ((result == 1 && !fallback) || result != 1))
696 {
697 return _T("(no branch)");
698 }
699 else
700 return output;
701
702 }
703
704 void CGit::GetRemoteTrackedBranch(const CString& localBranch, CString& pullRemote, CString& pullBranch)
705 {
706 if (localBranch.IsEmpty())
707 return;
708
709 CString configName;
710 configName.Format(L"branch.%s.remote", localBranch);
711 pullRemote = GetConfigValue(configName);
712
713 //Select pull-branch from current branch
714 configName.Format(L"branch.%s.merge", localBranch);
715 pullBranch = StripRefName(GetConfigValue(configName));
716 }
717
718 void CGit::GetRemoteTrackedBranchForHEAD(CString& remote, CString& branch)
719 {
720 CString refName;
721 if (GetCurrentBranchFromFile(m_CurrentDir, refName))
722 return;
723 GetRemoteTrackedBranch(StripRefName(refName), remote, branch);
724 }
725
726 CString CGit::GetFullRefName(const CString& shortRefName)
727 {
728 CString refName;
729 CString cmd;
730 cmd.Format(L"git.exe rev-parse --symbolic-full-name %s", shortRefName);
731 if (Run(cmd, &refName, NULL, CP_UTF8) != 0)
732 return CString();//Error
733 int iStart = 0;
734 return refName.Tokenize(L"\n", iStart);
735 }
736
737 CString CGit::StripRefName(CString refName)
738 {
739 if(wcsncmp(refName, L"refs/heads/", 11) == 0)
740 refName = refName.Mid(11);
741 else if(wcsncmp(refName, L"refs/", 5) == 0)
742 refName = refName.Mid(5);
743 int start =0;
744 return refName.Tokenize(_T("\n"),start);
745 }
746
747 int CGit::GetCurrentBranchFromFile(const CString &sProjectRoot, CString &sBranchOut, bool fallback)
748 {
749 // read current branch name like git-gui does, by parsing the .git/HEAD file directly
750
751 if ( sProjectRoot.IsEmpty() )
752 return -1;
753
754 CString sDotGitPath;
755 if (!g_GitAdminDir.GetAdminDirPath(sProjectRoot, sDotGitPath))
756 return -1;
757
758 CString sHeadFile = sDotGitPath + _T("HEAD");
759
760 FILE *pFile;
761 _tfopen_s(&pFile, sHeadFile.GetString(), _T("r"));
762
763 if (!pFile)
764 {
765 return -1;
766 }
767
768 char s[256] = {0};
769 fgets(s, sizeof(s), pFile);
770
771 fclose(pFile);
772
773 const char *pfx = "ref: refs/heads/";
774 const int len = 16;//strlen(pfx)
775
776 if ( !strncmp(s, pfx, len) )
777 {
778 //# We're on a branch. It might not exist. But
779 //# HEAD looks good enough to be a branch.
780 CStringA utf8Branch(s + len);
781 sBranchOut = CUnicodeUtils::GetUnicode(utf8Branch);
782 sBranchOut.TrimRight(_T(" \r\n\t"));
783
784 if ( sBranchOut.IsEmpty() )
785 return -1;
786 }
787 else if (fallback)
788 {
789 CStringA utf8Hash(s);
790 CString unicodeHash = CUnicodeUtils::GetUnicode(utf8Hash);
791 unicodeHash.TrimRight(_T(" \r\n\t"));
792 if (CGitHash::IsValidSHA1(unicodeHash))
793 sBranchOut = unicodeHash;
794 else
795 //# Assume this is a detached head.
796 sBranchOut = _T("HEAD");
797 return 1;
798 }
799 else
800 {
801 //# Assume this is a detached head.
802 sBranchOut = "HEAD";
803
804 return 1;
805 }
806
807 return 0;
808 }
809
810 int CGit::BuildOutputFormat(CString &format,bool IsFull)
811 {
812 CString log;
813 log.Format(_T("#<%c>%%x00"),LOG_REV_ITEM_BEGIN);
814 format += log;
815 if(IsFull)
816 {
817 log.Format(_T("#<%c>%%an%%x00"),LOG_REV_AUTHOR_NAME);
818 format += log;
819 log.Format(_T("#<%c>%%ae%%x00"),LOG_REV_AUTHOR_EMAIL);
820 format += log;
821 log.Format(_T("#<%c>%%ai%%x00"),LOG_REV_AUTHOR_DATE);
822 format += log;
823 log.Format(_T("#<%c>%%cn%%x00"),LOG_REV_COMMIT_NAME);
824 format += log;
825 log.Format(_T("#<%c>%%ce%%x00"),LOG_REV_COMMIT_EMAIL);
826 format += log;
827 log.Format(_T("#<%c>%%ci%%x00"),LOG_REV_COMMIT_DATE);
828 format += log;
829 log.Format(_T("#<%c>%%b%%x00"),LOG_REV_COMMIT_BODY);
830 format += log;
831 }
832
833 log.Format(_T("#<%c>%%m%%H%%x00"),LOG_REV_COMMIT_HASH);
834 format += log;
835 log.Format(_T("#<%c>%%P%%x00"),LOG_REV_COMMIT_PARENT);
836 format += log;
837 log.Format(_T("#<%c>%%s%%x00"),LOG_REV_COMMIT_SUBJECT);
838 format += log;
839
840 if(IsFull)
841 {
842 log.Format(_T("#<%c>%%x00"),LOG_REV_COMMIT_FILE);
843 format += log;
844 }
845 return 0;
846 }
847
848 CString CGit::GetLogCmd(const CString &range, const CTGitPath *path, int count, int mask, bool paramonly,
849 CFilterData *Filter)
850 {
851 CString cmd;
852 CString num;
853 CString since;
854
855 CString file = _T(" --");
856
857 if(path)
858 file.Format(_T(" -- \"%s\""),path->GetGitPathString());
859
860 if(count>0)
861 num.Format(_T("-n%d"),count);
862
863 CString param;
864
865 if(mask& LOG_INFO_STAT )
866 param += _T(" --numstat ");
867 if(mask& LOG_INFO_FILESTATE)
868 param += _T(" --raw ");
869
870 if(mask& LOG_INFO_FULLHISTORY)
871 param += _T(" --full-history ");
872
873 if(mask& LOG_INFO_BOUNDARY)
874 param += _T(" --left-right --boundary ");
875
876 if(mask& CGit::LOG_INFO_ALL_BRANCH)
877 param += _T(" --all ");
878
879 if(mask & CGit::LOG_INFO_LOCAL_BRANCHES)
880 param += _T(" --branches ");
881
882 if(mask& CGit::LOG_INFO_DETECT_COPYRENAME)
883 param += _T(" -C ");
884
885 if(mask& CGit::LOG_INFO_DETECT_RENAME )
886 param += _T(" -M ");
887
888 if(mask& CGit::LOG_INFO_FIRST_PARENT )
889 param += _T(" --first-parent ");
890
891 if(mask& CGit::LOG_INFO_NO_MERGE )
892 param += _T(" --no-merges ");
893
894 if(mask& CGit::LOG_INFO_FOLLOW)
895 param += _T(" --follow ");
896
897 if(mask& CGit::LOG_INFO_SHOW_MERGEDFILE)
898 param += _T(" -c ");
899
900 if(mask& CGit::LOG_INFO_FULL_DIFF)
901 param += _T(" --full-diff ");
902
903 if(mask& CGit::LOG_INFO_SIMPILFY_BY_DECORATION)
904 param += _T(" --simplify-by-decoration ");
905
906 param += range;
907
908 CString st1,st2;
909
910 if( Filter && (Filter->m_From != -1))
911 {
912 st1.Format(_T(" --max-age=%I64u "), Filter->m_From);
913 param += st1;
914 }
915
916 if( Filter && (Filter->m_To != -1))
917 {
918 st2.Format(_T(" --min-age=%I64u "), Filter->m_To);
919 param += st2;
920 }
921
922 bool isgrep = false;
923 if( Filter && (!Filter->m_Author.IsEmpty()))
924 {
925 st1.Format(_T(" --author=\"%s\"" ),Filter->m_Author);
926 param += st1;
927 isgrep = true;
928 }
929
930 if( Filter && (!Filter->m_Committer.IsEmpty()))
931 {
932 st1.Format(_T(" --committer=\"%s\"" ),Filter->m_Author);
933 param += st1;
934 isgrep = true;
935 }
936
937 if( Filter && (!Filter->m_MessageFilter.IsEmpty()))
938 {
939 st1.Format(_T(" --grep=\"%s\"" ),Filter->m_MessageFilter);
940 param += st1;
941 isgrep = true;
942 }
943
944 if(Filter && isgrep)
945 {
946 if(!Filter->m_IsRegex)
947 param += _T(" --fixed-strings ");
948
949 param += _T(" --regexp-ignore-case --extended-regexp ");
950 }
951
952 DWORD logOrderBy = CRegDWORD(_T("Software\\TortoiseGit\\LogOrderBy"), LOG_ORDER_TOPOORDER);
953 if (logOrderBy == LOG_ORDER_TOPOORDER)
954 param += _T(" --topo-order");
955 else if (logOrderBy == LOG_ORDER_DATEORDER)
956 param += _T(" --date-order");
957
958 if(paramonly) //tgit.dll.Git.cpp:setup_revisions() only looks at args[1] and greater. To account for this, pass a dummy parameter in the 0th place
959 cmd.Format(_T("--ignore-this-parameter %s -z %s --parents "), num, param);
960 else
961 {
962 CString log;
963 BuildOutputFormat(log,!(mask&CGit::LOG_INFO_ONLY_HASH));
964 cmd.Format(_T("git.exe log %s -z %s --parents --pretty=format:\"%s\""),
965 num,param,log);
966 }
967
968 cmd += file;
969
970 return cmd;
971 }
972 #define BUFSIZE 512
973 void GetTempPath(CString &path)
974 {
975 TCHAR lpPathBuffer[BUFSIZE] = { 0 };
976 DWORD dwRetVal;
977 DWORD dwBufSize=BUFSIZE;
978 dwRetVal = GetTortoiseGitTempPath(dwBufSize, // length of the buffer
979 lpPathBuffer); // buffer for path
980 if (dwRetVal > dwBufSize || (dwRetVal == 0))
981 {
982 path=_T("");
983 }
984 path.Format(_T("%s"),lpPathBuffer);
985 }
986 CString GetTempFile()
987 {
988 TCHAR lpPathBuffer[BUFSIZE] = { 0 };
989 DWORD dwRetVal;
990 DWORD dwBufSize=BUFSIZE;
991 TCHAR szTempName[BUFSIZE] = { 0 };
992 UINT uRetVal;
993
994 dwRetVal = GetTortoiseGitTempPath(dwBufSize, // length of the buffer
995 lpPathBuffer); // buffer for path
996 if (dwRetVal > dwBufSize || (dwRetVal == 0))
997 {
998 return _T("");
999 }
1000 // Create a temporary file.
1001 uRetVal = GetTempFileName(lpPathBuffer, // directory for tmp files
1002 TEXT("Patch"), // temp file name prefix
1003 0, // create unique name
1004 szTempName); // buffer for name
1005
1006
1007 if (uRetVal == 0)
1008 {
1009 return _T("");
1010 }
1011
1012 return CString(szTempName);
1013
1014 }
1015
1016 DWORD GetTortoiseGitTempPath(DWORD nBufferLength, LPTSTR lpBuffer)
1017 {
1018 DWORD result = ::GetTempPath(nBufferLength, lpBuffer);
1019 if (result == 0) return 0;
1020 if (lpBuffer == NULL || (result + 13 > nBufferLength))
1021 {
1022 if (lpBuffer)
1023 lpBuffer[0] = '\0';
1024 return result + 13;
1025 }
1026
1027 _tcscat_s(lpBuffer, nBufferLength, _T("TortoiseGit\\"));
1028 CreateDirectory(lpBuffer, NULL);
1029
1030 return result + 13;
1031 }
1032
1033 int CGit::RunLogFile(CString cmd, const CString &filename, CString *stdErr)
1034 {
1035 STARTUPINFO si;
1036 PROCESS_INFORMATION pi;
1037 si.cb=sizeof(STARTUPINFO);
1038 GetStartupInfo(&si);
1039
1040 SECURITY_ATTRIBUTES psa={sizeof(psa),NULL,TRUE};;
1041 psa.bInheritHandle=TRUE;
1042
1043 HANDLE hReadErr, hWriteErr;
1044 if (!CreatePipe(&hReadErr, &hWriteErr, &psa, 0))
1045 {
1046 CString err = CFormatMessageWrapper();
1047 CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": could not open stderr pipe: %s\n"), err.Trim());
1048 return TGIT_GIT_ERROR_OPEN_PIP;
1049 }
1050
1051 HANDLE houtfile=CreateFile(filename,GENERIC_WRITE,FILE_SHARE_READ | FILE_SHARE_WRITE,
1052 &psa,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
1053
1054 if (houtfile == INVALID_HANDLE_VALUE)
1055 {
1056 CString err = CFormatMessageWrapper();
1057 CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": could not open stdout pipe: %s\n"), err.Trim());
1058 CloseHandle(hReadErr);
1059 CloseHandle(hWriteErr);
1060 return TGIT_GIT_ERROR_OPEN_PIP;
1061 }
1062
1063 si.wShowWindow = SW_HIDE;
1064 si.dwFlags = STARTF_USESTDHANDLES|STARTF_USESHOWWINDOW;
1065 si.hStdOutput = houtfile;
1066 si.hStdError = hWriteErr;
1067
1068 LPTSTR pEnv = (!m_Environment.empty()) ? &m_Environment[0]: NULL;
1069 DWORD dwFlags = pEnv ? CREATE_UNICODE_ENVIRONMENT : 0;
1070
1071 if(cmd.Find(_T("git")) == 0)
1072 cmd=CGit::ms_LastMsysGitDir+_T("\\")+cmd;
1073
1074 CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": executing %s\n"), cmd);
1075 if(!CreateProcess(NULL,(LPWSTR)cmd.GetString(), NULL,NULL,TRUE,dwFlags,pEnv,(LPWSTR)m_CurrentDir.GetString(),&si,&pi))
1076 {
1077 CString err = CFormatMessageWrapper();
1078 CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": failed to create Process: %s\n"), err.Trim());
1079 stdErr = &err;
1080 CloseHandle(hReadErr);
1081 CloseHandle(hWriteErr);
1082 CloseHandle(houtfile);
1083 return TGIT_GIT_ERROR_CREATE_PROCESS;
1084 }
1085
1086 BYTE_VECTOR stderrVector;
1087 CGitCall_ByteVector pcall(L"", nullptr, &stderrVector);
1088 HANDLE thread;
1089 ASYNCREADSTDERRTHREADARGS threadArguments;
1090 threadArguments.fileHandle = hReadErr;
1091 threadArguments.pcall = &pcall;
1092 thread = CreateThread(nullptr, 0, AsyncReadStdErrThread, &threadArguments, 0, nullptr);
1093
1094 WaitForSingleObject(pi.hProcess,INFINITE);
1095
1096 CloseHandle(hWriteErr);
1097 CloseHandle(hReadErr);
1098
1099 if (thread)
1100 WaitForSingleObject(thread, INFINITE);
1101
1102 stderrVector.push_back(0);
1103 StringAppend(stdErr, &(stderrVector[0]), CP_UTF8);
1104
1105 DWORD exitcode = 0;
1106 if (!GetExitCodeProcess(pi.hProcess, &exitcode))
1107 {
1108 CString err = CFormatMessageWrapper();
1109 CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": could not get exit code: %s\n"), err.Trim());
1110 return TGIT_GIT_ERROR_GET_EXIT_CODE;
1111 }
1112 else
1113 CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": process exited: %d\n"), exitcode);
1114
1115 CloseHandle(pi.hThread);
1116 CloseHandle(pi.hProcess);
1117 CloseHandle(houtfile);
1118 return exitcode;
1119 }
1120
1121 git_repository * CGit::GetGitRepository() const
1122 {
1123 git_repository * repo = nullptr;
1124 git_repository_open(&repo, GetGitPathStringA(m_CurrentDir));
1125 return repo;
1126 }
1127
1128 int CGit::GetHash(git_repository * repo, CGitHash &hash, const CString& friendname, bool skipFastCheck /* = false */)
1129 {
1130 ATLASSERT(repo);
1131
1132 // no need to parse a ref if it's already a 40-byte hash
1133 if (!skipFastCheck && CGitHash::IsValidSHA1(friendname))
1134 {
1135 hash = CGitHash(friendname);
1136 return 0;
1137 }
1138
1139 int isHeadOrphan = git_repository_head_unborn(repo);
1140 if (isHeadOrphan != 0)
1141 {
1142 hash.Empty();
1143 if (isHeadOrphan == 1)
1144 return 0;
1145 else
1146 return -1;
1147 }
1148
1149 CAutoObject gitObject;
1150 if (git_revparse_single(gitObject.GetPointer(), repo, CUnicodeUtils::GetUTF8(friendname)))
1151 return -1;
1152
1153 const git_oid * oid = git_object_id(gitObject);
1154 if (!oid)
1155 return -1;
1156
1157 hash = CGitHash((char *)oid->id);
1158
1159 return 0;
1160 }
1161
1162 int CGit::GetHash(CGitHash &hash, const CString& friendname)
1163 {
1164 // no need to parse a ref if it's already a 40-byte hash
1165 if (CGitHash::IsValidSHA1(friendname))
1166 {
1167 hash = CGitHash(friendname);
1168 return 0;
1169 }
1170
1171 if (m_IsUseLibGit2)
1172 {
1173 CAutoRepository repo(GetGitRepository());
1174 if (!repo)
1175 return -1;
1176
1177 return GetHash(repo, hash, friendname, true);
1178 }
1179 else
1180 {
1181 CString cmd;
1182 cmd.Format(_T("git.exe rev-parse %s" ),FixBranchName(friendname));
1183 gitLastErr.Empty();
1184 int ret = Run(cmd, &gitLastErr, NULL, CP_UTF8);
1185 hash = CGitHash(gitLastErr.Trim());
1186 if (ret == 0)
1187 gitLastErr.Empty();
1188 return ret;
1189 }
1190 }
1191
1192 int CGit::GetInitAddList(CTGitPathList &outputlist)
1193 {
1194 CString cmd;
1195 BYTE_VECTOR cmdout;
1196
1197 cmd=_T("git.exe ls-files -s -t -z");
1198 outputlist.Clear();
1199 if (Run(cmd, &cmdout))
1200 return -1;
1201
1202 if (outputlist.ParserFromLsFile(cmdout))
1203 return -1;
1204 for(int i = 0; i < outputlist.GetCount(); ++i)
1205 const_cast<CTGitPath&>(outputlist[i]).m_Action = CTGitPath::LOGACTIONS_ADDED;
1206
1207 return 0;
1208 }
1209 int CGit::GetCommitDiffList(const CString &rev1, const CString &rev2, CTGitPathList &outputlist, bool ignoreSpaceAtEol, bool ignoreSpaceChange, bool ignoreAllSpace , bool ignoreBlankLines)
1210 {
1211 CString cmd;
1212 CString ignore;
1213 if (ignoreSpaceAtEol)
1214 ignore += _T(" --ignore-space-at-eol");
1215 if (ignoreSpaceChange)
1216 ignore += _T(" --ignore-space-change");
1217 if (ignoreAllSpace)
1218 ignore += _T(" --ignore-all-space");
1219 if (ignoreBlankLines)
1220 ignore += _T(" --ignore-blank-lines");
1221
1222 if(rev1 == GIT_REV_ZERO || rev2 == GIT_REV_ZERO)
1223 {
1224 //rev1=+_T("");
1225 if(rev1 == GIT_REV_ZERO)
1226 cmd.Format(_T("git.exe diff -r --raw -C -M --numstat -z %s %s --"), ignore, rev2);
1227 else
1228 cmd.Format(_T("git.exe diff -r -R --raw -C -M --numstat -z %s %s --"), ignore, rev1);
1229 }
1230 else
1231 {
1232 cmd.Format(_T("git.exe diff-tree -r --raw -C -M --numstat -z %s %s %s --"), ignore, rev2, rev1);
1233 }
1234
1235 BYTE_VECTOR out;
1236 if (Run(cmd, &out))
1237 return -1;
1238
1239 outputlist.ParserFromLog(out);
1240
1241 return 0;
1242 }
1243
1244 int addto_list_each_ref_fn(const char *refname, const unsigned char * /*sha1*/, int /*flags*/, void *cb_data)
1245 {
1246 STRING_VECTOR *list = (STRING_VECTOR*)cb_data;
1247 CString str;
1248 g_Git.StringAppend(&str, (BYTE*)refname, CP_UTF8);
1249 list->push_back(str);
1250 return 0;
1251 }
1252
1253 int CGit::GetTagList(STRING_VECTOR &list)
1254 {
1255 if (this->m_IsUseLibGit2)
1256 {
1257 CAutoRepository repo(GetGitRepository());
1258 if (!repo)
1259 return -1;
1260
1261 CAutoStrArray tag_names;
1262
1263 if (git_tag_list(tag_names, repo))
1264 return -1;
1265
1266 for (size_t i = 0; i < tag_names->count; ++i)
1267 {
1268 CStringA tagName(tag_names->strings[i]);
1269 list.push_back(CUnicodeUtils::GetUnicode(tagName));
1270 }
1271
1272 std::sort(list.begin(), list.end(), g_bSortTagsReversed ? LogicalCompareReversedPredicate : LogicalComparePredicate);
1273
1274 return 0;
1275 }
1276 else
1277 {
1278 CString cmd, output;
1279 cmd=_T("git.exe tag -l");
1280 int ret = Run(cmd, &output, NULL, CP_UTF8);
1281 if(!ret)
1282 {
1283 int pos=0;
1284 CString one;
1285 while( pos>=0 )
1286 {
1287 one=output.Tokenize(_T("\n"),pos);
1288 if (!one.IsEmpty())
1289 list.push_back(one);
1290 }
1291 std::sort(list.begin(), list.end(), g_bSortTagsReversed ? LogicalCompareReversedPredicate : LogicalComparePredicate);
1292 }
1293 return ret;
1294 }
1295 }
1296
1297 CString CGit::GetGitLastErr(const CString& msg)
1298 {
1299 if (this->m_IsUseLibGit2)
1300 return GetLibGit2LastErr(msg);
1301 else if (gitLastErr.IsEmpty())
1302 return msg + _T("\nUnknown git.exe error.");
1303 else
1304 {
1305 CString lastError = gitLastErr;
1306 gitLastErr.Empty();
1307 return msg + _T("\n") + lastError;
1308 }
1309 }
1310
1311 CString CGit::GetGitLastErr(const CString& msg, LIBGIT2_CMD cmd)
1312 {
1313 if (UsingLibGit2(cmd))
1314 return GetLibGit2LastErr(msg);
1315 else if (gitLastErr.IsEmpty())
1316 return msg + _T("\nUnknown git.exe error.");
1317 else
1318 {
1319 CString lastError = gitLastErr;
1320 gitLastErr.Empty();
1321 return msg + _T("\n") + lastError;
1322 }
1323 }
1324
1325 CString CGit::GetLibGit2LastErr()
1326 {
1327 const git_error *libgit2err = giterr_last();
1328 if (libgit2err)
1329 {
1330 CString lastError = CUnicodeUtils::GetUnicode(CStringA(libgit2err->message));
1331 giterr_clear();
1332 return _T("libgit2 returned: ") + lastError;
1333 }
1334 else
1335 return _T("An error occoured in libgit2, but no message is available.");
1336 }
1337
1338 CString CGit::GetLibGit2LastErr(const CString& msg)
1339 {
1340 if (!msg.IsEmpty())
1341 return msg + _T("\n") + GetLibGit2LastErr();
1342 return GetLibGit2LastErr();
1343 }
1344
1345 CString CGit::FixBranchName_Mod(CString& branchName)
1346 {
1347 if(branchName == "FETCH_HEAD")
1348 branchName = DerefFetchHead();
1349 return branchName;
1350 }
1351
1352 CString CGit::FixBranchName(const CString& branchName)
1353 {
1354 CString tempBranchName = branchName;
1355 FixBranchName_Mod(tempBranchName);
1356 return tempBranchName;
1357 }
1358
1359 bool CGit::IsBranchTagNameUnique(const CString& name)
1360 {
1361 if (m_IsUseLibGit2)
1362 {
1363 CAutoRepository repo(GetGitRepository());
1364 if (!repo)
1365 return true; // TODO: optimize error reporting
1366
1367 CAutoReference tagRef;
1368 if (git_reference_lookup(tagRef.GetPointer(), repo, CUnicodeUtils::GetUTF8(L"refs/tags/" + name)))
1369 return true;
1370
1371 CAutoReference branchRef;
1372 if (git_reference_lookup(branchRef.GetPointer(), repo, CUnicodeUtils::GetUTF8(L"refs/heads/" + name)))
1373 return true;
1374
1375 return false;
1376 }
1377 // else
1378 CString output;
1379
1380 CString cmd;
1381 cmd.Format(_T("git.exe show-ref --tags --heads refs/heads/%s refs/tags/%s"), name, name);
1382 int ret = Run(cmd, &output, NULL, CP_UTF8);
1383 if (!ret)
1384 {
1385 int i = 0, pos = 0;
1386 while (pos >= 0)
1387 {
1388 if (!output.Tokenize(_T("\n"), pos).IsEmpty())
1389 ++i;
1390 }
1391 if (i >= 2)
1392 return false;
1393 }
1394
1395 return true;
1396 }
1397
1398 bool CGit::BranchTagExists(const CString& name, bool isBranch /*= true*/)
1399 {
1400 if (m_IsUseLibGit2)
1401 {
1402 CAutoRepository repo(GetGitRepository());
1403 if (!repo)
1404 return false; // TODO: optimize error reporting
1405
1406 CString prefix;
1407 if (isBranch)
1408 prefix = _T("refs/heads/");
1409 else
1410 prefix = _T("refs/tags/");
1411
1412 CAutoReference ref;
1413 if (git_reference_lookup(ref.GetPointer(), repo, CUnicodeUtils::GetUTF8(prefix + name)))
1414 return false;
1415
1416 return true;
1417 }
1418 // else
1419 CString cmd, output;
1420
1421 cmd = _T("git.exe show-ref ");
1422 if (isBranch)
1423 cmd += _T("--heads ");
1424 else
1425 cmd += _T("--tags ");
1426
1427 cmd += _T("refs/heads/") + name;
1428 cmd += _T(" refs/tags/") + name;
1429
1430 int ret = Run(cmd, &output, NULL, CP_UTF8);
1431 if (!ret)
1432 {
1433 if (!output.IsEmpty())
1434 return true;
1435 }
1436
1437 return false;
1438 }
1439
1440 CString CGit::DerefFetchHead()
1441 {
1442 CString dotGitPath;
1443 g_GitAdminDir.GetAdminDirPath(m_CurrentDir, dotGitPath);
1444 std::ifstream fetchHeadFile((dotGitPath + L"FETCH_HEAD").GetString(), std::ios::in | std::ios::binary);
1445 int forMergeLineCount = 0;
1446 std::string line;
1447 std::string hashToReturn;
1448 while(getline(fetchHeadFile, line))
1449 {
1450 //Tokenize this line
1451 std::string::size_type prevPos = 0;
1452 std::string::size_type pos = line.find('\t');
1453 if(pos == std::string::npos) continue; //invalid line
1454
1455 std::string hash = line.substr(0, pos);
1456 ++pos; prevPos = pos; pos = line.find('\t', pos); if(pos == std::string::npos) continue;
1457
1458 bool forMerge = pos == prevPos;
1459 ++pos; prevPos = pos; pos = line.size(); if(pos == std::string::npos) continue;
1460
1461 std::string remoteBranch = line.substr(prevPos, pos - prevPos);
1462
1463 //Process this line
1464 if(forMerge)
1465 {
1466 hashToReturn = hash;
1467 ++forMergeLineCount;
1468 if(forMergeLineCount > 1)
1469 return L""; //More then 1 branch to merge found. Octopus merge needed. Cannot pick single ref from FETCH_HEAD
1470 }
1471 }
1472
1473 return CUnicodeUtils::GetUnicode(hashToReturn.c_str());
1474 }
1475
1476 int CGit::GetBranchList(STRING_VECTOR &list,int *current,BRANCH_TYPE type)
1477 {
1478 int ret = 0;
1479 CString cur;
1480 if (m_IsUseLibGit2)
1481 {
1482 CAutoRepository repo(GetGitRepository());
1483 if (!repo)
1484 return -1;
1485
1486 if (git_repository_head_detached(repo) == 1)
1487 cur = _T("(detached from ");
1488
1489 if ((type & (BRANCH_LOCAL | BRANCH_REMOTE)) != 0)
1490 {
1491 git_branch_t flags = GIT_BRANCH_LOCAL;
1492 if ((type & BRANCH_LOCAL) && (type & BRANCH_REMOTE))
1493 flags = GIT_BRANCH_ALL;
1494 else if (type & BRANCH_REMOTE)
1495 flags = GIT_BRANCH_REMOTE;
1496
1497 CAutoBranchIterator it;
1498 if (git_branch_iterator_new(it.GetPointer(), repo, flags))
1499 return -1;
1500
1501 git_reference * ref = nullptr;
1502 git_branch_t branchType;
1503 while (git_branch_next(&ref, &branchType, it) == 0)
1504 {
1505 CAutoReference autoRef(ref);
1506 const char * name = nullptr;
1507 if (git_branch_name(&name, ref))
1508 continue;
1509
1510 CString branchname = CUnicodeUtils::GetUnicode(name);
1511 if (branchType & GIT_BRANCH_REMOTE)
1512 list.push_back(_T("remotes/") + branchname);
1513 else
1514 {
1515 if (git_branch_is_head(ref))
1516 cur = branchname;
1517 list.push_back(branchname);
1518 }
1519 }
1520 }
1521 }
1522 else
1523 {
1524 CString cmd, output;
1525 cmd = _T("git.exe branch --no-color");
1526
1527 if ((type & BRANCH_ALL) == BRANCH_ALL)
1528 cmd += _T(" -a");
1529 else if (type & BRANCH_REMOTE)
1530 cmd += _T(" -r");
1531
1532 ret = Run(cmd, &output, nullptr, CP_UTF8);
1533 if (!ret)
1534 {
1535 int pos = 0;
1536 CString one;
1537 while (pos >= 0)
1538 {
1539 one = output.Tokenize(_T("\n"), pos);
1540 one.Trim(L" \r\n\t");
1541 if (one.Find(L" -> ") >= 0 || one.IsEmpty())
1542 continue; // skip something like: refs/origin/HEAD -> refs/origin/master
1543 if (one[0] == _T('*'))
1544 {
1545 one = one.Mid(2);
1546 cur = one;
1547 }
1548 if (one.Left(10) != _T("(no branch") && one.Left(15) != _T("(detached from "))
1549 list.push_back(one);
1550 }
1551 }
1552 }
1553
1554 if(type & BRANCH_FETCH_HEAD && !DerefFetchHead().IsEmpty())
1555 list.push_back(L"FETCH_HEAD");
1556
1557 std::sort(list.begin(), list.end(), LogicalCompareBranchesPredicate);
1558
1559 if (current && cur.Left(10) != _T("(no branch") && cur.Left(15) != _T("(detached from "))
1560 {
1561 for (unsigned int i = 0; i < list.size(); ++i)
1562 {
1563 if (list[i] == cur)
1564 {
1565 *current = i;
1566 break;
1567 }
1568 }
1569 }
1570
1571 return ret;
1572 }
1573
1574 int CGit::GetRemoteList(STRING_VECTOR &list)
1575 {
1576 if (this->m_IsUseLibGit2)
1577 {
1578 CAutoRepository repo(GetGitRepository());
1579 if (!repo)
1580 return -1;
1581
1582 CAutoStrArray remotes;
1583 if (git_remote_list(remotes, repo))
1584 return -1;
1585
1586 for (size_t i = 0; i < remotes->count; ++i)
1587 {
1588 CStringA remote(remotes->strings[i]);
1589 list.push_back(CUnicodeUtils::GetUnicode(remote));
1590 }
1591
1592 std::sort(list.begin(), list.end());
1593
1594 return 0;
1595 }
1596 else
1597 {
1598 int ret;
1599 CString cmd, output;
1600 cmd=_T("git.exe remote");
1601 ret = Run(cmd, &output, NULL, CP_UTF8);
1602 if(!ret)
1603 {
1604 int pos=0;
1605 CString one;
1606 while( pos>=0 )
1607 {
1608 one=output.Tokenize(_T("\n"),pos);
1609 if (!one.IsEmpty())
1610 list.push_back(one);
1611 }
1612 }
1613 return ret;
1614 }
1615 }
1616
1617 int CGit::GetRemoteTags(const CString& remote, STRING_VECTOR &list)
1618 {
1619 CString cmd, out, err;
1620 cmd.Format(_T("git.exe ls-remote -t \"%s\""), remote);
1621 if (Run(cmd, &out, &err, CP_UTF8))
1622 {
1623 MessageBox(NULL, err, _T("TortoiseGit"), MB_ICONERROR);
1624 return -1;
1625 }
1626
1627 int pos = 0;
1628 while (pos >= 0)
1629 {
1630 CString one = out.Tokenize(_T("\n"), pos).Mid(51).Trim(); // sha1, tab + refs/tags/
1631 // dot not include annotated tags twice; this works, because an annotated tag appears twice (one normal tag and one with ^{} at the end)
1632 if (one.Find(_T("^{}")) >= 1)
1633 continue;
1634 if (!one.IsEmpty())
1635 list.push_back(one);
1636 }
1637 std::sort(list.begin(), list.end(), g_bSortTagsReversed ? LogicalCompareReversedPredicate : LogicalComparePredicate);
1638 return 0;
1639 }
1640
1641 int libgit2_addto_list_each_ref_fn(git_reference *ref, void *payload)
1642 {
1643 STRING_VECTOR *list = (STRING_VECTOR*)payload;
1644 CString str;
1645 g_Git.StringAppend(&str, (BYTE*)git_reference_name(ref), CP_UTF8);
1646 list->push_back(str);
1647 return 0;
1648 }
1649
1650 int CGit::GetRefList(STRING_VECTOR &list)
1651 {
1652 if (this->m_IsUseLibGit2)
1653 {
1654 CAutoRepository repo(GetGitRepository());
1655 if (!repo)
1656 return -1;
1657
1658 if (git_reference_foreach(repo, libgit2_addto_list_each_ref_fn, &list))
1659 return -1;
1660
1661 std::sort(list.begin(), list.end(), LogicalComparePredicate);
1662
1663 return 0;
1664 }
1665 else
1666 {
1667 CString cmd, output;
1668 cmd=_T("git.exe show-ref -d");
1669 int ret = Run(cmd, &output, NULL, CP_UTF8);
1670 if(!ret)
1671 {
1672 int pos=0;
1673 CString one;
1674 while( pos>=0 )
1675 {
1676 one=output.Tokenize(_T("\n"),pos);
1677 int start=one.Find(_T(" "),0);
1678 if(start>0)
1679 {
1680 CString name;
1681 name=one.Right(one.GetLength()-start-1);
1682 list.push_back(name);
1683 }
1684 }
1685 std::sort(list.begin(), list.end(), LogicalComparePredicate);
1686 }
1687 return ret;
1688 }
1689 }
1690
1691 typedef struct map_each_ref_payload {
1692 git_repository * repo;
1693 MAP_HASH_NAME * map;
1694 } map_each_ref_payload;
1695
1696 int libgit2_addto_map_each_ref_fn(git_reference *ref, void *payload)
1697 {
1698 map_each_ref_payload *payloadContent = (map_each_ref_payload*)payload;
1699
1700 CString str;
1701 g_Git.StringAppend(&str, (BYTE*)git_reference_name(ref), CP_UTF8);
1702
1703 CAutoObject gitObject;
1704 if (git_revparse_single(gitObject.GetPointer(), payloadContent->repo, git_reference_name(ref)))
1705 return 1;
1706
1707 if (git_object_type(gitObject) == GIT_OBJ_TAG)
1708 {
1709 str += _T("^{}"); // deref tag
1710 CAutoObject derefedTag;
1711 if (git_object_peel(derefedTag.GetPointer(), gitObject, GIT_OBJ_ANY))
1712 return 1;
1713 gitObject.Swap(derefedTag);
1714 }
1715
1716 const git_oid * oid = git_object_id(gitObject);
1717 if (oid == NULL)
1718 return 1;
1719
1720 CGitHash hash((char *)oid->id);
1721 (*payloadContent->map)[hash].push_back(str);
1722
1723 return 0;
1724 }
1725 int CGit::GetMapHashToFriendName(git_repository* repo, MAP_HASH_NAME &map)
1726 {
1727 ATLASSERT(repo);
1728
1729 map_each_ref_payload payloadContent = { repo, &map };
1730
1731 if (git_reference_foreach(repo, libgit2_addto_map_each_ref_fn, &payloadContent))
1732 return -1;
1733
1734 for (auto it = map.begin(); it != map.end(); ++it)
1735 {
1736 std::sort(it->second.begin(), it->second.end());
1737 }
1738
1739 return 0;
1740 }
1741
1742 int CGit::GetMapHashToFriendName(MAP_HASH_NAME &map)
1743 {
1744 if (this->m_IsUseLibGit2)
1745 {
1746 CAutoRepository repo(GetGitRepository());
1747 if (!repo)
1748 return -1;
1749
1750 return GetMapHashToFriendName(repo, map);
1751 }
1752 else
1753 {
1754 CString cmd, output;
1755 cmd=_T("git.exe show-ref -d");
1756 int ret = Run(cmd, &output, NULL, CP_UTF8);
1757 if(!ret)
1758 {
1759 int pos=0;
1760 CString one;
1761 while( pos>=0 )
1762 {
1763 one=output.Tokenize(_T("\n"),pos);
1764 int start=one.Find(_T(" "),0);
1765 if(start>0)
1766 {
1767 CString name;
1768 name=one.Right(one.GetLength()-start-1);
1769
1770 CString hash;
1771 hash=one.Left(start);
1772
1773 map[CGitHash(hash)].push_back(name);
1774 }
1775 }
1776 }
1777 return ret;
1778 }
1779 }
1780
1781 static void SetLibGit2SearchPath(int level, const CString &value)
1782 {
1783 CStringA valueA = CUnicodeUtils::GetMulti(value, CP_UTF8);
1784 git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, level, valueA);
1785 }
1786
1787 static void SetLibGit2TemplatePath(const CString &value)
1788 {
1789 CStringA valueA = CUnicodeUtils::GetMulti(value, CP_UTF8);
1790 git_libgit2_opts(GIT_OPT_SET_TEMPLATE_PATH, valueA);
1791 }
1792
1793 BOOL CGit::CheckMsysGitDir(BOOL bFallback)
1794 {
1795 if (m_bInitialized)
1796 {
1797 return TRUE;
1798 }
1799
1800 this->m_Environment.clear();
1801 m_Environment.CopyProcessEnvironment();
1802
1803 TCHAR *oldpath;
1804 size_t homesize,size;
1805
1806 // set HOME if not set already
1807 _tgetenv_s(&homesize, NULL, 0, _T("HOME"));
1808 if (!homesize)
1809 m_Environment.SetEnv(_T("HOME"), GetHomeDirectory());
1810
1811 //setup ssh client
1812 CString sshclient=CRegString(_T("Software\\TortoiseGit\\SSH"));
1813 if (sshclient.IsEmpty())
1814 sshclient = CRegString(_T("Software\\TortoiseGit\\SSH"), _T(""), FALSE, HKEY_LOCAL_MACHINE);
1815
1816 if(!sshclient.IsEmpty())
1817 {
1818 m_Environment.SetEnv(_T("GIT_SSH"), sshclient);
1819 m_Environment.SetEnv(_T("SVN_SSH"), sshclient);
1820 }
1821 else
1822 {
1823 TCHAR sPlink[MAX_PATH] = {0};
1824 GetModuleFileName(NULL, sPlink, _countof(sPlink));
1825 LPTSTR ptr = _tcsrchr(sPlink, _T('\\'));
1826 if (ptr) {
1827 _tcscpy_s(ptr + 1, MAX_PATH - (ptr - sPlink + 1), _T("TortoiseGitPLink.exe"));
1828 m_Environment.SetEnv(_T("GIT_SSH"), sPlink);
1829 m_Environment.SetEnv(_T("SVN_SSH"), sPlink);
1830 }
1831 }
1832
1833 {
1834 TCHAR sAskPass[MAX_PATH] = {0};
1835 GetModuleFileName(NULL, sAskPass, _countof(sAskPass));
1836 LPTSTR ptr = _tcsrchr(sAskPass, _T('\\'));
1837 if (ptr)
1838 {
1839 _tcscpy_s(ptr + 1, MAX_PATH - (ptr - sAskPass + 1), _T("SshAskPass.exe"));
1840 m_Environment.SetEnv(_T("DISPLAY"),_T(":9999"));
1841 m_Environment.SetEnv(_T("SSH_ASKPASS"),sAskPass);
1842 m_Environment.SetEnv(_T("GIT_ASKPASS"),sAskPass);
1843 }
1844 }
1845
1846 // add git/bin path to PATH
1847
1848 CRegString msysdir=CRegString(REG_MSYSGIT_PATH,_T(""),FALSE);
1849 CString str = msysdir;
1850 if(str.IsEmpty() || !FileExists(str + _T("\\git.exe")))
1851 {
1852 if (!bFallback)
1853 return FALSE;
1854
1855 CRegString msyslocalinstalldir = CRegString(REG_MSYSGIT_INSTALL_LOCAL, _T(""), FALSE, HKEY_CURRENT_USER);
1856 str = msyslocalinstalldir;
1857 str.TrimRight(_T("\\"));
1858 if (str.IsEmpty())
1859 {
1860 CRegString msysinstalldir = CRegString(REG_MSYSGIT_INSTALL, _T(""), FALSE, HKEY_LOCAL_MACHINE);
1861 str = msysinstalldir;
1862 str.TrimRight(_T("\\"));
1863 }
1864 if ( !str.IsEmpty() )
1865 {
1866 str += "\\bin";
1867 msysdir=str;
1868 CGit::ms_LastMsysGitDir = str;
1869 msysdir.write();
1870 }
1871 else
1872 {
1873 // search PATH if git/bin directory is already present
1874 if ( FindGitPath() )
1875 {
1876 m_bInitialized = TRUE;
1877 msysdir = CGit::ms_LastMsysGitDir;
1878 msysdir.write();
1879 return TRUE;
1880 }
1881
1882 return FALSE;
1883 }
1884 }
1885 else
1886 {
1887 CGit::ms_LastMsysGitDir = str;
1888 }
1889
1890 // check for git.exe existance (maybe it was deinstalled in the meantime)
1891 if (!FileExists(CGit::ms_LastMsysGitDir + _T("\\git.exe")))
1892 return FALSE;
1893
1894 // Configure libgit2 search paths
1895 CString msysGitDir;
1896 PathCanonicalize(msysGitDir.GetBufferSetLength(MAX_PATH), CGit::ms_LastMsysGitDir + _T("\\..\\etc"));
1897 msysGitDir.ReleaseBuffer();
1898 SetLibGit2SearchPath(GIT_CONFIG_LEVEL_SYSTEM, msysGitDir);
1899 SetLibGit2SearchPath(GIT_CONFIG_LEVEL_GLOBAL, g_Git.GetHomeDirectory());
1900 SetLibGit2SearchPath(GIT_CONFIG_LEVEL_XDG, g_Git.GetGitGlobalXDGConfigPath());
1901 CString msysGitTemplateDir;
1902 PathCanonicalize(msysGitTemplateDir.GetBufferSetLength(MAX_PATH), CGit::ms_LastMsysGitDir + _T("\\..\\share\\git-core\\templates"));
1903 msysGitTemplateDir.ReleaseBuffer();
1904 SetLibGit2TemplatePath(msysGitTemplateDir);
1905
1906 //set path
1907 _tdupenv_s(&oldpath,&size,_T("PATH"));
1908
1909 CString path;
1910 path.Format(_T("%s;%s"),oldpath,str + _T(";")+ (CString)CRegString(REG_MSYSGIT_EXTRA_PATH,_T(""),FALSE));
1911
1912 m_Environment.SetEnv(_T("PATH"), path);
1913
1914 CString str1 = m_Environment.GetEnv(_T("PATH"));
1915
1916 CString sOldPath = oldpath;
1917 free(oldpath);
1918
1919 m_bInitialized = TRUE;
1920 return true;
1921 }
1922
1923 CString CGit::GetHomeDirectory() const
1924 {
1925 const wchar_t * homeDir = wget_windows_home_directory();
1926 return CString(homeDir, (int)wcslen(homeDir));
1927 }
1928
1929 CString CGit::GetGitLocalConfig() const
1930 {
1931 CString path;
1932 g_GitAdminDir.GetAdminDirPath(m_CurrentDir, path);
1933 path += _T("config");
1934 return path;
1935 }
1936
1937 CStringA CGit::GetGitPathStringA(const CString &path)
1938 {
1939 return CUnicodeUtils::GetUTF8(CTGitPath(path).GetGitPathString());
1940 }
1941
1942 CString CGit::GetGitGlobalConfig() const
1943 {
1944 return g_Git.GetHomeDirectory() + _T("\\.gitconfig");
1945 }
1946
1947 CString CGit::GetGitGlobalXDGConfigPath() const
1948 {
1949 return g_Git.GetHomeDirectory() + _T("\\.config\\git");
1950 }
1951
1952 CString CGit::GetGitGlobalXDGConfig() const
1953 {
1954 return g_Git.GetGitGlobalXDGConfigPath() + _T("\\config");
1955 }
1956
1957 CString CGit::GetGitSystemConfig() const
1958 {
1959 const wchar_t * systemConfig = wget_msysgit_etc();
1960 return CString(systemConfig, (int)wcslen(systemConfig));
1961 }
1962
1963 BOOL CGit::CheckCleanWorkTree()
1964 {
1965 CString out;
1966 CString cmd;
1967 cmd=_T("git.exe rev-parse --verify HEAD");
1968
1969 if(Run(cmd,&out,CP_UTF8))
1970 return FALSE;
1971
1972 cmd=_T("git.exe update-index --ignore-submodules --refresh");
1973 if(Run(cmd,&out,CP_UTF8))
1974 return FALSE;
1975
1976 cmd=_T("git.exe diff-files --quiet --ignore-submodules");
1977 if(Run(cmd,&out,CP_UTF8))
1978 return FALSE;
1979
1980 cmd = _T("git.exe diff-index --cached --quiet HEAD --ignore-submodules --");
1981 if(Run(cmd,&out,CP_UTF8))
1982 return FALSE;
1983
1984 return TRUE;
1985 }
1986 int CGit::Revert(const CString& commit, const CTGitPathList &list, bool)
1987 {
1988 int ret;
1989 for (int i = 0; i < list.GetCount(); ++i)
1990 {
1991 ret = Revert(commit, (CTGitPath&)list[i]);
1992 if(ret)
1993 return ret;
1994 }
1995 return 0;
1996 }
1997 int CGit::Revert(const CString& commit, const CTGitPath &path)
1998 {
1999 CString cmd, out;
2000
2001 if(path.m_Action & CTGitPath::LOGACTIONS_REPLACED && !path.GetGitOldPathString().IsEmpty())
2002 {
2003 if (CTGitPath(path.GetGitOldPathString()).IsDirectory())
2004 {
2005 CString err;
2006 err.Format(_T("Cannot revert renaming of \"%s\". A directory with the old name \"%s\" exists."), path.GetGitPathString(), path.GetGitOldPathString());
2007 ::MessageBox(NULL, err, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
2008 return -1;
2009 }
2010 CString force;
2011 // if the filenames only differ in case, we have to pass "-f"
2012 if (path.GetGitPathString().CompareNoCase(path.GetGitOldPathString()) == 0)
2013 force = _T("-f ");
2014 cmd.Format(_T("git.exe mv %s-- \"%s\" \"%s\""), force, path.GetGitPathString(), path.GetGitOldPathString());
2015 if (Run(cmd, &out, CP_UTF8))
2016 {
2017 ::MessageBox(NULL, out, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
2018 return -1;
2019 }
2020
2021 cmd.Format(_T("git.exe checkout %s -f -- \"%s\""), commit, path.GetGitOldPathString());
2022 if (Run(cmd, &out, CP_UTF8))
2023 {
2024 ::MessageBox(NULL, out, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
2025 return -1;
2026 }
2027
2028 }
2029 else if(path.m_Action & CTGitPath::LOGACTIONS_ADDED)
2030 { //To init git repository, there are not HEAD, so we can use git reset command
2031 cmd.Format(_T("git.exe rm -f --cached -- \"%s\""),path.GetGitPathString());
2032
2033 if (Run(cmd, &out, CP_UTF8))
2034 {
2035 ::MessageBox(NULL, out, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
2036 return -1;
2037 }
2038 }
2039 else
2040 {
2041 cmd.Format(_T("git.exe checkout %s -f -- \"%s\""), commit, path.GetGitPathString());
2042 if (Run(cmd, &out, CP_UTF8))
2043 {
2044 ::MessageBox(NULL, out, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
2045 return -1;
2046 }
2047 }
2048
2049 if (path.m_Action & CTGitPath::LOGACTIONS_DELETED)
2050 {
2051 cmd.Format(_T("git.exe add -f -- \"%s\""), path.GetGitPathString());
2052 if (Run(cmd, &out, CP_UTF8))
2053 {
2054 ::MessageBox(NULL, out, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
2055 return -1;
2056 }
2057 }
2058
2059 return 0;
2060 }
2061
2062 int CGit::ListConflictFile(CTGitPathList &list, const CTGitPath *path)
2063 {
2064 BYTE_VECTOR vector;
2065
2066 CString cmd;
2067 if(path)
2068 cmd.Format(_T("git.exe ls-files -u -t -z -- \"%s\""),path->GetGitPathString());
2069 else
2070 cmd=_T("git.exe ls-files -u -t -z");
2071
2072 if (Run(cmd, &vector))
2073 {
2074 return -1;
2075 }
2076
2077 if (list.ParserFromLsFile(vector))
2078 return -1;
2079
2080 return 0;
2081 }
2082
2083 bool CGit::IsFastForward(const CString &from, const CString &to, CGitHash * commonAncestor)
2084 {
2085 if (UsingLibGit2(GIT_CMD_MERGE_BASE))
2086 {
2087 CAutoRepository repo(GetGitRepository());
2088 if (!repo)
2089 return false;
2090
2091 CGitHash fromHash, toHash, baseHash;
2092 if (GetHash(repo, toHash, FixBranchName(to)))
2093 return false;
2094
2095 if (GetHash(repo, fromHash, FixBranchName(from)))
2096 return false;
2097
2098 git_oid baseOid;
2099 if (git_merge_base(&baseOid, repo, (const git_oid*)toHash.m_hash, (const git_oid*)fromHash.m_hash))
2100 return false;
2101
2102 baseHash = baseOid.id;
2103
2104 if (commonAncestor)
2105 *commonAncestor = baseHash;
2106
2107 return fromHash == baseHash;
2108 }
2109 // else
2110 CString base;
2111 CGitHash basehash,hash;
2112 CString cmd, err;
2113 cmd.Format(_T("git.exe merge-base %s %s"), FixBranchName(to), FixBranchName(from));
2114
2115 if (Run(cmd, &base, &err, CP_UTF8))
2116 {
2117 return false;
2118 }
2119 basehash = base.Trim();
2120
2121 GetHash(hash, from);
2122
2123 if (commonAncestor)
2124 *commonAncestor = basehash;
2125
2126 return hash == basehash;
2127 }
2128
2129 unsigned int CGit::Hash2int(const CGitHash &hash)
2130 {
2131 int ret=0;
2132 for (int i = 0; i < 4; ++i)
2133 {
2134 ret = ret << 8;
2135 ret |= hash.m_hash[i];
2136 }
2137 return ret;
2138 }
2139
2140 int CGit::RefreshGitIndex()
2141 {
2142 if(g_Git.m_IsUseGitDLL)
2143 {
2144 CAutoLocker lock(g_Git.m_critGitDllSec);
2145 try
2146 {
2147 return [] { return git_run_cmd("update-index","update-index -q --refresh"); }();
2148
2149 }catch(...)
2150 {
2151 return -1;
2152 }
2153
2154 }
2155 else
2156 {
2157 CString cmd,output;
2158 cmd=_T("git.exe update-index --refresh");
2159 return Run(cmd, &output, CP_UTF8);
2160 }
2161 }
2162
2163 int CGit::GetOneFile(const CString &Refname, const CTGitPath &path, const CString &outputfile)
2164 {
2165 if (UsingLibGit2(GIT_CMD_GETONEFILE))
2166 {
2167 CAutoRepository repo(GetGitRepository());
2168 if (!repo)
2169 return -1;
2170
2171 CGitHash hash;
2172 if (GetHash(repo, hash, Refname))
2173 return -1;
2174
2175 CAutoCommit commit;
2176 if (git_commit_lookup(commit.GetPointer(), repo, (const git_oid *)hash.m_hash))
2177 return -1;
2178
2179 CAutoTree tree;
2180 if (git_commit_tree(tree.GetPointer(), commit))
2181 return -1;
2182
2183 CAutoTreeEntry entry;
2184 if (git_tree_entry_bypath(entry.GetPointer(), tree, CUnicodeUtils::GetUTF8(path.GetGitPathString())))
2185 return -1;
2186
2187 CAutoBlob blob;
2188 if (git_tree_entry_to_object((git_object**)blob.GetPointer(), repo, entry))
2189 return -1;
2190
2191 FILE *file = nullptr;
2192 _tfopen_s(&file, outputfile, _T("w"));
2193 if (file == nullptr)
2194 {
2195 giterr_set_str(GITERR_NONE, "Could not create file.");
2196 return -1;
2197 }
2198 CAutoBuf buf;
2199 if (git_blob_filtered_content(buf, blob, CUnicodeUtils::GetUTF8(path.GetGitPathString()), 0))
2200 {
2201 fclose(file);
2202 return -1;
2203 }
2204 if (fwrite(buf->ptr, sizeof(char), buf->size, file) != buf->size)
2205 {
2206 giterr_set_str(GITERR_OS, "Could not write to file.");
2207 fclose(file);
2208
2209 return -1;
2210 }
2211 fclose(file);
2212
2213 return 0;
2214 }
2215 else if (g_Git.m_IsUseGitDLL)
2216 {
2217 CAutoLocker lock(g_Git.m_critGitDllSec);
2218 try
2219 {
2220 g_Git.CheckAndInitDll();
2221 CStringA ref, patha, outa;
2222 ref = CUnicodeUtils::GetMulti(Refname, CP_UTF8);
2223 patha = CUnicodeUtils::GetMulti(path.GetGitPathString(), CP_UTF8);
2224 outa = CUnicodeUtils::GetMulti(outputfile, CP_UTF8);
2225 ::DeleteFile(outputfile);
2226 return git_checkout_file(ref, patha, outa);
2227
2228 }
2229 catch (const char * msg)
2230 {
2231 gitLastErr = L"gitdll.dll reports: " + CString(msg);
2232 return -1;
2233 }
2234 catch (...)
2235 {
2236 gitLastErr = L"An unknown gitdll.dll error occurred.";
2237 return -1;
2238 }
2239 }
2240 else
2241 {
2242 CString cmd;
2243 cmd.Format(_T("git.exe cat-file -p %s:\"%s\""), Refname, path.GetGitPathString());
2244 return RunLogFile(cmd, outputfile, &gitLastErr);
2245 }
2246 }
2247 void CEnvironment::CopyProcessEnvironment()
2248 {
2249 TCHAR *porig = GetEnvironmentStrings();
2250 TCHAR *p = porig;
2251 while(*p !=0 || *(p+1) !=0)
2252 this->push_back(*p++);
2253
2254 push_back(_T('\0'));
2255 push_back(_T('\0'));
2256
2257 FreeEnvironmentStrings(porig);
2258 }
2259
2260 CString CEnvironment::GetEnv(const TCHAR *name)
2261 {
2262 CString str;
2263 for (size_t i = 0; i < size(); ++i)
2264 {
2265 str = &(*this)[i];
2266 int start =0;
2267 CString sname = str.Tokenize(_T("="),start);
2268 if(sname.CompareNoCase(name) == 0)
2269 {
2270 return &(*this)[i+start];
2271 }
2272 i+=str.GetLength();
2273 }
2274 return _T("");
2275 }
2276
2277 void CEnvironment::SetEnv(const TCHAR *name, const TCHAR* value)
2278 {
2279 unsigned int i;
2280 for (i = 0; i < size(); ++i)
2281 {
2282 CString str = &(*this)[i];
2283 int start =0;
2284 CString sname = str.Tokenize(_T("="),start);
2285 if(sname.CompareNoCase(name) == 0)
2286 {
2287 break;
2288 }
2289 i+=str.GetLength();
2290 }
2291
2292 if(i == size())
2293 {
2294 i -= 1; // roll back terminate \0\0
2295 this->push_back(_T('\0'));
2296 }
2297
2298 CEnvironment::iterator it;
2299 it=this->begin();
2300 it += i;
2301
2302 while(*it && i<size())
2303 {
2304 this->erase(it);
2305 it=this->begin();
2306 it += i;
2307 }
2308
2309 while(*name)
2310 {
2311 this->insert(it,*name++);
2312 ++i;
2313 it= begin()+i;
2314 }
2315
2316 this->insert(it, _T('='));
2317 ++i;
2318 it= begin()+i;
2319
2320 while(*value)
2321 {
2322 this->insert(it,*value++);
2323 ++i;
2324 it= begin()+i;
2325 }
2326
2327 }
2328
2329 int CGit::GetGitEncode(TCHAR* configkey)
2330 {
2331 CString str=GetConfigValue(configkey);
2332
2333 if(str.IsEmpty())
2334 return CP_UTF8;
2335
2336 return CUnicodeUtils::GetCPCode(str);
2337 }
2338
2339
2340 int CGit::GetDiffPath(CTGitPathList *PathList, CGitHash *hash1, CGitHash *hash2, char *arg)
2341 {
2342 GIT_FILE file=0;
2343 int ret=0;
2344 GIT_DIFF diff=0;
2345
2346 CAutoLocker lock(g_Git.m_critGitDllSec);
2347
2348 if(arg == NULL)
2349 diff = GetGitDiff();
2350 else
2351 git_open_diff(&diff, arg);
2352
2353 if(diff ==NULL)
2354 return -1;
2355
2356 bool isStat = 0;
2357 if(arg == NULL)
2358 isStat = true;
2359 else
2360 isStat = !!strstr(arg, "stat");
2361
2362 int count=0;
2363
2364 if(hash2 == NULL)
2365 ret = git_root_diff(diff, hash1->m_hash, &file, &count,isStat);
2366 else
2367 ret = git_do_diff(diff,hash2->m_hash,hash1->m_hash,&file,&count,isStat);
2368
2369 if(ret)
2370 return -1;
2371
2372 CTGitPath path;
2373 CString strnewname;
2374 CString stroldname;
2375
2376 for (int j = 0; j < count; ++j)
2377 {
2378 path.Reset();
2379 char *newname;
2380 char *oldname;
2381
2382 strnewname.Empty();
2383 stroldname.Empty();
2384
2385 int mode=0,IsBin=0,inc=0,dec=0;
2386 git_get_diff_file(diff,file,j,&newname,&oldname,
2387 &mode,&IsBin,&inc,&dec);
2388
2389 StringAppend(&strnewname, (BYTE*)newname, CP_UTF8);
2390 StringAppend(&stroldname, (BYTE*)oldname, CP_UTF8);
2391
2392 path.SetFromGit(strnewname,&stroldname);
2393 path.ParserAction((BYTE)mode);
2394
2395 if(IsBin)
2396 {
2397 path.m_StatAdd=_T("-");
2398 path.m_StatDel=_T("-");
2399 }
2400 else
2401 {
2402 path.m_StatAdd.Format(_T("%d"),inc);
2403 path.m_StatDel.Format(_T("%d"),dec);
2404 }
2405 PathList->AddPath(path);
2406 }
2407 git_diff_flush(diff);
2408
2409 if(arg)
2410 git_close_diff(diff);
2411
2412 return 0;
2413 }
2414
2415 int CGit::GetShortHASHLength() const
2416 {
2417 return 7;
2418 }
2419
2420 CString CGit::GetShortName(const CString& ref, REF_TYPE *out_type)
2421 {
2422 CString str=ref;
2423 CString shortname;
2424 REF_TYPE type = CGit::UNKNOWN;
2425
2426 if (CGit::GetShortName(str, shortname, _T("refs/heads/")))
2427 {
2428 type = CGit::LOCAL_BRANCH;
2429
2430 }
2431 else if (CGit::GetShortName(str, shortname, _T("refs/remotes/")))
2432 {
2433 type = CGit::REMOTE_BRANCH;
2434 }
2435 else if (CGit::GetShortName(str, shortname, _T("refs/tags/")))
2436 {
2437 type = CGit::TAG;
2438 }
2439 else if (CGit::GetShortName(str, shortname, _T("refs/stash")))
2440 {
2441 type = CGit::STASH;
2442 shortname=_T("stash");
2443 }
2444 else if (CGit::GetShortName(str, shortname, _T("refs/bisect/")))
2445 {
2446 if (shortname.Find(_T("good")) == 0)
2447 {
2448 type = CGit::BISECT_GOOD;
2449 shortname = _T("good");
2450 }
2451
2452 if (shortname.Find(_T("bad")) == 0)
2453 {
2454 type = CGit::BISECT_BAD;
2455 shortname = _T("bad");
2456 }
2457 }
2458 else if (CGit::GetShortName(str, shortname, _T("refs/notes/")))
2459 {
2460 type = CGit::NOTES;
2461 }
2462 else if (CGit::GetShortName(str, shortname, _T("refs/")))
2463 {
2464 type = CGit::UNKNOWN;
2465 }
2466 else
2467 {
2468 type = CGit::UNKNOWN;
2469 shortname = ref;
2470 }
2471
2472 if(out_type)
2473 *out_type = type;
2474
2475 return shortname;
2476 }
2477
2478 bool CGit::UsingLibGit2(LIBGIT2_CMD cmd) const
2479 {
2480 return m_IsUseLibGit2 && ((1 << cmd) & m_IsUseLibGit2_mask) ? true : false;
2481 }
2482
2483 CString CGit::GetUnifiedDiffCmd(const CTGitPath& path, const git_revnum_t& rev1, const git_revnum_t& rev2, bool bMerge, bool bCombine, int diffContext)
2484 {
2485 CString cmd;
2486 if (rev2 == GitRev::GetWorkingCopy())
2487 cmd.Format(_T("git.exe diff --stat -p %s --"), rev1);
2488 else if (rev1 == GitRev::GetWorkingCopy())
2489 cmd.Format(_T("git.exe diff -R --stat -p %s --"), rev2);
2490 else
2491 {
2492 CString merge;
2493 if (bMerge)
2494 merge += _T(" -m");
2495
2496 if (bCombine)
2497 merge += _T(" -c");
2498
2499 CString unified;
2500 if (diffContext > 0)
2501 unified.Format(_T(" --unified=%d"), diffContext);
2502 cmd.Format(_T("git.exe diff-tree -r -p %s %s --stat %s %s --"), merge, unified, rev1, rev2);
2503 }
2504
2505 if (!path.IsEmpty())
2506 {
2507 cmd += _T(" \"");
2508 cmd += path.GetGitPathString();
2509 cmd += _T("\"");
2510 }
2511
2512 return cmd;
2513 }
2514
2515 static int UnifiedDiffToFile(const git_diff_delta * /* delta */, const git_diff_hunk * /* hunk */, const git_diff_line * line, void *payload)
2516 {
2517 ATLASSERT(payload && line);
2518 if (line->origin == GIT_DIFF_LINE_CONTEXT || line->origin == GIT_DIFF_LINE_ADDITION || line->origin == GIT_DIFF_LINE_DELETION)
2519 fwrite(&line->origin, 1, 1, (FILE *)payload);
2520 fwrite(line->content, 1, line->content_len, (FILE *)payload);
2521 return 0;
2522 }
2523
2524 static int resolve_to_tree(git_repository *repo, const char *identifier, git_tree **tree)
2525 {
2526 ATLASSERT(repo && identifier && tree);
2527
2528 /* try to resolve identifier */
2529 CAutoObject obj;
2530 if (git_revparse_single(obj.GetPointer(), repo, identifier))
2531 return -1;
2532
2533 if (obj == nullptr)
2534 return GIT_ENOTFOUND;
2535
2536 int err = 0;
2537 switch (git_object_type(obj))
2538 {
2539 case GIT_OBJ_TREE:
2540 *tree = (git_tree *)obj.Detach();
2541 break;
2542 case GIT_OBJ_COMMIT:
2543 err = git_commit_tree(tree, (git_commit *)(git_object*)obj);
2544 break;
2545 default:
2546 err = GIT_ENOTFOUND;
2547 }
2548
2549 return err;
2550 }
2551
2552 /* use libgit2 get unified diff */
2553 static int GetUnifiedDiffLibGit2(const CTGitPath& path, const git_revnum_t& revOld, const git_revnum_t& revNew, git_diff_line_cb callback, void *data, bool /* bMerge */)
2554 {
2555 CStringA tree1 = CUnicodeUtils::GetMulti(revNew, CP_UTF8);
2556 CStringA tree2 = CUnicodeUtils::GetMulti(revOld, CP_UTF8);
2557
2558 CAutoRepository repo(g_Git.GetGitRepository());
2559 if (!repo)
2560 return -1;
2561
2562 int isHeadOrphan = git_repository_head_unborn(repo);
2563 if (isHeadOrphan == 1)
2564 return 0;
2565 else if (isHeadOrphan != 0)
2566 return -1;
2567
2568 git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
2569 CStringA pathA = CUnicodeUtils::GetMulti(path.GetGitPathString(), CP_UTF8);
2570 char *buf = pathA.GetBuffer();
2571 if (!pathA.IsEmpty())
2572 {
2573 opts.pathspec.strings = &buf;
2574 opts.pathspec.count = 1;
2575 }
2576 CAutoDiff diff;
2577
2578 if (revNew == GitRev::GetWorkingCopy() || revOld == GitRev::GetWorkingCopy())
2579 {
2580 CAutoTree t1;
2581 CAutoDiff diff2;
2582
2583 if (revNew != GitRev::GetWorkingCopy() && resolve_to_tree(repo, tree1, t1.GetPointer()))
2584 return -1;
2585
2586 if (revOld != GitRev::GetWorkingCopy() && resolve_to_tree(repo, tree2, t1.GetPointer()))
2587 return -1;
2588
2589 if (git_diff_tree_to_index(diff.GetPointer(), repo, t1, nullptr, &opts))
2590 return -1;
2591
2592 if (git_diff_index_to_workdir(diff2.GetPointer(), repo, nullptr, &opts))
2593 return -1;
2594
2595 if (git_diff_merge(diff, diff2))
2596 return -1;
2597 }
2598 else
2599 {
2600 if (tree1.IsEmpty() && tree2.IsEmpty())
2601 return -1;
2602
2603 if (tree1.IsEmpty())
2604 {
2605 tree1 = tree2;
2606 tree2.Empty();
2607 }
2608
2609 CAutoTree t1;
2610 CAutoTree t2;
2611 if (!tree1.IsEmpty() && resolve_to_tree(repo, tree1, t1.GetPointer()))
2612 return -1;
2613
2614 if (tree2.IsEmpty())
2615 {
2616 /* don't check return value, there are not parent commit at first commit*/
2617 resolve_to_tree(repo, tree1 + "~1", t2.GetPointer());
2618 }
2619 else if (resolve_to_tree(repo, tree2, t2.GetPointer()))
2620 return -1;
2621 if (git_diff_tree_to_tree(diff.GetPointer(), repo, t2, t1, &opts))
2622 return -1;
2623 }
2624
2625 for (size_t i = 0; i < git_diff_num_deltas(diff); ++i)
2626 {
2627 CAutoPatch patch;
2628 if (git_patch_from_diff(patch.GetPointer(), diff, i))
2629 return -1;
2630
2631 if (git_patch_print(patch, callback, data))
2632 return -1;
2633 }
2634
2635 pathA.ReleaseBuffer();
2636
2637 return 0;
2638 }
2639
2640 int CGit::GetUnifiedDiff(const CTGitPath& path, const git_revnum_t& rev1, const git_revnum_t& rev2, CString patchfile, bool bMerge, bool bCombine, int diffContext)
2641 {
2642 if (UsingLibGit2(GIT_CMD_DIFF))
2643 {
2644 FILE *file = nullptr;
2645 _tfopen_s(&file, patchfile, _T("w"));
2646 if (file == nullptr)
2647 return -1;
2648 int ret = GetUnifiedDiffLibGit2(path, rev1, rev2, UnifiedDiffToFile, file, bMerge);
2649 fclose(file);
2650 return ret;
2651 }
2652 else
2653 {
2654 CString cmd;
2655 cmd = GetUnifiedDiffCmd(path, rev1, rev2, bMerge, bCombine, diffContext);
2656 return RunLogFile(cmd, patchfile, &gitLastErr);
2657 }
2658 }
2659
2660 static int UnifiedDiffToStringA(const git_diff_delta * /*delta*/, const git_diff_hunk * /*hunk*/, const git_diff_line *line, void *payload)
2661 {
2662 ATLASSERT(payload && line);
2663 CStringA *str = (CStringA*) payload;
2664 if (line->origin == GIT_DIFF_LINE_CONTEXT || line->origin == GIT_DIFF_LINE_ADDITION || line->origin == GIT_DIFF_LINE_DELETION)
2665 str->Append(&line->origin, 1);
2666 str->Append(line->content, (int)line->content_len);
2667 return 0;
2668 }
2669
2670 int CGit::GetUnifiedDiff(const CTGitPath& path, const git_revnum_t& rev1, const git_revnum_t& rev2, CStringA * buffer, bool bMerge, bool bCombine, int diffContext)
2671 {
2672 if (UsingLibGit2(GIT_CMD_DIFF))
2673 return GetUnifiedDiffLibGit2(path, rev1, rev2, UnifiedDiffToStringA, buffer, bMerge);
2674 else
2675 {
2676 CString cmd;
2677 cmd = GetUnifiedDiffCmd(path, rev1, rev2, bMerge, bCombine, diffContext);
2678 BYTE_VECTOR vector;
2679 int ret = Run(cmd, &vector);
2680 if (!vector.empty())
2681 {
2682 vector.push_back(0); // vector is not NUL terminated
2683 buffer->Append((char *)&vector[0]);
2684 }
2685 return ret;
2686 }
2687 }
2688
2689 int CGit::GitRevert(int parent, const CGitHash &hash)
2690 {
2691 if (UsingLibGit2(GIT_CMD_REVERT))
2692 {
2693 CAutoRepository repo(GetGitRepository());
2694 if (!repo)
2695 return -1;
2696
2697 CAutoCommit commit;
2698 if (git_commit_lookup(commit.GetPointer(), repo, (const git_oid *)hash.m_hash))
2699 return -1;
2700
2701 git_revert_options revert_opts = GIT_REVERT_OPTIONS_INIT;
2702 revert_opts.mainline = parent;
2703 int result = git_revert(repo, commit, &revert_opts);
2704
2705 return !result ? 0 : -1;
2706 }
2707 else
2708 {
2709 CString cmd, merge;
2710 if (parent)
2711 merge.Format(_T("-m %d "), parent);
2712 cmd.Format(_T("git.exe revert --no-edit --no-commit %s%s"), merge, hash.ToString());
2713 gitLastErr = cmd + _T("\n");
2714 if (Run(cmd, &gitLastErr, CP_UTF8))
2715 {
2716 return -1;
2717 }
2718 else
2719 {
2720 gitLastErr.Empty();
2721 return 0;
2722 }
2723 }
2724 }
2725
2726 int CGit::DeleteRef(const CString& reference)
2727 {
2728 if (UsingLibGit2(GIT_CMD_DELETETAGBRANCH))
2729 {
2730 CAutoRepository repo(GetGitRepository());
2731 if (!repo)
2732 return -1;
2733
2734 CStringA refA;
2735 if (reference.Right(3) == _T("^{}"))
2736 refA = CUnicodeUtils::GetUTF8(reference.Left(reference.GetLength() - 3));
2737 else
2738 refA = CUnicodeUtils::GetUTF8(reference);
2739
2740 CAutoReference ref;
2741 if (git_reference_lookup(ref.GetPointer(), repo, refA))
2742 return -1;
2743
2744 int result = -1;
2745 if (git_reference_is_tag(ref))
2746 result = git_tag_delete(repo, git_reference_shorthand(ref));
2747 else if (git_reference_is_branch(ref))
2748 result = git_branch_delete(ref);
2749 else if (git_reference_is_remote(ref))
2750 result = git_branch_delete(ref);
2751 else
2752 giterr_set_str(GITERR_REFERENCE, CUnicodeUtils::GetUTF8(L"unsupported reference type: " + reference));
2753
2754 return result;
2755 }
2756 else
2757 {
2758 CString cmd, shortname;
2759 if (GetShortName(reference, shortname, _T("refs/heads/")))
2760 cmd.Format(_T("git.exe branch -D -- %s"), shortname);
2761 else if (GetShortName(reference, shortname, _T("refs/tags/")))
2762 cmd.Format(_T("git.exe tag -d -- %s"), shortname);
2763 else if (GetShortName(reference, shortname, _T("refs/remotes/")))
2764 cmd.Format(_T("git.exe branch -r -D -- %s"), shortname);
2765 else
2766 {
2767 gitLastErr = L"unsupported reference type: " + reference;
2768 return -1;
2769 }
2770
2771 if (Run(cmd, &gitLastErr, CP_UTF8))
2772 return -1;
2773
2774 gitLastErr.Empty();
2775 return 0;
2776 }
2777 }
2778
2779 bool CGit::LoadTextFile(const CString &filename, CString &msg)
2780 {
2781 if (PathFileExists(filename))
2782 {
2783 FILE *pFile = nullptr;
2784 _tfopen_s(&pFile, filename, _T("r"));
2785 if (pFile)
2786 {
2787 CStringA str;
2788 do
2789 {
2790 char s[8196] = { 0 };
2791 int read = (int)fread(s, sizeof(char), sizeof(s), pFile);
2792 if (read == 0)
2793 break;
2794 str += CStringA(s, read);
2795 } while (true);
2796 fclose(pFile);
2797 msg = CUnicodeUtils::GetUnicode(str);
2798 msg.Replace(_T("\r\n"), _T("\n"));
2799 msg.TrimRight(_T("\n"));
2800 msg += _T("\n");
2801 }
2802 else
2803 ::MessageBox(nullptr, _T("Could not open ") + filename, _T("TortoiseGit"), MB_ICONERROR);
2804 return true; // load no further files
2805 }
2806 return false;
2807 }
Windows Explorer Extension to Operate Git