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