?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
No need to retrieve whole commit
[TortoiseGit.git] / src / Git / Git.cpp
blob0941779ffa2118056e635e8912102bc9e30dbcab
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(const wchar_t* symbolicRefName, bool bStripRefsHeads)
715 {
716 CString refName;
717 if(this->m_IsUseGitDLL)
718 {
719 unsigned char sha1[20] = { 0 };
720 int flag = 0;
721
722 CAutoLocker lock(g_Git.m_critGitDllSec);
723 const char *refs_heads_master = nullptr;
724 try
725 {
726 refs_heads_master = git_resolve_ref(CUnicodeUtils::GetUTF8(CString(symbolicRefName)), sha1, 0, &flag);
727 }
728 catch (const char *err)
729 {
730 ::MessageBox(NULL, _T("Could not resolve ref ") + CString(symbolicRefName) + _T(".\nlibgit reports:\n") + CString(err), _T("TortoiseGit"), MB_OK | MB_ICONERROR);
731 }
732 if(refs_heads_master && (flag&REF_ISSYMREF))
733 {
734 StringAppend(&refName,(BYTE*)refs_heads_master);
735 if(bStripRefsHeads)
736 refName = StripRefName(refName);
737 }
738
739 }
740 else
741 {
742 CString cmd;
743 cmd.Format(L"git.exe symbolic-ref %s", symbolicRefName);
744 if (Run(cmd, &refName, NULL, CP_UTF8) != 0)
745 return CString();//Error
746 int iStart = 0;
747 refName = refName.Tokenize(L"\n", iStart);
748 if(bStripRefsHeads)
749 refName = StripRefName(refName);
750 }
751 return refName;
752 }
753
754 CString CGit::GetFullRefName(const CString& shortRefName)
755 {
756 CString refName;
757 CString cmd;
758 cmd.Format(L"git.exe rev-parse --symbolic-full-name %s", shortRefName);
759 if (Run(cmd, &refName, NULL, CP_UTF8) != 0)
760 return CString();//Error
761 int iStart = 0;
762 return refName.Tokenize(L"\n", iStart);
763 }
764
765 CString CGit::StripRefName(CString refName)
766 {
767 if(wcsncmp(refName, L"refs/heads/", 11) == 0)
768 refName = refName.Mid(11);
769 else if(wcsncmp(refName, L"refs/", 5) == 0)
770 refName = refName.Mid(5);
771 int start =0;
772 return refName.Tokenize(_T("\n"),start);
773 }
774
775 int CGit::GetCurrentBranchFromFile(const CString &sProjectRoot, CString &sBranchOut, bool fallback)
776 {
777 // read current branch name like git-gui does, by parsing the .git/HEAD file directly
778
779 if ( sProjectRoot.IsEmpty() )
780 return -1;
781
782 CString sDotGitPath;
783 if (!g_GitAdminDir.GetAdminDirPath(sProjectRoot, sDotGitPath))
784 return -1;
785
786 CString sHeadFile = sDotGitPath + _T("HEAD");
787
788 FILE *pFile;
789 _tfopen_s(&pFile, sHeadFile.GetString(), _T("r"));
790
791 if (!pFile)
792 {
793 return -1;
794 }
795
796 char s[256] = {0};
797 fgets(s, sizeof(s), pFile);
798
799 fclose(pFile);
800
801 const char *pfx = "ref: refs/heads/";
802 const int len = 16;//strlen(pfx)
803
804 if ( !strncmp(s, pfx, len) )
805 {
806 //# We're on a branch. It might not exist. But
807 //# HEAD looks good enough to be a branch.
808 CStringA utf8Branch(s + len);
809 sBranchOut = CUnicodeUtils::GetUnicode(utf8Branch);
810 sBranchOut.TrimRight(_T(" \r\n\t"));
811
812 if ( sBranchOut.IsEmpty() )
813 return -1;
814 }
815 else if (fallback)
816 {
817 CStringA utf8Hash(s);
818 CString unicodeHash = CUnicodeUtils::GetUnicode(utf8Hash);
819 unicodeHash.TrimRight(_T(" \r\n\t"));
820 if (CGitHash::IsValidSHA1(unicodeHash))
821 sBranchOut = unicodeHash;
822 else
823 //# Assume this is a detached head.
824 sBranchOut = _T("HEAD");
825 return 1;
826 }
827 else
828 {
829 //# Assume this is a detached head.
830 sBranchOut = "HEAD";
831
832 return 1;
833 }
834
835 return 0;
836 }
837
838 int CGit::BuildOutputFormat(CString &format,bool IsFull)
839 {
840 CString log;
841 log.Format(_T("#<%c>%%x00"),LOG_REV_ITEM_BEGIN);
842 format += log;
843 if(IsFull)
844 {
845 log.Format(_T("#<%c>%%an%%x00"),LOG_REV_AUTHOR_NAME);
846 format += log;
847 log.Format(_T("#<%c>%%ae%%x00"),LOG_REV_AUTHOR_EMAIL);
848 format += log;
849 log.Format(_T("#<%c>%%ai%%x00"),LOG_REV_AUTHOR_DATE);
850 format += log;
851 log.Format(_T("#<%c>%%cn%%x00"),LOG_REV_COMMIT_NAME);
852 format += log;
853 log.Format(_T("#<%c>%%ce%%x00"),LOG_REV_COMMIT_EMAIL);
854 format += log;
855 log.Format(_T("#<%c>%%ci%%x00"),LOG_REV_COMMIT_DATE);
856 format += log;
857 log.Format(_T("#<%c>%%b%%x00"),LOG_REV_COMMIT_BODY);
858 format += log;
859 }
860
861 log.Format(_T("#<%c>%%m%%H%%x00"),LOG_REV_COMMIT_HASH);
862 format += log;
863 log.Format(_T("#<%c>%%P%%x00"),LOG_REV_COMMIT_PARENT);
864 format += log;
865 log.Format(_T("#<%c>%%s%%x00"),LOG_REV_COMMIT_SUBJECT);
866 format += log;
867
868 if(IsFull)
869 {
870 log.Format(_T("#<%c>%%x00"),LOG_REV_COMMIT_FILE);
871 format += log;
872 }
873 return 0;
874 }
875
876 CString CGit::GetLogCmd(const CString &range, const CTGitPath *path, int count, int mask, bool paramonly,
877 CFilterData *Filter)
878 {
879 CString cmd;
880 CString num;
881 CString since;
882
883 CString file = _T(" --");
884
885 if(path)
886 file.Format(_T(" -- \"%s\""),path->GetGitPathString());
887
888 if(count>0)
889 num.Format(_T("-n%d"),count);
890
891 CString param;
892
893 if(mask& LOG_INFO_STAT )
894 param += _T(" --numstat ");
895 if(mask& LOG_INFO_FILESTATE)
896 param += _T(" --raw ");
897
898 if(mask& LOG_INFO_FULLHISTORY)
899 param += _T(" --full-history ");
900
901 if(mask& LOG_INFO_BOUNDARY)
902 param += _T(" --left-right --boundary ");
903
904 if(mask& CGit::LOG_INFO_ALL_BRANCH)
905 param += _T(" --all ");
906
907 if(mask & CGit::LOG_INFO_LOCAL_BRANCHES)
908 param += _T(" --branches ");
909
910 if(mask& CGit::LOG_INFO_DETECT_COPYRENAME)
911 param += _T(" -C ");
912
913 if(mask& CGit::LOG_INFO_DETECT_RENAME )
914 param += _T(" -M ");
915
916 if(mask& CGit::LOG_INFO_FIRST_PARENT )
917 param += _T(" --first-parent ");
918
919 if(mask& CGit::LOG_INFO_NO_MERGE )
920 param += _T(" --no-merges ");
921
922 if(mask& CGit::LOG_INFO_FOLLOW)
923 param += _T(" --follow ");
924
925 if(mask& CGit::LOG_INFO_SHOW_MERGEDFILE)
926 param += _T(" -c ");
927
928 if(mask& CGit::LOG_INFO_FULL_DIFF)
929 param += _T(" --full-diff ");
930
931 if(mask& CGit::LOG_INFO_SIMPILFY_BY_DECORATION)
932 param += _T(" --simplify-by-decoration ");
933
934 param += range;
935
936 CString st1,st2;
937
938 if( Filter && (Filter->m_From != -1))
939 {
940 st1.Format(_T(" --max-age=%I64u "), Filter->m_From);
941 param += st1;
942 }
943
944 if( Filter && (Filter->m_To != -1))
945 {
946 st2.Format(_T(" --min-age=%I64u "), Filter->m_To);
947 param += st2;
948 }
949
950 bool isgrep = false;
951 if( Filter && (!Filter->m_Author.IsEmpty()))
952 {
953 st1.Format(_T(" --author=\"%s\"" ),Filter->m_Author);
954 param += st1;
955 isgrep = true;
956 }
957
958 if( Filter && (!Filter->m_Committer.IsEmpty()))
959 {
960 st1.Format(_T(" --committer=\"%s\"" ),Filter->m_Author);
961 param += st1;
962 isgrep = true;
963 }
964
965 if( Filter && (!Filter->m_MessageFilter.IsEmpty()))
966 {
967 st1.Format(_T(" --grep=\"%s\"" ),Filter->m_MessageFilter);
968 param += st1;
969 isgrep = true;
970 }
971
972 if(Filter && isgrep)
973 {
974 if(!Filter->m_IsRegex)
975 param += _T(" --fixed-strings ");
976
977 param += _T(" --regexp-ignore-case --extended-regexp ");
978 }
979
980 DWORD logOrderBy = CRegDWORD(_T("Software\\TortoiseGit\\LogOrderBy"), LOG_ORDER_TOPOORDER);
981 if (logOrderBy == LOG_ORDER_TOPOORDER)
982 param += _T(" --topo-order");
983 else if (logOrderBy == LOG_ORDER_DATEORDER)
984 param += _T(" --date-order");
985
986 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
987 cmd.Format(_T("--ignore-this-parameter %s -z %s --parents "), num, param);
988 else
989 {
990 CString log;
991 BuildOutputFormat(log,!(mask&CGit::LOG_INFO_ONLY_HASH));
992 cmd.Format(_T("git.exe log %s -z %s --parents --pretty=format:\"%s\""),
993 num,param,log);
994 }
995
996 cmd += file;
997
998 return cmd;
999 }
1000 #define BUFSIZE 512
1001 void GetTempPath(CString &path)
1002 {
1003 TCHAR lpPathBuffer[BUFSIZE] = { 0 };
1004 DWORD dwRetVal;
1005 DWORD dwBufSize=BUFSIZE;
1006 dwRetVal = GetTortoiseGitTempPath(dwBufSize, // length of the buffer
1007 lpPathBuffer); // buffer for path
1008 if (dwRetVal > dwBufSize || (dwRetVal == 0))
1009 {
1010 path=_T("");
1011 }
1012 path.Format(_T("%s"),lpPathBuffer);
1013 }
1014 CString GetTempFile()
1015 {
1016 TCHAR lpPathBuffer[BUFSIZE] = { 0 };
1017 DWORD dwRetVal;
1018 DWORD dwBufSize=BUFSIZE;
1019 TCHAR szTempName[BUFSIZE] = { 0 };
1020 UINT uRetVal;
1021
1022 dwRetVal = GetTortoiseGitTempPath(dwBufSize, // length of the buffer
1023 lpPathBuffer); // buffer for path
1024 if (dwRetVal > dwBufSize || (dwRetVal == 0))
1025 {
1026 return _T("");
1027 }
1028 // Create a temporary file.
1029 uRetVal = GetTempFileName(lpPathBuffer, // directory for tmp files
1030 TEXT("Patch"), // temp file name prefix
1031 0, // create unique name
1032 szTempName); // buffer for name
1033
1034
1035 if (uRetVal == 0)
1036 {
1037 return _T("");
1038 }
1039
1040 return CString(szTempName);
1041
1042 }
1043
1044 DWORD GetTortoiseGitTempPath(DWORD nBufferLength, LPTSTR lpBuffer)
1045 {
1046 DWORD result = ::GetTempPath(nBufferLength, lpBuffer);
1047 if (result == 0) return 0;
1048 if (lpBuffer == NULL || (result + 13 > nBufferLength))
1049 {
1050 if (lpBuffer)
1051 lpBuffer[0] = '\0';
1052 return result + 13;
1053 }
1054
1055 _tcscat_s(lpBuffer, nBufferLength, _T("TortoiseGit\\"));
1056 CreateDirectory(lpBuffer, NULL);
1057
1058 return result + 13;
1059 }
1060
1061 int CGit::RunLogFile(CString cmd, const CString &filename, CString *stdErr)
1062 {
1063 STARTUPINFO si;
1064 PROCESS_INFORMATION pi;
1065 si.cb=sizeof(STARTUPINFO);
1066 GetStartupInfo(&si);
1067
1068 SECURITY_ATTRIBUTES psa={sizeof(psa),NULL,TRUE};;
1069 psa.bInheritHandle=TRUE;
1070
1071 HANDLE hReadErr, hWriteErr;
1072 if (!CreatePipe(&hReadErr, &hWriteErr, &psa, 0))
1073 {
1074 CString err = CFormatMessageWrapper();
1075 CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": could not open stderr pipe: %s\n"), err.Trim());
1076 return TGIT_GIT_ERROR_OPEN_PIP;
1077 }
1078
1079 HANDLE houtfile=CreateFile(filename,GENERIC_WRITE,FILE_SHARE_READ | FILE_SHARE_WRITE,
1080 &psa,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
1081
1082 if (houtfile == INVALID_HANDLE_VALUE)
1083 {
1084 CString err = CFormatMessageWrapper();
1085 CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": could not open stdout pipe: %s\n"), err.Trim());
1086 CloseHandle(hReadErr);
1087 CloseHandle(hWriteErr);
1088 return TGIT_GIT_ERROR_OPEN_PIP;
1089 }
1090
1091 si.wShowWindow = SW_HIDE;
1092 si.dwFlags = STARTF_USESTDHANDLES|STARTF_USESHOWWINDOW;
1093 si.hStdOutput = houtfile;
1094 si.hStdError = hWriteErr;
1095
1096 LPTSTR pEnv = (!m_Environment.empty()) ? &m_Environment[0]: NULL;
1097 DWORD dwFlags = pEnv ? CREATE_UNICODE_ENVIRONMENT : 0;
1098
1099 if(cmd.Find(_T("git")) == 0)
1100 cmd=CGit::ms_LastMsysGitDir+_T("\\")+cmd;
1101
1102 CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": executing %s\n"), cmd);
1103 if(!CreateProcess(NULL,(LPWSTR)cmd.GetString(), NULL,NULL,TRUE,dwFlags,pEnv,(LPWSTR)m_CurrentDir.GetString(),&si,&pi))
1104 {
1105 CString err = CFormatMessageWrapper();
1106 CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": failed to create Process: %s\n"), err.Trim());
1107 stdErr = &err;
1108 CloseHandle(hReadErr);
1109 CloseHandle(hWriteErr);
1110 CloseHandle(houtfile);
1111 return TGIT_GIT_ERROR_CREATE_PROCESS;
1112 }
1113
1114 BYTE_VECTOR stderrVector;
1115 CGitCall_ByteVector pcall(L"", nullptr, &stderrVector);
1116 HANDLE thread;
1117 ASYNCREADSTDERRTHREADARGS threadArguments;
1118 threadArguments.fileHandle = hReadErr;
1119 threadArguments.pcall = &pcall;
1120 thread = CreateThread(nullptr, 0, AsyncReadStdErrThread, &threadArguments, 0, nullptr);
1121
1122 WaitForSingleObject(pi.hProcess,INFINITE);
1123
1124 CloseHandle(hWriteErr);
1125 CloseHandle(hReadErr);
1126
1127 if (thread)
1128 WaitForSingleObject(thread, INFINITE);
1129
1130 stderrVector.push_back(0);
1131 StringAppend(stdErr, &(stderrVector[0]), CP_UTF8);
1132
1133 DWORD exitcode = 0;
1134 if (!GetExitCodeProcess(pi.hProcess, &exitcode))
1135 {
1136 CString err = CFormatMessageWrapper();
1137 CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": could not get exit code: %s\n"), err.Trim());
1138 return TGIT_GIT_ERROR_GET_EXIT_CODE;
1139 }
1140 else
1141 CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": process exited: %d\n"), exitcode);
1142
1143 CloseHandle(pi.hThread);
1144 CloseHandle(pi.hProcess);
1145 CloseHandle(houtfile);
1146 return exitcode;
1147 }
1148
1149 int CGit::GetHash(CGitHash &hash, const CString& friendname)
1150 {
1151 // no need to parse a ref if it's already a 40-byte hash
1152 if (CGitHash::IsValidSHA1(friendname))
1153 {
1154 hash = CGitHash(friendname);
1155 return 0;
1156 }
1157
1158 if (m_IsUseLibGit2)
1159 {
1160 git_repository *repo = NULL;
1161 CStringA gitdirA = CUnicodeUtils::GetMulti(CTGitPath(m_CurrentDir).GetGitPathString(), CP_UTF8);
1162 if (git_repository_open(&repo, gitdirA))
1163 return -1;
1164
1165 int isHeadOrphan = git_repository_head_unborn(repo);
1166 if (isHeadOrphan != 0)
1167 {
1168 git_repository_free(repo);
1169 hash.Empty();
1170 if (isHeadOrphan == 1)
1171 return 0;
1172 else
1173 return -1;
1174 }
1175
1176 CStringA refnameA = CUnicodeUtils::GetMulti(friendname, CP_UTF8);
1177
1178 git_object * gitObject = NULL;
1179 if (git_revparse_single(&gitObject, repo, refnameA))
1180 {
1181 git_repository_free(repo);
1182 return -1;
1183 }
1184
1185 const git_oid * oid = git_object_id(gitObject);
1186 if (oid == NULL)
1187 {
1188 git_object_free(gitObject);
1189 git_repository_free(repo);
1190 return -1;
1191 }
1192
1193 hash = CGitHash((char *)oid->id);
1194
1195 git_object_free(gitObject); // also frees oid
1196 git_repository_free(repo);
1197
1198 return 0;
1199 }
1200 else
1201 {
1202 CString cmd;
1203 cmd.Format(_T("git.exe rev-parse %s" ),FixBranchName(friendname));
1204 gitLastErr.Empty();
1205 int ret = Run(cmd, &gitLastErr, NULL, CP_UTF8);
1206 hash = CGitHash(gitLastErr.Trim());
1207 if (ret == 0)
1208 gitLastErr.Empty();
1209 return ret;
1210 }
1211 }
1212
1213 int CGit::GetInitAddList(CTGitPathList &outputlist)
1214 {
1215 CString cmd;
1216 BYTE_VECTOR cmdout;
1217
1218 cmd=_T("git.exe ls-files -s -t -z");
1219 outputlist.Clear();
1220 if (Run(cmd, &cmdout))
1221 return -1;
1222
1223 if (outputlist.ParserFromLsFile(cmdout))
1224 return -1;
1225 for(int i = 0; i < outputlist.GetCount(); ++i)
1226 const_cast<CTGitPath&>(outputlist[i]).m_Action = CTGitPath::LOGACTIONS_ADDED;
1227
1228 return 0;
1229 }
1230 int CGit::GetCommitDiffList(const CString &rev1, const CString &rev2, CTGitPathList &outputlist, bool ignoreSpaceAtEol, bool ignoreSpaceChange, bool ignoreAllSpace , bool ignoreBlankLines)
1231 {
1232 CString cmd;
1233 CString ignore;
1234 if (ignoreSpaceAtEol)
1235 ignore += _T(" --ignore-space-at-eol");
1236 if (ignoreSpaceChange)
1237 ignore += _T(" --ignore-space-change");
1238 if (ignoreAllSpace)
1239 ignore += _T(" --ignore-all-space");
1240 if (ignoreBlankLines)
1241 ignore += _T(" --ignore-blank-lines");
1242
1243 if(rev1 == GIT_REV_ZERO || rev2 == GIT_REV_ZERO)
1244 {
1245 //rev1=+_T("");
1246 if(rev1 == GIT_REV_ZERO)
1247 cmd.Format(_T("git.exe diff -r --raw -C -M --numstat -z %s %s --"), ignore, rev2);
1248 else
1249 cmd.Format(_T("git.exe diff -r -R --raw -C -M --numstat -z %s --"), ignore, rev1);
1250 }
1251 else
1252 {
1253 cmd.Format(_T("git.exe diff-tree -r --raw -C -M --numstat -z %s %s %s --"), ignore, rev2, rev1);
1254 }
1255
1256 BYTE_VECTOR out;
1257 if (Run(cmd, &out))
1258 return -1;
1259
1260 outputlist.ParserFromLog(out);
1261
1262 return 0;
1263 }
1264
1265 int addto_list_each_ref_fn(const char *refname, const unsigned char * /*sha1*/, int /*flags*/, void *cb_data)
1266 {
1267 STRING_VECTOR *list = (STRING_VECTOR*)cb_data;
1268 CString str;
1269 g_Git.StringAppend(&str, (BYTE*)refname, CP_UTF8);
1270 list->push_back(str);
1271 return 0;
1272 }
1273
1274 int CGit::GetTagList(STRING_VECTOR &list)
1275 {
1276 if (this->m_IsUseLibGit2)
1277 {
1278 git_repository *repo = NULL;
1279
1280 CStringA gitdir = CUnicodeUtils::GetMulti(CTGitPath(m_CurrentDir).GetGitPathString(), CP_UTF8);
1281 if (git_repository_open(&repo, gitdir))
1282 return -1;
1283
1284 git_strarray tag_names;
1285
1286 if (git_tag_list(&tag_names, repo))
1287 {
1288 git_repository_free(repo);
1289 return -1;
1290 }
1291
1292 for (size_t i = 0; i < tag_names.count; ++i)
1293 {
1294 CStringA tagName(tag_names.strings[i]);
1295 list.push_back(CUnicodeUtils::GetUnicode(tagName));
1296 }
1297
1298 git_strarray_free(&tag_names);
1299
1300 git_repository_free(repo);
1301
1302 std::sort(list.begin(), list.end(), LogicalComparePredicate);
1303
1304 return 0;
1305 }
1306 else
1307 {
1308 CString cmd, output;
1309 cmd=_T("git.exe tag -l");
1310 int ret = Run(cmd, &output, NULL, CP_UTF8);
1311 if(!ret)
1312 {
1313 int pos=0;
1314 CString one;
1315 while( pos>=0 )
1316 {
1317 one=output.Tokenize(_T("\n"),pos);
1318 if (!one.IsEmpty())
1319 list.push_back(one);
1320 }
1321 std::sort(list.begin(), list.end(), LogicalComparePredicate);
1322 }
1323 return ret;
1324 }
1325 }
1326
1327 /**
1328 Use this method only if m_IsUseLibGit2 is used for fallbacks.
1329 If you directly use libgit2 methods, use GetLibGit2LastErr instead.
1330 */
1331 CString CGit::GetGitLastErr(const CString& msg)
1332 {
1333 if (this->m_IsUseLibGit2)
1334 return GetLibGit2LastErr(msg);
1335 else if (gitLastErr.IsEmpty())
1336 return msg + _T("\nUnknown git.exe error.");
1337 else
1338 {
1339 CString lastError = gitLastErr;
1340 gitLastErr.Empty();
1341 return msg + _T("\n") + lastError;
1342 }
1343 }
1344
1345 CString CGit::GetGitLastErr(const CString& msg, LIBGIT2_CMD cmd)
1346 {
1347 if (UsingLibGit2(cmd))
1348 return GetLibGit2LastErr(msg);
1349 else if (gitLastErr.IsEmpty())
1350 return msg + _T("\nUnknown git.exe error.");
1351 else
1352 {
1353 CString lastError = gitLastErr;
1354 gitLastErr.Empty();
1355 return msg + _T("\n") + lastError;
1356 }
1357 }
1358
1359 CString CGit::GetLibGit2LastErr()
1360 {
1361 const git_error *libgit2err = giterr_last();
1362 if (libgit2err)
1363 {
1364 CString lastError = CUnicodeUtils::GetUnicode(CStringA(libgit2err->message));
1365 giterr_clear();
1366 return _T("libgit2 returned: ") + lastError;
1367 }
1368 else
1369 return _T("An error occoured in libgit2, but no message is available.");
1370 }
1371
1372 CString CGit::GetLibGit2LastErr(const CString& msg)
1373 {
1374 if (!msg.IsEmpty())
1375 return msg + _T("\n") + GetLibGit2LastErr();
1376 return GetLibGit2LastErr();
1377 }
1378
1379 CString CGit::FixBranchName_Mod(CString& branchName)
1380 {
1381 if(branchName == "FETCH_HEAD")
1382 branchName = DerefFetchHead();
1383 return branchName;
1384 }
1385
1386 CString CGit::FixBranchName(const CString& branchName)
1387 {
1388 CString tempBranchName = branchName;
1389 FixBranchName_Mod(tempBranchName);
1390 return tempBranchName;
1391 }
1392
1393 bool CGit::IsBranchTagNameUnique(const CString& name)
1394 {
1395 if (m_IsUseLibGit2)
1396 {
1397 git_repository *repo = nullptr;
1398
1399 if (git_repository_open(&repo, CUnicodeUtils::GetUTF8(CTGitPath(m_CurrentDir).GetGitPathString())))
1400 return true; // TODO: optimize error reporting
1401
1402 git_reference * tagRef = nullptr;
1403 if (git_reference_lookup(&tagRef, repo, CUnicodeUtils::GetUTF8(L"refs/tags/" + name)))
1404 {
1405 git_repository_free(repo);
1406 return true;
1407 }
1408 git_reference_free(tagRef);
1409
1410 git_reference * branchRef = nullptr;
1411 if (git_reference_lookup(&branchRef, repo, CUnicodeUtils::GetUTF8(L"refs/heads/" + name)))
1412 {
1413 git_repository_free(repo);
1414 return true;
1415 }
1416
1417 git_reference_free(branchRef);
1418 git_repository_free(repo);
1419
1420 return false;
1421 }
1422 // else
1423 CString output;
1424
1425 CString cmd;
1426 cmd.Format(_T("git.exe show-ref --tags --heads refs/heads/%s refs/tags/%s"), name, name);
1427 int ret = Run(cmd, &output, NULL, CP_UTF8);
1428 if (!ret)
1429 {
1430 int i = 0, pos = 0;
1431 while (pos >= 0)
1432 {
1433 if (!output.Tokenize(_T("\n"), pos).IsEmpty())
1434 ++i;
1435 }
1436 if (i >= 2)
1437 return false;
1438 }
1439
1440 return true;
1441 }
1442
1443 /*
1444 Checks if a branch or tag with the given name exists
1445 isBranch is true -> branch, tag otherwise
1446 */
1447 bool CGit::BranchTagExists(const CString& name, bool isBranch /*= true*/)
1448 {
1449 if (m_IsUseLibGit2)
1450 {
1451 git_repository *repo = nullptr;
1452
1453 if (git_repository_open(&repo, CUnicodeUtils::GetUTF8(CTGitPath(m_CurrentDir).GetGitPathString())))
1454 return false; // TODO: optimize error reporting
1455
1456 CString prefix;
1457 if (isBranch)
1458 prefix = _T("refs/heads/");
1459 else
1460 prefix = _T("refs/tags/");
1461
1462 git_reference * ref = nullptr;
1463 if (git_reference_lookup(&ref, repo, CUnicodeUtils::GetUTF8(prefix + name)))
1464 {
1465 git_repository_free(repo);
1466 return false;
1467 }
1468
1469 git_reference_free(ref);
1470 git_repository_free(repo);
1471
1472 return true;
1473 }
1474 // else
1475 CString cmd, output;
1476
1477 cmd = _T("git.exe show-ref ");
1478 if (isBranch)
1479 cmd += _T("--heads ");
1480 else
1481 cmd += _T("--tags ");
1482
1483 cmd += _T("refs/heads/") + name;
1484 cmd += _T(" refs/tags/") + name;
1485
1486 int ret = Run(cmd, &output, NULL, CP_UTF8);
1487 if (!ret)
1488 {
1489 if (!output.IsEmpty())
1490 return true;
1491 }
1492
1493 return false;
1494 }
1495
1496 CString CGit::DerefFetchHead()
1497 {
1498 CString dotGitPath;
1499 g_GitAdminDir.GetAdminDirPath(m_CurrentDir, dotGitPath);
1500 std::ifstream fetchHeadFile((dotGitPath + L"FETCH_HEAD").GetString(), std::ios::in | std::ios::binary);
1501 int forMergeLineCount = 0;
1502 std::string line;
1503 std::string hashToReturn;
1504 while(getline(fetchHeadFile, line))
1505 {
1506 //Tokenize this line
1507 std::string::size_type prevPos = 0;
1508 std::string::size_type pos = line.find('\t');
1509 if(pos == std::string::npos) continue; //invalid line
1510
1511 std::string hash = line.substr(0, pos);
1512 ++pos; prevPos = pos; pos = line.find('\t', pos); if(pos == std::string::npos) continue;
1513
1514 bool forMerge = pos == prevPos;
1515 ++pos; prevPos = pos; pos = line.size(); if(pos == std::string::npos) continue;
1516
1517 std::string remoteBranch = line.substr(prevPos, pos - prevPos);
1518
1519 //Process this line
1520 if(forMerge)
1521 {
1522 hashToReturn = hash;
1523 ++forMergeLineCount;
1524 if(forMergeLineCount > 1)
1525 return L""; //More then 1 branch to merge found. Octopus merge needed. Cannot pick single ref from FETCH_HEAD
1526 }
1527 }
1528
1529 return CUnicodeUtils::GetUnicode(hashToReturn.c_str());
1530 }
1531
1532 int CGit::GetBranchList(STRING_VECTOR &list,int *current,BRANCH_TYPE type)
1533 {
1534 int ret = 0;
1535 CString cur;
1536 if (m_IsUseLibGit2)
1537 {
1538 git_repository *repo = nullptr;
1539
1540 if (git_repository_open(&repo, CUnicodeUtils::GetUTF8(CTGitPath(m_CurrentDir).GetGitPathString())))
1541 return -1;
1542
1543 if (git_repository_head_detached(repo) == 1)
1544 cur = _T("(detached from ");
1545
1546 if ((type & (BRANCH_LOCAL | BRANCH_REMOTE)) != 0)
1547 {
1548 git_branch_iterator * it = nullptr;
1549
1550 git_branch_t flags = GIT_BRANCH_LOCAL;
1551 if ((type & BRANCH_LOCAL) && (type & BRANCH_REMOTE))
1552 flags = GIT_BRANCH_ALL;
1553 else if (type & BRANCH_REMOTE)
1554 flags = GIT_BRANCH_REMOTE;
1555
1556 if (git_branch_iterator_new(&it, repo, flags))
1557 {
1558 git_repository_free(repo);
1559 return -1;
1560 }
1561
1562 git_reference * ref = nullptr;
1563 git_branch_t branchType;
1564 while (git_branch_next(&ref, &branchType, it) == 0)
1565 {
1566 const char * name = nullptr;
1567 if (git_branch_name(&name, ref))
1568 continue;
1569 CString branchname = CUnicodeUtils::GetUnicode(name);
1570 if (branchType & GIT_BRANCH_REMOTE)
1571 list.push_back(_T("remotes/") + branchname);
1572 else
1573 {
1574 if (git_branch_is_head(ref))
1575 cur = branchname;
1576 list.push_back(branchname);
1577 }
1578 git_reference_free(ref);
1579 }
1580
1581 git_branch_iterator_free(it);
1582 }
1583 git_repository_free(repo);
1584 }
1585 else
1586 {
1587 CString cmd, output;
1588 cmd = _T("git.exe branch --no-color");
1589
1590 if ((type & BRANCH_ALL) == BRANCH_ALL)
1591 cmd += _T(" -a");
1592 else if (type & BRANCH_REMOTE)
1593 cmd += _T(" -r");
1594
1595 ret = Run(cmd, &output, nullptr, CP_UTF8);
1596 if (!ret)
1597 {
1598 int pos = 0;
1599 CString one;
1600 while (pos >= 0)
1601 {
1602 one = output.Tokenize(_T("\n"), pos);
1603 one.Trim(L" \r\n\t");
1604 if (one.Find(L" -> ") >= 0 || one.IsEmpty())
1605 continue; // skip something like: refs/origin/HEAD -> refs/origin/master
1606 if (one[0] == _T('*'))
1607 {
1608 one = one.Mid(2);
1609 cur = one;
1610 }
1611 if (one.Left(10) != _T("(no branch") && one.Left(15) != _T("(detached from "))
1612 list.push_back(one);
1613 }
1614 }
1615 }
1616
1617 if(type & BRANCH_FETCH_HEAD && !DerefFetchHead().IsEmpty())
1618 list.push_back(L"FETCH_HEAD");
1619
1620 std::sort(list.begin(), list.end(), LogicalCompareBranchesPredicate);
1621
1622 if (current && cur.Left(10) != _T("(no branch") && cur.Left(15) != _T("(detached from "))
1623 {
1624 for (unsigned int i = 0; i < list.size(); ++i)
1625 {
1626 if (list[i] == cur)
1627 {
1628 *current = i;
1629 break;
1630 }
1631 }
1632 }
1633
1634 return ret;
1635 }
1636
1637 int CGit::GetRemoteList(STRING_VECTOR &list)
1638 {
1639 if (this->m_IsUseLibGit2)
1640 {
1641 git_repository *repo = NULL;
1642
1643 CStringA gitdir = CUnicodeUtils::GetMulti(CTGitPath(m_CurrentDir).GetGitPathString(), CP_UTF8);
1644 if (git_repository_open(&repo, gitdir))
1645 return -1;
1646
1647 git_strarray remotes;
1648
1649 if (git_remote_list(&remotes, repo))
1650 {
1651 git_repository_free(repo);
1652 return -1;
1653 }
1654
1655 for (size_t i = 0; i < remotes.count; ++i)
1656 {
1657 CStringA remote(remotes.strings[i]);
1658 list.push_back(CUnicodeUtils::GetUnicode(remote));
1659 }
1660
1661 git_strarray_free(&remotes);
1662
1663 git_repository_free(repo);
1664
1665 std::sort(list.begin(), list.end());
1666
1667 return 0;
1668 }
1669 else
1670 {
1671 int ret;
1672 CString cmd, output;
1673 cmd=_T("git.exe remote");
1674 ret = Run(cmd, &output, NULL, CP_UTF8);
1675 if(!ret)
1676 {
1677 int pos=0;
1678 CString one;
1679 while( pos>=0 )
1680 {
1681 one=output.Tokenize(_T("\n"),pos);
1682 if (!one.IsEmpty())
1683 list.push_back(one);
1684 }
1685 }
1686 return ret;
1687 }
1688 }
1689
1690 int CGit::GetRemoteTags(const CString& remote, STRING_VECTOR &list)
1691 {
1692 CString cmd, out, err;
1693 cmd.Format(_T("git.exe ls-remote -t \"%s\""), remote);
1694 if (Run(cmd, &out, &err, CP_UTF8))
1695 {
1696 MessageBox(NULL, err, _T("TortoiseGit"), MB_ICONERROR);
1697 return -1;
1698 }
1699
1700 int pos = 0;
1701 while (pos >= 0)
1702 {
1703 CString one = out.Tokenize(_T("\n"), pos).Mid(51).Trim(); // sha1, tab + refs/tags/
1704 // dot not include annotated tags twice; this works, because an annotated tag appears twice (one normal tag and one with ^{} at the end)
1705 if (one.Find(_T("^{}")) >= 1)
1706 continue;
1707 if (!one.IsEmpty())
1708 list.push_back(one);
1709 }
1710 std::sort(list.begin(), list.end(), LogicalComparePredicate);
1711 return 0;
1712 }
1713
1714 int libgit2_addto_list_each_ref_fn(git_reference *ref, void *payload)
1715 {
1716 STRING_VECTOR *list = (STRING_VECTOR*)payload;
1717 CString str;
1718 g_Git.StringAppend(&str, (BYTE*)git_reference_name(ref), CP_UTF8);
1719 list->push_back(str);
1720 return 0;
1721 }
1722
1723 int CGit::GetRefList(STRING_VECTOR &list)
1724 {
1725 if (this->m_IsUseLibGit2)
1726 {
1727 git_repository *repo = NULL;
1728
1729 CStringA gitdir = CUnicodeUtils::GetMulti(CTGitPath(m_CurrentDir).GetGitPathString(), CP_UTF8);
1730 if (git_repository_open(&repo, gitdir))
1731 return -1;
1732
1733 if (git_reference_foreach(repo, libgit2_addto_list_each_ref_fn, &list))
1734 {
1735 git_repository_free(repo);
1736 return -1;
1737 }
1738
1739 git_repository_free(repo);
1740
1741 std::sort(list.begin(), list.end(), LogicalComparePredicate);
1742
1743 return 0;
1744 }
1745 else
1746 {
1747 CString cmd, output;
1748 cmd=_T("git.exe show-ref -d");
1749 int ret = Run(cmd, &output, NULL, CP_UTF8);
1750 if(!ret)
1751 {
1752 int pos=0;
1753 CString one;
1754 while( pos>=0 )
1755 {
1756 one=output.Tokenize(_T("\n"),pos);
1757 int start=one.Find(_T(" "),0);
1758 if(start>0)
1759 {
1760 CString name;
1761 name=one.Right(one.GetLength()-start-1);
1762 list.push_back(name);
1763 }
1764 }
1765 std::sort(list.begin(), list.end(), LogicalComparePredicate);
1766 }
1767 return ret;
1768 }
1769 }
1770
1771 typedef struct map_each_ref_payload {
1772 git_repository * repo;
1773 MAP_HASH_NAME * map;
1774 } map_each_ref_payload;
1775
1776 int libgit2_addto_map_each_ref_fn(git_reference *ref, void *payload)
1777 {
1778 map_each_ref_payload *payloadContent = (map_each_ref_payload*)payload;
1779
1780 CString str;
1781 g_Git.StringAppend(&str, (BYTE*)git_reference_name(ref), CP_UTF8);
1782
1783 git_object * gitObject = NULL;
1784
1785 do
1786 {
1787 if (git_revparse_single(&gitObject, payloadContent->repo, git_reference_name(ref)))
1788 {
1789 break;
1790 }
1791
1792 if (git_object_type(gitObject) == GIT_OBJ_TAG)
1793 {
1794 str += _T("^{}"); // deref tag
1795 git_object * derefedTag = NULL;
1796 if (git_object_peel(&derefedTag, gitObject, GIT_OBJ_ANY))
1797 {
1798 break;
1799 }
1800 git_object_free(gitObject);
1801 gitObject = derefedTag;
1802 }
1803
1804 const git_oid * oid = git_object_id(gitObject);
1805 if (oid == NULL)
1806 {
1807 break;
1808 }
1809
1810 CGitHash hash((char *)oid->id);
1811 (*payloadContent->map)[hash].push_back(str);
1812 } while (false);
1813
1814 if (gitObject)
1815 {
1816 git_object_free(gitObject);
1817 return 0;
1818 }
1819
1820 return 1;
1821 }
1822
1823 int CGit::GetMapHashToFriendName(MAP_HASH_NAME &map)
1824 {
1825 if (this->m_IsUseLibGit2)
1826 {
1827 git_repository *repo = NULL;
1828
1829 CStringA gitdir = CUnicodeUtils::GetMulti(CTGitPath(m_CurrentDir).GetGitPathString(), CP_UTF8);
1830 if (git_repository_open(&repo, gitdir))
1831 return -1;
1832
1833 map_each_ref_payload payloadContent = { repo, &map };
1834
1835 if (git_reference_foreach(repo, libgit2_addto_map_each_ref_fn, &payloadContent))
1836 {
1837 git_repository_free(repo);
1838 return -1;
1839 }
1840
1841 git_repository_free(repo);
1842
1843 for (auto it = map.begin(); it != map.end(); ++it)
1844 {
1845 std::sort(it->second.begin(), it->second.end());
1846 }
1847
1848 return 0;
1849 }
1850 else
1851 {
1852 CString cmd, output;
1853 cmd=_T("git.exe show-ref -d");
1854 int ret = Run(cmd, &output, NULL, CP_UTF8);
1855 if(!ret)
1856 {
1857 int pos=0;
1858 CString one;
1859 while( pos>=0 )
1860 {
1861 one=output.Tokenize(_T("\n"),pos);
1862 int start=one.Find(_T(" "),0);
1863 if(start>0)
1864 {
1865 CString name;
1866 name=one.Right(one.GetLength()-start-1);
1867
1868 CString hash;
1869 hash=one.Left(start);
1870
1871 map[CGitHash(hash)].push_back(name);
1872 }
1873 }
1874 }
1875 return ret;
1876 }
1877 }
1878
1879 static void SetLibGit2SearchPath(int level, const CString &value)
1880 {
1881 CStringA valueA = CUnicodeUtils::GetMulti(value, CP_UTF8);
1882 git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, level, valueA);
1883 }
1884
1885 static void SetLibGit2TemplatePath(const CString &value)
1886 {
1887 CStringA valueA = CUnicodeUtils::GetMulti(value, CP_UTF8);
1888 git_libgit2_opts(GIT_OPT_SET_TEMPLATE_PATH, valueA);
1889 }
1890
1891 BOOL CGit::CheckMsysGitDir(BOOL bFallback)
1892 {
1893 if (m_bInitialized)
1894 {
1895 return TRUE;
1896 }
1897
1898 this->m_Environment.clear();
1899 m_Environment.CopyProcessEnvironment();
1900
1901 TCHAR *oldpath;
1902 size_t homesize,size;
1903
1904 // set HOME if not set already
1905 _tgetenv_s(&homesize, NULL, 0, _T("HOME"));
1906 if (!homesize)
1907 m_Environment.SetEnv(_T("HOME"), GetHomeDirectory());
1908
1909 //setup ssh client
1910 CString sshclient=CRegString(_T("Software\\TortoiseGit\\SSH"));
1911 if (sshclient.IsEmpty())
1912 sshclient = CRegString(_T("Software\\TortoiseGit\\SSH"), _T(""), FALSE, HKEY_LOCAL_MACHINE);
1913
1914 if(!sshclient.IsEmpty())
1915 {
1916 m_Environment.SetEnv(_T("GIT_SSH"), sshclient);
1917 m_Environment.SetEnv(_T("SVN_SSH"), sshclient);
1918 }
1919 else
1920 {
1921 TCHAR sPlink[MAX_PATH] = {0};
1922 GetModuleFileName(NULL, sPlink, _countof(sPlink));
1923 LPTSTR ptr = _tcsrchr(sPlink, _T('\\'));
1924 if (ptr) {
1925 _tcscpy_s(ptr + 1, MAX_PATH - (ptr - sPlink + 1), _T("TortoiseGitPLink.exe"));
1926 m_Environment.SetEnv(_T("GIT_SSH"), sPlink);
1927 m_Environment.SetEnv(_T("SVN_SSH"), sPlink);
1928 }
1929 }
1930
1931 {
1932 TCHAR sAskPass[MAX_PATH] = {0};
1933 GetModuleFileName(NULL, sAskPass, _countof(sAskPass));
1934 LPTSTR ptr = _tcsrchr(sAskPass, _T('\\'));
1935 if (ptr)
1936 {
1937 _tcscpy_s(ptr + 1, MAX_PATH - (ptr - sAskPass + 1), _T("SshAskPass.exe"));
1938 m_Environment.SetEnv(_T("DISPLAY"),_T(":9999"));
1939 m_Environment.SetEnv(_T("SSH_ASKPASS"),sAskPass);
1940 m_Environment.SetEnv(_T("GIT_ASKPASS"),sAskPass);
1941 }
1942 }
1943
1944 // add git/bin path to PATH
1945
1946 CRegString msysdir=CRegString(REG_MSYSGIT_PATH,_T(""),FALSE);
1947 CString str = msysdir;
1948 if(str.IsEmpty() || !FileExists(str + _T("\\git.exe")))
1949 {
1950 if (!bFallback)
1951 return FALSE;
1952
1953 CRegString msyslocalinstalldir = CRegString(REG_MSYSGIT_INSTALL_LOCAL, _T(""), FALSE, HKEY_CURRENT_USER);
1954 str = msyslocalinstalldir;
1955 str.TrimRight(_T("\\"));
1956 if (str.IsEmpty())
1957 {
1958 CRegString msysinstalldir = CRegString(REG_MSYSGIT_INSTALL, _T(""), FALSE, HKEY_LOCAL_MACHINE);
1959 str = msysinstalldir;
1960 str.TrimRight(_T("\\"));
1961 }
1962 if ( !str.IsEmpty() )
1963 {
1964 str += "\\bin";
1965 msysdir=str;
1966 CGit::ms_LastMsysGitDir = str;
1967 msysdir.write();
1968 }
1969 else
1970 {
1971 // search PATH if git/bin directory is already present
1972 if ( FindGitPath() )
1973 {
1974 m_bInitialized = TRUE;
1975 msysdir = CGit::ms_LastMsysGitDir;
1976 msysdir.write();
1977 return TRUE;
1978 }
1979
1980 return FALSE;
1981 }
1982 }
1983 else
1984 {
1985 CGit::ms_LastMsysGitDir = str;
1986 }
1987
1988 // check for git.exe existance (maybe it was deinstalled in the meantime)
1989 if (!FileExists(CGit::ms_LastMsysGitDir + _T("\\git.exe")))
1990 return FALSE;
1991
1992 // Configure libgit2 search paths
1993 CString msysGitDir;
1994 PathCanonicalize(msysGitDir.GetBufferSetLength(MAX_PATH), CGit::ms_LastMsysGitDir + _T("\\..\\etc"));
1995 msysGitDir.ReleaseBuffer();
1996 SetLibGit2SearchPath(GIT_CONFIG_LEVEL_SYSTEM, msysGitDir);
1997 SetLibGit2SearchPath(GIT_CONFIG_LEVEL_GLOBAL, g_Git.GetHomeDirectory());
1998 SetLibGit2SearchPath(GIT_CONFIG_LEVEL_XDG, g_Git.GetGitGlobalXDGConfigPath());
1999 CString msysGitTemplateDir;
2000 PathCanonicalize(msysGitTemplateDir.GetBufferSetLength(MAX_PATH), CGit::ms_LastMsysGitDir + _T("\\..\\share\\git-core\\templates"));
2001 msysGitTemplateDir.ReleaseBuffer();
2002 SetLibGit2TemplatePath(msysGitTemplateDir);
2003
2004 //set path
2005 _tdupenv_s(&oldpath,&size,_T("PATH"));
2006
2007 CString path;
2008 path.Format(_T("%s;%s"),oldpath,str + _T(";")+ (CString)CRegString(REG_MSYSGIT_EXTRA_PATH,_T(""),FALSE));
2009
2010 m_Environment.SetEnv(_T("PATH"), path);
2011
2012 CString str1 = m_Environment.GetEnv(_T("PATH"));
2013
2014 CString sOldPath = oldpath;
2015 free(oldpath);
2016
2017 m_bInitialized = TRUE;
2018 return true;
2019 }
2020
2021 CString CGit::GetHomeDirectory()
2022 {
2023 const wchar_t * homeDir = wget_windows_home_directory();
2024 return CString(homeDir, (int)wcslen(homeDir));
2025 }
2026
2027 CString CGit::GetGitLocalConfig()
2028 {
2029 CString path;
2030 g_GitAdminDir.GetAdminDirPath(m_CurrentDir, path);
2031 path += _T("config");
2032 return path;
2033 }
2034
2035 CStringA CGit::GetGitPathStringA(const CString &path)
2036 {
2037 return CUnicodeUtils::GetUTF8(CTGitPath(path).GetGitPathString());
2038 }
2039
2040 CString CGit::GetGitGlobalConfig()
2041 {
2042 return g_Git.GetHomeDirectory() + _T("\\.gitconfig");
2043 }
2044
2045 CString CGit::GetGitGlobalXDGConfigPath()
2046 {
2047 return g_Git.GetHomeDirectory() + _T("\\.config\\git");
2048 }
2049
2050 CString CGit::GetGitGlobalXDGConfig()
2051 {
2052 return g_Git.GetGitGlobalXDGConfigPath() + _T("\\config");
2053 }
2054
2055 CString CGit::GetGitSystemConfig()
2056 {
2057 const wchar_t * systemConfig = wget_msysgit_etc();
2058 return CString(systemConfig, (int)wcslen(systemConfig));
2059 }
2060
2061 BOOL CGit::CheckCleanWorkTree()
2062 {
2063 CString out;
2064 CString cmd;
2065 cmd=_T("git.exe rev-parse --verify HEAD");
2066
2067 if(Run(cmd,&out,CP_UTF8))
2068 return FALSE;
2069
2070 cmd=_T("git.exe update-index --ignore-submodules --refresh");
2071 if(Run(cmd,&out,CP_UTF8))
2072 return FALSE;
2073
2074 cmd=_T("git.exe diff-files --quiet --ignore-submodules");
2075 if(Run(cmd,&out,CP_UTF8))
2076 return FALSE;
2077
2078 cmd = _T("git.exe diff-index --cached --quiet HEAD --ignore-submodules --");
2079 if(Run(cmd,&out,CP_UTF8))
2080 return FALSE;
2081
2082 return TRUE;
2083 }
2084 int CGit::Revert(const CString& commit, const CTGitPathList &list, bool)
2085 {
2086 int ret;
2087 for (int i = 0; i < list.GetCount(); ++i)
2088 {
2089 ret = Revert(commit, (CTGitPath&)list[i]);
2090 if(ret)
2091 return ret;
2092 }
2093 return 0;
2094 }
2095 int CGit::Revert(const CString& commit, const CTGitPath &path)
2096 {
2097 CString cmd, out;
2098
2099 if(path.m_Action & CTGitPath::LOGACTIONS_REPLACED && !path.GetGitOldPathString().IsEmpty())
2100 {
2101 if (CTGitPath(path.GetGitOldPathString()).IsDirectory())
2102 {
2103 CString err;
2104 err.Format(_T("Cannot revert renaming of \"%s\". A directory with the old name \"%s\" exists."), path.GetGitPathString(), path.GetGitOldPathString());
2105 ::MessageBox(NULL, err, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
2106 return -1;
2107 }
2108 CString force;
2109 // if the filenames only differ in case, we have to pass "-f"
2110 if (path.GetGitPathString().CompareNoCase(path.GetGitOldPathString()) == 0)
2111 force = _T("-f ");
2112 cmd.Format(_T("git.exe mv %s-- \"%s\" \"%s\""), force, path.GetGitPathString(), path.GetGitOldPathString());
2113 if (Run(cmd, &out, CP_UTF8))
2114 {
2115 ::MessageBox(NULL, out, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
2116 return -1;
2117 }
2118
2119 cmd.Format(_T("git.exe checkout %s -f -- \"%s\""), commit, path.GetGitOldPathString());
2120 if (Run(cmd, &out, CP_UTF8))
2121 {
2122 ::MessageBox(NULL, out, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
2123 return -1;
2124 }
2125
2126 }
2127 else if(path.m_Action & CTGitPath::LOGACTIONS_ADDED)
2128 { //To init git repository, there are not HEAD, so we can use git reset command
2129 cmd.Format(_T("git.exe rm -f --cached -- \"%s\""),path.GetGitPathString());
2130
2131 if (Run(cmd, &out, CP_UTF8))
2132 {
2133 ::MessageBox(NULL, out, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
2134 return -1;
2135 }
2136 }
2137 else
2138 {
2139 cmd.Format(_T("git.exe checkout %s -f -- \"%s\""), commit, path.GetGitPathString());
2140 if (Run(cmd, &out, CP_UTF8))
2141 {
2142 ::MessageBox(NULL, out, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
2143 return -1;
2144 }
2145 }
2146
2147 if (path.m_Action & CTGitPath::LOGACTIONS_DELETED)
2148 {
2149 cmd.Format(_T("git.exe add -f -- \"%s\""), path.GetGitPathString());
2150 if (Run(cmd, &out, CP_UTF8))
2151 {
2152 ::MessageBox(NULL, out, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
2153 return -1;
2154 }
2155 }
2156
2157 return 0;
2158 }
2159
2160 int CGit::ListConflictFile(CTGitPathList &list, const CTGitPath *path)
2161 {
2162 BYTE_VECTOR vector;
2163
2164 CString cmd;
2165 if(path)
2166 cmd.Format(_T("git.exe ls-files -u -t -z -- \"%s\""),path->GetGitPathString());
2167 else
2168 cmd=_T("git.exe ls-files -u -t -z");
2169
2170 if (Run(cmd, &vector))
2171 {
2172 return -1;
2173 }
2174
2175 if (list.ParserFromLsFile(vector))
2176 return -1;
2177
2178 return 0;
2179 }
2180
2181 bool CGit::IsFastForward(const CString &from, const CString &to, CGitHash * commonAncestor)
2182 {
2183 if (UsingLibGit2(GIT_CMD_MERGE_BASE))
2184 {
2185 CGitHash fromHash, toHash, baseHash;
2186 if (GetHash(toHash, FixBranchName(to)))
2187 return false;
2188
2189 if (GetHash(fromHash, FixBranchName(from)))
2190 return false;
2191
2192 git_repository *repo = nullptr;
2193 if (git_repository_open(&repo, CUnicodeUtils::GetMulti(CTGitPath(m_CurrentDir).GetGitPathString(), CP_UTF8)))
2194 return false;
2195
2196 git_oid baseOid;
2197 if (git_merge_base(&baseOid, repo, (const git_oid*)toHash.m_hash, (const git_oid*)fromHash.m_hash))
2198 {
2199 git_repository_free(repo);
2200 return false;
2201 }
2202
2203 baseHash = baseOid.id;
2204
2205 if (commonAncestor)
2206 *commonAncestor = baseHash;
2207
2208 git_repository_free(repo);
2209
2210 return fromHash == baseHash;
2211 }
2212 // else
2213 CString base;
2214 CGitHash basehash,hash;
2215 CString cmd, err;
2216 cmd.Format(_T("git.exe merge-base %s %s"), FixBranchName(to), FixBranchName(from));
2217
2218 if (Run(cmd, &base, &err, CP_UTF8))
2219 {
2220 return false;
2221 }
2222 basehash = base.Trim();
2223
2224 GetHash(hash, from);
2225
2226 if (commonAncestor)
2227 *commonAncestor = basehash;
2228
2229 return hash == basehash;
2230 }
2231
2232 unsigned int CGit::Hash2int(const CGitHash &hash)
2233 {
2234 int ret=0;
2235 for (int i = 0; i < 4; ++i)
2236 {
2237 ret = ret << 8;
2238 ret |= hash.m_hash[i];
2239 }
2240 return ret;
2241 }
2242
2243 int CGit::RefreshGitIndex()
2244 {
2245 if(g_Git.m_IsUseGitDLL)
2246 {
2247 CAutoLocker lock(g_Git.m_critGitDllSec);
2248 try
2249 {
2250 return [] { return git_run_cmd("update-index","update-index -q --refresh"); }();
2251
2252 }catch(...)
2253 {
2254 return -1;
2255 }
2256
2257 }
2258 else
2259 {
2260 CString cmd,output;
2261 cmd=_T("git.exe update-index --refresh");
2262 return Run(cmd, &output, CP_UTF8);
2263 }
2264 }
2265
2266 int CGit::GetOneFile(const CString &Refname, const CTGitPath &path, const CString &outputfile)
2267 {
2268 if (UsingLibGit2(GIT_CMD_GETONEFILE))
2269 {
2270 CGitHash hash;
2271 if (GetHash(hash, Refname))
2272 return -1;
2273
2274 git_repository *repo = nullptr;
2275 if (git_repository_open(&repo, CUnicodeUtils::GetUTF8(CTGitPath(m_CurrentDir).GetGitPathString())))
2276 return -1;
2277
2278 git_commit * commit = nullptr;
2279 if (git_commit_lookup(&commit, repo, (const git_oid *)hash.m_hash))
2280 {
2281 git_repository_free(repo);
2282 return -1;
2283 }
2284
2285 git_tree * tree = nullptr;
2286 if (git_commit_tree(&tree, commit))
2287 {
2288 git_commit_free(commit);
2289 git_repository_free(repo);
2290 return -1;
2291 }
2292
2293 git_tree_entry * entry = nullptr;
2294 if (git_tree_entry_bypath(&entry, tree, CUnicodeUtils::GetUTF8(path.GetGitPathString())))
2295 {
2296 git_tree_free(tree);
2297 git_commit_free(commit);
2298 git_repository_free(repo);
2299 return -1;
2300 }
2301
2302 git_blob * blob = nullptr;
2303 if (git_tree_entry_to_object((git_object**)&blob, repo, entry))
2304 {
2305 git_tree_entry_free(entry);
2306 git_tree_free(tree);
2307 git_commit_free(commit);
2308 git_repository_free(repo);
2309 return -1;
2310 }
2311
2312 FILE *file = nullptr;
2313 _tfopen_s(&file, outputfile, _T("w"));
2314 if (file == nullptr)
2315 {
2316 giterr_set_str(GITERR_NONE, "Could not create file.");
2317 git_blob_free(blob);
2318 git_tree_entry_free(entry);
2319 git_tree_free(tree);
2320 git_commit_free(commit);
2321 git_repository_free(repo);
2322 return -1;
2323 }
2324 git_buf buf = { 0 };
2325 if (git_blob_filtered_content(&buf, blob, CUnicodeUtils::GetUTF8(path.GetGitPathString()), 0))
2326 {
2327 git_blob_free(blob);
2328 git_tree_entry_free(entry);
2329 git_tree_free(tree);
2330 git_commit_free(commit);
2331 git_repository_free(repo);
2332 return -1;
2333 }
2334 if (fwrite(buf.ptr, sizeof(char), buf.size, file) != buf.size)
2335 {
2336 giterr_set_str(GITERR_OS, "Could not write to file.");
2337 git_buf_free(&buf);
2338 fclose(file);
2339
2340 git_blob_free(blob);
2341 git_tree_entry_free(entry);
2342 git_tree_free(tree);
2343 git_commit_free(commit);
2344 git_repository_free(repo);
2345 return -1;
2346 }
2347 git_buf_free(&buf);
2348 fclose(file);
2349
2350 git_blob_free(blob);
2351 git_tree_entry_free(entry);
2352 git_tree_free(tree);
2353 git_commit_free(commit);
2354 git_repository_free(repo);
2355
2356 return 0;
2357 }
2358 else if (g_Git.m_IsUseGitDLL)
2359 {
2360 CAutoLocker lock(g_Git.m_critGitDllSec);
2361 try
2362 {
2363 g_Git.CheckAndInitDll();
2364 CStringA ref, patha, outa;
2365 ref = CUnicodeUtils::GetMulti(Refname, CP_UTF8);
2366 patha = CUnicodeUtils::GetMulti(path.GetGitPathString(), CP_UTF8);
2367 outa = CUnicodeUtils::GetMulti(outputfile, CP_UTF8);
2368 ::DeleteFile(outputfile);
2369 return git_checkout_file(ref, patha, outa);
2370
2371 }
2372 catch (const char * msg)
2373 {
2374 gitLastErr = L"gitdll.dll reports: " + CString(msg);
2375 return -1;
2376 }
2377 catch (...)
2378 {
2379 gitLastErr = L"An unknown gitdll.dll error occurred.";
2380 return -1;
2381 }
2382 }
2383 else
2384 {
2385 CString cmd;
2386 cmd.Format(_T("git.exe cat-file -p %s:\"%s\""), Refname, path.GetGitPathString());
2387 return RunLogFile(cmd, outputfile, &gitLastErr);
2388 }
2389 }
2390 void CEnvironment::CopyProcessEnvironment()
2391 {
2392 TCHAR *porig = GetEnvironmentStrings();
2393 TCHAR *p = porig;
2394 while(*p !=0 || *(p+1) !=0)
2395 this->push_back(*p++);
2396
2397 push_back(_T('\0'));
2398 push_back(_T('\0'));
2399
2400 FreeEnvironmentStrings(porig);
2401 }
2402
2403 CString CEnvironment::GetEnv(const TCHAR *name)
2404 {
2405 CString str;
2406 for (size_t i = 0; i < size(); ++i)
2407 {
2408 str = &(*this)[i];
2409 int start =0;
2410 CString sname = str.Tokenize(_T("="),start);
2411 if(sname.CompareNoCase(name) == 0)
2412 {
2413 return &(*this)[i+start];
2414 }
2415 i+=str.GetLength();
2416 }
2417 return _T("");
2418 }
2419
2420 void CEnvironment::SetEnv(const TCHAR *name, const TCHAR* value)
2421 {
2422 unsigned int i;
2423 for (i = 0; i < size(); ++i)
2424 {
2425 CString str = &(*this)[i];
2426 int start =0;
2427 CString sname = str.Tokenize(_T("="),start);
2428 if(sname.CompareNoCase(name) == 0)
2429 {
2430 break;
2431 }
2432 i+=str.GetLength();
2433 }
2434
2435 if(i == size())
2436 {
2437 i -= 1; // roll back terminate \0\0
2438 this->push_back(_T('\0'));
2439 }
2440
2441 CEnvironment::iterator it;
2442 it=this->begin();
2443 it += i;
2444
2445 while(*it && i<size())
2446 {
2447 this->erase(it);
2448 it=this->begin();
2449 it += i;
2450 }
2451
2452 while(*name)
2453 {
2454 this->insert(it,*name++);
2455 ++i;
2456 it= begin()+i;
2457 }
2458
2459 this->insert(it, _T('='));
2460 ++i;
2461 it= begin()+i;
2462
2463 while(*value)
2464 {
2465 this->insert(it,*value++);
2466 ++i;
2467 it= begin()+i;
2468 }
2469
2470 }
2471
2472 int CGit::GetGitEncode(TCHAR* configkey)
2473 {
2474 CString str=GetConfigValue(configkey);
2475
2476 if(str.IsEmpty())
2477 return CP_UTF8;
2478
2479 return CUnicodeUtils::GetCPCode(str);
2480 }
2481
2482
2483 int CGit::GetDiffPath(CTGitPathList *PathList, CGitHash *hash1, CGitHash *hash2, char *arg)
2484 {
2485 GIT_FILE file=0;
2486 int ret=0;
2487 GIT_DIFF diff=0;
2488
2489 CAutoLocker lock(g_Git.m_critGitDllSec);
2490
2491 if(arg == NULL)
2492 diff = GetGitDiff();
2493 else
2494 git_open_diff(&diff, arg);
2495
2496 if(diff ==NULL)
2497 return -1;
2498
2499 bool isStat = 0;
2500 if(arg == NULL)
2501 isStat = true;
2502 else
2503 isStat = !!strstr(arg, "stat");
2504
2505 int count=0;
2506
2507 if(hash2 == NULL)
2508 ret = git_root_diff(diff, hash1->m_hash, &file, &count,isStat);
2509 else
2510 ret = git_do_diff(diff,hash2->m_hash,hash1->m_hash,&file,&count,isStat);
2511
2512 if(ret)
2513 return -1;
2514
2515 CTGitPath path;
2516 CString strnewname;
2517 CString stroldname;
2518
2519 for (int j = 0; j < count; ++j)
2520 {
2521 path.Reset();
2522 char *newname;
2523 char *oldname;
2524
2525 strnewname.Empty();
2526 stroldname.Empty();
2527
2528 int mode=0,IsBin=0,inc=0,dec=0;
2529 git_get_diff_file(diff,file,j,&newname,&oldname,
2530 &mode,&IsBin,&inc,&dec);
2531
2532 StringAppend(&strnewname, (BYTE*)newname, CP_UTF8);
2533 StringAppend(&stroldname, (BYTE*)oldname, CP_UTF8);
2534
2535 path.SetFromGit(strnewname,&stroldname);
2536 path.ParserAction((BYTE)mode);
2537
2538 if(IsBin)
2539 {
2540 path.m_StatAdd=_T("-");
2541 path.m_StatDel=_T("-");
2542 }
2543 else
2544 {
2545 path.m_StatAdd.Format(_T("%d"),inc);
2546 path.m_StatDel.Format(_T("%d"),dec);
2547 }
2548 PathList->AddPath(path);
2549 }
2550 git_diff_flush(diff);
2551
2552 if(arg)
2553 git_close_diff(diff);
2554
2555 return 0;
2556 }
2557
2558 int CGit::GetShortHASHLength()
2559 {
2560 return 7;
2561 }
2562
2563 CString CGit::GetShortName(const CString& ref, REF_TYPE *out_type)
2564 {
2565 CString str=ref;
2566 CString shortname;
2567 REF_TYPE type = CGit::UNKNOWN;
2568
2569 if (CGit::GetShortName(str, shortname, _T("refs/heads/")))
2570 {
2571 type = CGit::LOCAL_BRANCH;
2572
2573 }
2574 else if (CGit::GetShortName(str, shortname, _T("refs/remotes/")))
2575 {
2576 type = CGit::REMOTE_BRANCH;
2577 }
2578 else if (CGit::GetShortName(str, shortname, _T("refs/tags/")))
2579 {
2580 type = CGit::TAG;
2581 }
2582 else if (CGit::GetShortName(str, shortname, _T("refs/stash")))
2583 {
2584 type = CGit::STASH;
2585 shortname=_T("stash");
2586 }
2587 else if (CGit::GetShortName(str, shortname, _T("refs/bisect/")))
2588 {
2589 if (shortname.Find(_T("good")) == 0)
2590 {
2591 type = CGit::BISECT_GOOD;
2592 shortname = _T("good");
2593 }
2594
2595 if (shortname.Find(_T("bad")) == 0)
2596 {
2597 type = CGit::BISECT_BAD;
2598 shortname = _T("bad");
2599 }
2600 }
2601 else if (CGit::GetShortName(str, shortname, _T("refs/notes/")))
2602 {
2603 type = CGit::NOTES;
2604 }
2605 else if (CGit::GetShortName(str, shortname, _T("refs/")))
2606 {
2607 type = CGit::UNKNOWN;
2608 }
2609 else
2610 {
2611 type = CGit::UNKNOWN;
2612 shortname = ref;
2613 }
2614
2615 if(out_type)
2616 *out_type = type;
2617
2618 return shortname;
2619 }
2620
2621 bool CGit::UsingLibGit2(LIBGIT2_CMD cmd)
2622 {
2623 return ((1 << cmd) & m_IsUseLibGit2_mask) ? true : false;
2624 }
2625
2626 CString CGit::GetUnifiedDiffCmd(const CTGitPath& path, const git_revnum_t& rev1, const git_revnum_t& rev2, bool bMerge, bool bCombine, int diffContext)
2627 {
2628 CString cmd;
2629 if (rev2 == GitRev::GetWorkingCopy())
2630 cmd.Format(_T("git.exe diff --stat -p %s --"), rev1);
2631 else if (rev1 == GitRev::GetWorkingCopy())
2632 cmd.Format(_T("git.exe diff -R --stat -p %s --"), rev2);
2633 else
2634 {
2635 CString merge;
2636 if (bMerge)
2637 merge += _T(" -m");
2638
2639 if (bCombine)
2640 merge += _T(" -c");
2641
2642 CString unified;
2643 if (diffContext > 0)
2644 unified.Format(_T(" --unified=%d"), diffContext);
2645 cmd.Format(_T("git.exe diff-tree -r -p %s %s --stat %s %s --"), merge, unified, rev1, rev2);
2646 }
2647
2648 if (!path.IsEmpty())
2649 {
2650 cmd += _T(" \"");
2651 cmd += path.GetGitPathString();
2652 cmd += _T("\"");
2653 }
2654
2655 return cmd;
2656 }
2657
2658 static int UnifiedDiffToFile(const git_diff_delta * /* delta */, const git_diff_hunk * /* hunk */, const git_diff_line * line, void *payload)
2659 {
2660 ATLASSERT(payload && line);
2661 if (line->origin == GIT_DIFF_LINE_CONTEXT || line->origin == GIT_DIFF_LINE_ADDITION || line->origin == GIT_DIFF_LINE_DELETION)
2662 fwrite(&line->origin, 1, 1, (FILE *)payload);
2663 fwrite(line->content, 1, line->content_len, (FILE *)payload);
2664 return 0;
2665 }
2666
2667 static int resolve_to_tree(git_repository *repo, const char *identifier, git_tree **tree)
2668 {
2669 ATLASSERT(repo && identifier && tree);
2670
2671 /* try to resolve identifier */
2672 git_object *obj = nullptr;
2673 if (git_revparse_single(&obj, repo, identifier))
2674 return -1;
2675
2676 if (obj == nullptr)
2677 return GIT_ENOTFOUND;
2678
2679 int err = 0;
2680 switch (git_object_type(obj))
2681 {
2682 case GIT_OBJ_TREE:
2683 *tree = (git_tree *)obj;
2684 break;
2685 case GIT_OBJ_COMMIT:
2686 err = git_commit_tree(tree, (git_commit *)obj);
2687 git_object_free(obj);
2688 break;
2689 default:
2690 err = GIT_ENOTFOUND;
2691 }
2692
2693 return err;
2694 }
2695
2696 /* use libgit2 get unified diff */
2697 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 */)
2698 {
2699 git_repository *repo = nullptr;
2700 CStringA gitdirA = CUnicodeUtils::GetMulti(CTGitPath(g_Git.m_CurrentDir).GetGitPathString(), CP_UTF8);
2701 CStringA tree1 = CUnicodeUtils::GetMulti(revNew, CP_UTF8);
2702 CStringA tree2 = CUnicodeUtils::GetMulti(revOld, CP_UTF8);
2703 int ret = 0;
2704
2705 if (git_repository_open(&repo, gitdirA))
2706 return -1;
2707
2708 int isHeadOrphan = git_repository_head_unborn(repo);
2709 if (isHeadOrphan != 0)
2710 {
2711 git_repository_free(repo);
2712 if (isHeadOrphan == 1)
2713 return 0;
2714 else
2715 return -1;
2716 }
2717
2718 git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
2719 CStringA pathA = CUnicodeUtils::GetMulti(path.GetGitPathString(), CP_UTF8);
2720 char *buf = pathA.GetBuffer();
2721 if (!pathA.IsEmpty())
2722 {
2723 opts.pathspec.strings = &buf;
2724 opts.pathspec.count = 1;
2725 }
2726 git_diff *diff = nullptr;
2727
2728 if (revNew == GitRev::GetWorkingCopy() || revOld == GitRev::GetWorkingCopy())
2729 {
2730 git_tree *t1 = nullptr;
2731 git_diff *diff2 = nullptr;
2732
2733 do
2734 {
2735 if (revNew != GitRev::GetWorkingCopy())
2736 {
2737 if (resolve_to_tree(repo, tree1, &t1))
2738 {
2739 ret = -1;
2740 break;
2741 }
2742 }
2743 if (revOld != GitRev::GetWorkingCopy())
2744 {
2745 if (resolve_to_tree(repo, tree2, &t1))
2746 {
2747 ret = -1;
2748 break;
2749 }
2750 }
2751
2752 ret = git_diff_tree_to_index(&diff, repo, t1, nullptr, &opts);
2753 if (ret)
2754 break;
2755
2756 ret = git_diff_index_to_workdir(&diff2, repo, nullptr, &opts);
2757 if (ret)
2758 break;
2759
2760 ret = git_diff_merge(diff, diff2);
2761 if (ret)
2762 break;
2763
2764 for (size_t i = 0; i < git_diff_num_deltas(diff); ++i)
2765 {
2766 git_patch *patch;
2767 if (git_patch_from_diff(&patch, diff, i))
2768 {
2769 ret = -1;
2770 break;
2771 }
2772
2773 if (git_patch_print(patch, callback, data))
2774 {
2775 git_patch_free(patch);
2776 ret = -1;
2777 break;
2778 }
2779
2780 git_patch_free(patch);
2781 }
2782 } while(0);
2783 if (diff)
2784 git_diff_free(diff);
2785 if (diff2)
2786 git_diff_free(diff2);
2787 if (t1)
2788 git_tree_free(t1);
2789 }
2790 else
2791 {
2792 git_tree *t1 = nullptr, *t2 = nullptr;
2793 do
2794 {
2795 if (tree1.IsEmpty() && tree2.IsEmpty())
2796 {
2797 ret = -1;
2798 break;
2799 }
2800
2801 if (tree1.IsEmpty())
2802 {
2803 tree1 = tree2;
2804 tree2.Empty();
2805 }
2806
2807 if (!tree1.IsEmpty() && resolve_to_tree(repo, tree1, &t1))
2808 {
2809 ret = -1;
2810 break;
2811 }
2812
2813 if (tree2.IsEmpty())
2814 {
2815 /* don't check return value, there are not parent commit at first commit*/
2816 resolve_to_tree(repo, tree1 + "~1", &t2);
2817 }
2818 else if (resolve_to_tree(repo, tree2, &t2))
2819 {
2820 ret = -1;
2821 break;
2822 }
2823 if (git_diff_tree_to_tree(&diff, repo, t2, t1, &opts))
2824 {
2825 ret = -1;
2826 break;
2827 }
2828
2829 for (size_t i = 0; i < git_diff_num_deltas(diff); ++i)
2830 {
2831 git_patch *patch;
2832 if (git_patch_from_diff(&patch, diff, i))
2833 {
2834 ret = -1;
2835 break;
2836 }
2837
2838 if (git_patch_print(patch, callback, data))
2839 {
2840 git_patch_free(patch);
2841 ret = -1;
2842 break;
2843 }
2844
2845 git_patch_free(patch);
2846 }
2847 } while(0);
2848
2849 if (diff)
2850 git_diff_free(diff);
2851 if (t1)
2852 git_tree_free(t1);
2853 if (t2)
2854 git_tree_free(t2);
2855 }
2856 git_repository_free(repo);
2857 pathA.ReleaseBuffer();
2858
2859 return ret;
2860 }
2861
2862 int CGit::GetUnifiedDiff(const CTGitPath& path, const git_revnum_t& rev1, const git_revnum_t& rev2, CString patchfile, bool bMerge, bool bCombine, int diffContext)
2863 {
2864 if (UsingLibGit2(GIT_CMD_DIFF))
2865 {
2866 FILE *file = nullptr;
2867 _tfopen_s(&file, patchfile, _T("w"));
2868 if (file == nullptr)
2869 return -1;
2870 int ret = GetUnifiedDiffLibGit2(path, rev1, rev2, UnifiedDiffToFile, file, bMerge);
2871 fclose(file);
2872 return ret;
2873 }
2874 else
2875 {
2876 CString cmd;
2877 cmd = GetUnifiedDiffCmd(path, rev1, rev2, bMerge, bCombine, diffContext);
2878 return g_Git.RunLogFile(cmd, patchfile, &gitLastErr);
2879 }
2880 }
2881
2882 static int UnifiedDiffToStringA(const git_diff_delta * /*delta*/, const git_diff_hunk * /*hunk*/, const git_diff_line *line, void *payload)
2883 {
2884 ATLASSERT(payload && line);
2885 CStringA *str = (CStringA*) payload;
2886 if (line->origin == GIT_DIFF_LINE_CONTEXT || line->origin == GIT_DIFF_LINE_ADDITION || line->origin == GIT_DIFF_LINE_DELETION)
2887 str->Append(&line->origin, 1);
2888 str->Append(line->content, (int)line->content_len);
2889 return 0;
2890 }
2891
2892 int CGit::GetUnifiedDiff(const CTGitPath& path, const git_revnum_t& rev1, const git_revnum_t& rev2, CStringA * buffer, bool bMerge, bool bCombine, int diffContext)
2893 {
2894 if (UsingLibGit2(GIT_CMD_DIFF))
2895 return GetUnifiedDiffLibGit2(path, rev1, rev2, UnifiedDiffToStringA, buffer, bMerge);
2896 else
2897 {
2898 CString cmd;
2899 cmd = GetUnifiedDiffCmd(path, rev1, rev2, bMerge, bCombine, diffContext);
2900 BYTE_VECTOR vector;
2901 int ret = Run(cmd, &vector);
2902 if (!vector.empty())
2903 {
2904 vector.push_back(0); // vector is not NUL terminated
2905 buffer->Append((char *)&vector[0]);
2906 }
2907 return ret;
2908 }
2909 }
2910
2911 int CGit::GitRevert(int parent, const CGitHash &hash)
2912 {
2913 if (UsingLibGit2(GIT_CMD_REVERT))
2914 {
2915 git_repository *repo = nullptr;
2916 CStringA gitdirA = CUnicodeUtils::GetUTF8(CTGitPath(m_CurrentDir).GetGitPathString());
2917 if (git_repository_open(&repo, gitdirA))
2918 return -1;
2919
2920 git_commit *commit = nullptr;
2921 if (git_commit_lookup(&commit, repo, (const git_oid *)hash.m_hash))
2922 {
2923 git_repository_free(repo);
2924 return -1;
2925 }
2926
2927 git_revert_options revert_opts = GIT_REVERT_OPTIONS_INIT;
2928 revert_opts.mainline = parent;
2929 int result = git_revert(repo, commit, &revert_opts);
2930
2931 git_commit_free(commit);
2932 git_repository_free(repo);
2933 return !result ? 0 : -1;
2934 }
2935 else
2936 {
2937 CString cmd, merge;
2938 if (parent)
2939 merge.Format(_T("-m %d "), parent);
2940 cmd.Format(_T("git.exe revert --no-edit --no-commit %s%s"), merge, hash.ToString());
2941 gitLastErr = cmd + _T("\n");
2942 if (g_Git.Run(cmd, &gitLastErr, CP_UTF8))
2943 {
2944 return -1;
2945 }
2946 else
2947 {
2948 gitLastErr.Empty();
2949 return 0;
2950 }
2951 }
2952 }
2953
2954 int CGit::DeleteRef(const CString& reference)
2955 {
2956 if (UsingLibGit2(GIT_CMD_DELETETAGBRANCH))
2957 {
2958 git_repository *repo = nullptr;
2959 if (git_repository_open(&repo, CUnicodeUtils::GetUTF8(CTGitPath(m_CurrentDir).GetGitPathString())))
2960 return -1;
2961
2962 git_reference *ref = nullptr;
2963 if (git_reference_lookup(&ref, repo, CUnicodeUtils::GetUTF8(reference)))
2964 {
2965 git_repository_free(repo);
2966 return -1;
2967 }
2968
2969 int result = -1;
2970 if (git_reference_is_tag(ref))
2971 result = git_tag_delete(repo, git_reference_shorthand(ref));
2972 else if (git_reference_is_branch(ref))
2973 result = git_branch_delete(ref);
2974 else if (git_reference_is_remote(ref))
2975 result = git_branch_delete(ref);
2976 else
2977 giterr_set_str(GITERR_REFERENCE, CUnicodeUtils::GetUTF8(L"unsupported reference type: " + reference));
2978
2979 git_reference_free(ref);
2980 git_repository_free(repo);
2981 return result;
2982 }
2983 else
2984 {
2985 CString cmd, shortname;
2986 if (GetShortName(reference, shortname, _T("refs/heads/")))
2987 cmd.Format(_T("git.exe branch -D -- %s"), shortname);
2988 else if (GetShortName(reference, shortname, _T("refs/tags/")))
2989 cmd.Format(_T("git.exe tag -d -- %s"), shortname);
2990 else if (GetShortName(reference, shortname, _T("refs/remotes/")))
2991 cmd.Format(_T("git.exe branch -r -D -- %s"), shortname);
2992 else
2993 {
2994 gitLastErr = L"unsupported reference type: " + reference;
2995 return -1;
2996 }
2997
2998 if (g_Git.Run(cmd, &gitLastErr, CP_UTF8))
2999 return -1;
3000
3001 gitLastErr.Empty();
3002 return 0;
3003 }
3004 }
3005
3006 bool CGit::LoadTextFile(const CString &filename, CString &msg)
3007 {
3008 if (PathFileExists(filename))
3009 {
3010 FILE *pFile = nullptr;
3011 _tfopen_s(&pFile, filename, _T("r"));
3012 if (pFile)
3013 {
3014 CStringA str;
3015 do
3016 {
3017 char s[8196] = { 0 };
3018 int read = (int)fread(s, sizeof(char), sizeof(s), pFile);
3019 if (read == 0)
3020 break;
3021 str += CStringA(s, read);
3022 } while (true);
3023 fclose(pFile);
3024 msg = CUnicodeUtils::GetUnicode(str);
3025 msg.Replace(_T("\r\n"), _T("\n"));
3026 msg.TrimRight(_T("\n"));
3027 msg += _T("\n");
3028 }
3029 else
3030 ::MessageBox(nullptr, _T("Could not open ") + filename, _T("TortoiseGit"), MB_ICONERROR);
3031 return true; // load no further files
3032 }
3033 return false;
3034 }
Windows Explorer Extension to Operate Git