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