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