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