?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Cache git.exe version while a TortoiseGit process is running
[TortoiseGit.git] / src / Git / Git.cpp
blob34500b85c26fb5a4f23afb0c7598146ba997a8e5
1 // TortoiseGit - a Windows shell extension for easy version control
2
3 // Copyright (C) 2008-2013 - 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];
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(CString &left, 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(CString &left, 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", this->GetGitEncode(L"i18n.commitencoding"));
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 = g_Git.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(void)
647 {
648 CString output;
649 //Run(_T("git.exe branch"),&branch);
650
651 if(this->GetCurrentBranchFromFile(this->m_CurrentDir,output))
652 {
653 return _T("(no branch)");
654 }
655 else
656 return output;
657
658 }
659
660 CString CGit::GetSymbolicRef(const wchar_t* symbolicRefName, bool bStripRefsHeads)
661 {
662 CString refName;
663 if(this->m_IsUseGitDLL)
664 {
665 unsigned char sha1[20];
666 int flag = 0;
667
668 CAutoLocker lock(g_Git.m_critGitDllSec);
669 const char *refs_heads_master = nullptr;
670 try
671 {
672 refs_heads_master = git_resolve_ref(CUnicodeUtils::GetUTF8(CString(symbolicRefName)), sha1, 0, &flag);
673 }
674 catch (const char *err)
675 {
676 ::MessageBox(NULL, _T("Could not resolve ref ") + CString(symbolicRefName) + _T(".\nlibgit reports:\n") + CString(err), _T("TortoiseGit"), MB_OK | MB_ICONERROR);
677 }
678 if(refs_heads_master && (flag&REF_ISSYMREF))
679 {
680 StringAppend(&refName,(BYTE*)refs_heads_master);
681 if(bStripRefsHeads)
682 refName = StripRefName(refName);
683 }
684
685 }
686 else
687 {
688 CString cmd;
689 cmd.Format(L"git symbolic-ref %s", symbolicRefName);
690 if (Run(cmd, &refName, NULL, CP_UTF8) != 0)
691 return CString();//Error
692 int iStart = 0;
693 refName = refName.Tokenize(L"\n", iStart);
694 if(bStripRefsHeads)
695 refName = StripRefName(refName);
696 }
697 return refName;
698 }
699
700 CString CGit::GetFullRefName(CString shortRefName)
701 {
702 CString refName;
703 CString cmd;
704 cmd.Format(L"git rev-parse --symbolic-full-name %s", shortRefName);
705 if (Run(cmd, &refName, NULL, CP_UTF8) != 0)
706 return CString();//Error
707 int iStart = 0;
708 return refName.Tokenize(L"\n", iStart);
709 }
710
711 CString CGit::StripRefName(CString refName)
712 {
713 if(wcsncmp(refName, L"refs/heads/", 11) == 0)
714 refName = refName.Mid(11);
715 else if(wcsncmp(refName, L"refs/", 5) == 0)
716 refName = refName.Mid(5);
717 int start =0;
718 return refName.Tokenize(_T("\n"),start);
719 }
720
721 int CGit::GetCurrentBranchFromFile(const CString &sProjectRoot, CString &sBranchOut)
722 {
723 // read current branch name like git-gui does, by parsing the .git/HEAD file directly
724
725 if ( sProjectRoot.IsEmpty() )
726 return -1;
727
728 CString sDotGitPath;
729 if (!g_GitAdminDir.GetAdminDirPath(sProjectRoot, sDotGitPath))
730 return -1;
731
732 CString sHeadFile = sDotGitPath + _T("HEAD");
733
734 FILE *pFile;
735 _tfopen_s(&pFile, sHeadFile.GetString(), _T("r"));
736
737 if (!pFile)
738 {
739 return -1;
740 }
741
742 char s[256] = {0};
743 fgets(s, sizeof(s), pFile);
744
745 fclose(pFile);
746
747 const char *pfx = "ref: refs/heads/";
748 const int len = 16;//strlen(pfx)
749
750 if ( !strncmp(s, pfx, len) )
751 {
752 //# We're on a branch. It might not exist. But
753 //# HEAD looks good enough to be a branch.
754 CStringA utf8Branch(s + len);
755 sBranchOut = CUnicodeUtils::GetUnicode(utf8Branch);
756 sBranchOut.TrimRight(_T(" \r\n\t"));
757
758 if ( sBranchOut.IsEmpty() )
759 return -1;
760 }
761 else
762 {
763 //# Assume this is a detached head.
764 sBranchOut = "HEAD";
765
766 return 1;
767 }
768
769 return 0;
770 }
771
772 int CGit::BuildOutputFormat(CString &format,bool IsFull)
773 {
774 CString log;
775 log.Format(_T("#<%c>%%x00"),LOG_REV_ITEM_BEGIN);
776 format += log;
777 if(IsFull)
778 {
779 log.Format(_T("#<%c>%%an%%x00"),LOG_REV_AUTHOR_NAME);
780 format += log;
781 log.Format(_T("#<%c>%%ae%%x00"),LOG_REV_AUTHOR_EMAIL);
782 format += log;
783 log.Format(_T("#<%c>%%ai%%x00"),LOG_REV_AUTHOR_DATE);
784 format += log;
785 log.Format(_T("#<%c>%%cn%%x00"),LOG_REV_COMMIT_NAME);
786 format += log;
787 log.Format(_T("#<%c>%%ce%%x00"),LOG_REV_COMMIT_EMAIL);
788 format += log;
789 log.Format(_T("#<%c>%%ci%%x00"),LOG_REV_COMMIT_DATE);
790 format += log;
791 log.Format(_T("#<%c>%%b%%x00"),LOG_REV_COMMIT_BODY);
792 format += log;
793 }
794
795 log.Format(_T("#<%c>%%m%%H%%x00"),LOG_REV_COMMIT_HASH);
796 format += log;
797 log.Format(_T("#<%c>%%P%%x00"),LOG_REV_COMMIT_PARENT);
798 format += log;
799 log.Format(_T("#<%c>%%s%%x00"),LOG_REV_COMMIT_SUBJECT);
800 format += log;
801
802 if(IsFull)
803 {
804 log.Format(_T("#<%c>%%x00"),LOG_REV_COMMIT_FILE);
805 format += log;
806 }
807 return 0;
808 }
809
810 CString CGit::GetLogCmd(CString &range, CTGitPath *path, int count, int mask, bool paramonly,
811 CFilterData *Filter)
812 {
813 CString cmd;
814 CString num;
815 CString since;
816
817 CString file;
818
819 if(path)
820 file.Format(_T(" -- \"%s\""),path->GetGitPathString());
821
822 if(count>0)
823 num.Format(_T("-n%d"),count);
824
825 CString param;
826
827 if(mask& LOG_INFO_STAT )
828 param += _T(" --numstat ");
829 if(mask& LOG_INFO_FILESTATE)
830 param += _T(" --raw ");
831
832 if(mask& LOG_INFO_FULLHISTORY)
833 param += _T(" --full-history ");
834
835 if(mask& LOG_INFO_BOUNDARY)
836 param += _T(" --left-right --boundary ");
837
838 if(mask& CGit::LOG_INFO_ALL_BRANCH)
839 param += _T(" --all ");
840
841 if(mask& CGit::LOG_INFO_DETECT_COPYRENAME)
842 param += _T(" -C ");
843
844 if(mask& CGit::LOG_INFO_DETECT_RENAME )
845 param += _T(" -M ");
846
847 if(mask& CGit::LOG_INFO_FIRST_PARENT )
848 param += _T(" --first-parent ");
849
850 if(mask& CGit::LOG_INFO_NO_MERGE )
851 param += _T(" --no-merges ");
852
853 if(mask& CGit::LOG_INFO_FOLLOW)
854 param += _T(" --follow ");
855
856 if(mask& CGit::LOG_INFO_SHOW_MERGEDFILE)
857 param += _T(" -c ");
858
859 if(mask& CGit::LOG_INFO_FULL_DIFF)
860 param += _T(" --full-diff ");
861
862 if(mask& CGit::LOG_INFO_SIMPILFY_BY_DECORATION)
863 param += _T(" --simplify-by-decoration ");
864
865 param += range;
866
867 CString st1,st2;
868
869 if( Filter && (Filter->m_From != -1))
870 {
871 st1.Format(_T(" --max-age=%I64u "), Filter->m_From);
872 param += st1;
873 }
874
875 if( Filter && (Filter->m_To != -1))
876 {
877 st2.Format(_T(" --min-age=%I64u "), Filter->m_To);
878 param += st2;
879 }
880
881 bool isgrep = false;
882 if( Filter && (!Filter->m_Author.IsEmpty()))
883 {
884 st1.Format(_T(" --author=\"%s\"" ),Filter->m_Author);
885 param += st1;
886 isgrep = true;
887 }
888
889 if( Filter && (!Filter->m_Committer.IsEmpty()))
890 {
891 st1.Format(_T(" --committer=\"%s\"" ),Filter->m_Author);
892 param += st1;
893 isgrep = true;
894 }
895
896 if( Filter && (!Filter->m_MessageFilter.IsEmpty()))
897 {
898 st1.Format(_T(" --grep=\"%s\"" ),Filter->m_MessageFilter);
899 param += st1;
900 isgrep = true;
901 }
902
903 if(Filter && isgrep)
904 {
905 if(!Filter->m_IsRegex)
906 param += _T(" --fixed-strings ");
907
908 param += _T(" --regexp-ignore-case --extended-regexp ");
909 }
910
911 DWORD logOrderBy = CRegDWORD(_T("Software\\TortoiseGit\\LogOrderBy"), LOG_ORDER_TOPOORDER);
912 if (logOrderBy == LOG_ORDER_TOPOORDER)
913 param += _T(" --topo-order");
914 else if (logOrderBy == LOG_ORDER_DATEORDER)
915 param += _T(" --date-order");
916
917 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
918 cmd.Format(_T("--ignore-this-parameter %s -z %s --parents "), num, param);
919 else
920 {
921 CString log;
922 BuildOutputFormat(log,!(mask&CGit::LOG_INFO_ONLY_HASH));
923 cmd.Format(_T("git.exe log %s -z %s --parents --pretty=format:\"%s\""),
924 num,param,log);
925 }
926
927 cmd += file;
928
929 return cmd;
930 }
931 #define BUFSIZE 512
932 void GetTempPath(CString &path)
933 {
934 TCHAR lpPathBuffer[BUFSIZE];
935 DWORD dwRetVal;
936 DWORD dwBufSize=BUFSIZE;
937 dwRetVal = GetTortoiseGitTempPath(dwBufSize, // length of the buffer
938 lpPathBuffer); // buffer for path
939 if (dwRetVal > dwBufSize || (dwRetVal == 0))
940 {
941 path=_T("");
942 }
943 path.Format(_T("%s"),lpPathBuffer);
944 }
945 CString GetTempFile()
946 {
947 TCHAR lpPathBuffer[BUFSIZE];
948 DWORD dwRetVal;
949 DWORD dwBufSize=BUFSIZE;
950 TCHAR szTempName[BUFSIZE];
951 UINT uRetVal;
952
953 dwRetVal = GetTortoiseGitTempPath(dwBufSize, // length of the buffer
954 lpPathBuffer); // buffer for path
955 if (dwRetVal > dwBufSize || (dwRetVal == 0))
956 {
957 return _T("");
958 }
959 // Create a temporary file.
960 uRetVal = GetTempFileName(lpPathBuffer, // directory for tmp files
961 TEXT("Patch"), // temp file name prefix
962 0, // create unique name
963 szTempName); // buffer for name
964
965
966 if (uRetVal == 0)
967 {
968 return _T("");
969 }
970
971 return CString(szTempName);
972
973 }
974
975 DWORD GetTortoiseGitTempPath(DWORD nBufferLength, LPTSTR lpBuffer)
976 {
977 DWORD result = ::GetTempPath(nBufferLength, lpBuffer);
978 if (result == 0) return 0;
979 if (lpBuffer == NULL || (result + 13 > nBufferLength))
980 {
981 if (lpBuffer)
982 lpBuffer[0] = '\0';
983 return result + 13;
984 }
985
986 _tcscat_s(lpBuffer, nBufferLength, _T("TortoiseGit\\"));
987 CreateDirectory(lpBuffer, NULL);
988
989 return result + 13;
990 }
991
992 int CGit::RunLogFile(CString cmd,const CString &filename)
993 {
994 STARTUPINFO si;
995 PROCESS_INFORMATION pi;
996 si.cb=sizeof(STARTUPINFO);
997 GetStartupInfo(&si);
998
999 SECURITY_ATTRIBUTES psa={sizeof(psa),NULL,TRUE};;
1000 psa.bInheritHandle=TRUE;
1001
1002 HANDLE houtfile=CreateFile(filename,GENERIC_WRITE,FILE_SHARE_READ | FILE_SHARE_WRITE,
1003 &psa,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
1004
1005 si.wShowWindow = SW_HIDE;
1006 si.dwFlags = STARTF_USESTDHANDLES|STARTF_USESHOWWINDOW;
1007 si.hStdOutput = houtfile;
1008
1009 LPTSTR pEnv = (!m_Environment.empty()) ? &m_Environment[0]: NULL;
1010 DWORD dwFlags = pEnv ? CREATE_UNICODE_ENVIRONMENT : 0;
1011
1012 if(cmd.Find(_T("git")) == 0)
1013 cmd=CGit::ms_LastMsysGitDir+_T("\\")+cmd;
1014
1015 CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": executing %s\n"), cmd);
1016 if(!CreateProcess(NULL,(LPWSTR)cmd.GetString(), NULL,NULL,TRUE,dwFlags,pEnv,(LPWSTR)m_CurrentDir.GetString(),&si,&pi))
1017 {
1018 LPVOID lpMsgBuf;
1019 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,
1020 NULL,GetLastError(),MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
1021 (LPTSTR)&lpMsgBuf,
1022 0,NULL);
1023 return TGIT_GIT_ERROR_CREATE_PROCESS;
1024 }
1025
1026 WaitForSingleObject(pi.hProcess,INFINITE);
1027
1028 CloseHandle(pi.hThread);
1029 CloseHandle(pi.hProcess);
1030 CloseHandle(houtfile);
1031 return TGIT_GIT_SUCCESS;
1032 // return 0;
1033 }
1034
1035 int CGit::GetHash(CGitHash &hash, TCHAR* friendname)
1036 {
1037 // no need to parse a ref if it's already a 40-byte hash
1038 if (CGitHash::IsValidSHA1(friendname))
1039 {
1040 CString sHash(friendname);
1041 hash = CGitHash(sHash);
1042 return 0;
1043 }
1044
1045 if (m_IsUseLibGit2)
1046 {
1047 git_repository *repo = NULL;
1048 CStringA gitdirA = CUnicodeUtils::GetMulti(CTGitPath(m_CurrentDir).GetGitPathString(), CP_UTF8);
1049 if (git_repository_open(&repo, gitdirA.GetBuffer()))
1050 {
1051 gitdirA.ReleaseBuffer();
1052 return -1;
1053 }
1054 gitdirA.ReleaseBuffer();
1055
1056 int isHeadOrphan = git_repository_head_orphan(repo);
1057 if (isHeadOrphan != 0)
1058 {
1059 git_repository_free(repo);
1060 hash.Empty();
1061 if (isHeadOrphan == 1)
1062 return 0;
1063 else
1064 return -1;
1065 }
1066
1067 CStringA refnameA = CUnicodeUtils::GetMulti(friendname, CP_UTF8);
1068
1069 git_object * gitObject = NULL;
1070 if (git_revparse_single(&gitObject, repo, refnameA.GetBuffer()))
1071 {
1072 refnameA.ReleaseBuffer();
1073 git_repository_free(repo);
1074 return -1;
1075 }
1076 refnameA.ReleaseBuffer();
1077
1078 const git_oid * oid = git_object_id(gitObject);
1079 if (oid == NULL)
1080 {
1081 git_object_free(gitObject);
1082 git_repository_free(repo);
1083 return -1;
1084 }
1085
1086 hash = CGitHash((char *)oid->id);
1087
1088 git_object_free(gitObject); // also frees oid
1089 git_repository_free(repo);
1090
1091 return 0;
1092 }
1093 else
1094 {
1095 CString cmd;
1096 cmd.Format(_T("git.exe rev-parse %s" ),FixBranchName(friendname));
1097 gitLastErr.Empty();
1098 int ret = Run(cmd, &gitLastErr, NULL, CP_UTF8);
1099 hash = CGitHash(gitLastErr.Trim());
1100 if (ret == 0)
1101 gitLastErr.Empty();
1102 return ret;
1103 }
1104 }
1105
1106 int CGit::GetInitAddList(CTGitPathList &outputlist)
1107 {
1108 CString cmd;
1109 BYTE_VECTOR cmdout;
1110
1111 cmd=_T("git.exe ls-files -s -t -z");
1112 outputlist.Clear();
1113 if (Run(cmd, &cmdout))
1114 return -1;
1115
1116 if (outputlist.ParserFromLsFile(cmdout))
1117 return -1;
1118 for(int i = 0; i < outputlist.GetCount(); ++i)
1119 const_cast<CTGitPath&>(outputlist[i]).m_Action = CTGitPath::LOGACTIONS_ADDED;
1120
1121 return 0;
1122 }
1123 int CGit::GetCommitDiffList(const CString &rev1,const CString &rev2,CTGitPathList &outputlist)
1124 {
1125 CString cmd;
1126
1127 if(rev1 == GIT_REV_ZERO || rev2 == GIT_REV_ZERO)
1128 {
1129 //rev1=+_T("");
1130 if(rev1 == GIT_REV_ZERO)
1131 cmd.Format(_T("git.exe diff -r --raw -C -M --numstat -z %s"),rev2);
1132 else
1133 cmd.Format(_T("git.exe diff -r -R --raw -C -M --numstat -z %s"),rev1);
1134 }
1135 else
1136 {
1137 cmd.Format(_T("git.exe diff-tree -r --raw -C -M --numstat -z %s %s"),rev2,rev1);
1138 }
1139
1140 BYTE_VECTOR out;
1141 if (Run(cmd, &out))
1142 return -1;
1143
1144 outputlist.ParserFromLog(out);
1145
1146 return 0;
1147 }
1148
1149 int addto_list_each_ref_fn(const char *refname, const unsigned char * /*sha1*/, int /*flags*/, void *cb_data)
1150 {
1151 STRING_VECTOR *list = (STRING_VECTOR*)cb_data;
1152 CString str;
1153 g_Git.StringAppend(&str, (BYTE*)refname, CP_UTF8);
1154 list->push_back(str);
1155 return 0;
1156 }
1157
1158 int CGit::GetTagList(STRING_VECTOR &list)
1159 {
1160 if (this->m_IsUseLibGit2)
1161 {
1162 git_repository *repo = NULL;
1163
1164 CStringA gitdir = CUnicodeUtils::GetMulti(CTGitPath(m_CurrentDir).GetGitPathString(), CP_UTF8);
1165 if (git_repository_open(&repo, gitdir.GetBuffer()))
1166 {
1167 gitdir.ReleaseBuffer();
1168 return -1;
1169 }
1170 gitdir.ReleaseBuffer();
1171
1172 git_strarray tag_names;
1173
1174 if (git_tag_list(&tag_names, repo))
1175 {
1176 git_repository_free(repo);
1177 return -1;
1178 }
1179
1180 for (size_t i = 0; i < tag_names.count; ++i)
1181 {
1182 CStringA tagName(tag_names.strings[i]);
1183 list.push_back(CUnicodeUtils::GetUnicode(tagName));
1184 }
1185
1186 git_strarray_free(&tag_names);
1187
1188 git_repository_free(repo);
1189
1190 std::sort(list.begin(), list.end(), LogicalComparePredicate);
1191
1192 return 0;
1193 }
1194 else
1195 {
1196 CString cmd, output;
1197 cmd=_T("git.exe tag -l");
1198 int ret = Run(cmd, &output, NULL, CP_UTF8);
1199 if(!ret)
1200 {
1201 int pos=0;
1202 CString one;
1203 while( pos>=0 )
1204 {
1205 one=output.Tokenize(_T("\n"),pos);
1206 if (!one.IsEmpty())
1207 list.push_back(one);
1208 }
1209 std::sort(list.begin(), list.end(), LogicalComparePredicate);
1210 }
1211 return ret;
1212 }
1213 }
1214
1215 /**
1216 Use this method only if m_IsUseLibGit2 is used for fallbacks.
1217 If you directly use libgit2 methods, use GetLibGit2LastErr instead.
1218 */
1219 CString CGit::GetGitLastErr(CString msg)
1220 {
1221 if (this->m_IsUseLibGit2)
1222 return GetLibGit2LastErr(msg);
1223 else if (gitLastErr.IsEmpty())
1224 return msg + _T("\nUnknown git.exe error.");
1225 else
1226 {
1227 CString lastError = gitLastErr;
1228 gitLastErr.Empty();
1229 return msg + _T("\n") + lastError;
1230 }
1231 }
1232
1233 CString CGit::GetLibGit2LastErr()
1234 {
1235 const git_error *libgit2err = giterr_last();
1236 if (libgit2err)
1237 {
1238 CString lastError = CUnicodeUtils::GetUnicode(CStringA(libgit2err->message));
1239 giterr_clear();
1240 return _T("libgit2 returned: ") + lastError;
1241 }
1242 else
1243 return _T("An error occoured in libgit2, but no message is available.");
1244 }
1245
1246 CString CGit::GetLibGit2LastErr(CString msg)
1247 {
1248 if (!msg.IsEmpty())
1249 return msg + _T("\n") + GetLibGit2LastErr();
1250 return GetLibGit2LastErr();
1251 }
1252
1253 CString CGit::FixBranchName_Mod(CString& branchName)
1254 {
1255 if(branchName == "FETCH_HEAD")
1256 branchName = DerefFetchHead();
1257 return branchName;
1258 }
1259
1260 CString CGit::FixBranchName(const CString& branchName)
1261 {
1262 CString tempBranchName = branchName;
1263 FixBranchName_Mod(tempBranchName);
1264 return tempBranchName;
1265 }
1266
1267 bool CGit::IsBranchTagNameUnique(const CString& name)
1268 {
1269 CString output;
1270
1271 CString cmd;
1272 cmd.Format(_T("git show-ref --tags --heads refs/heads/%s refs/tags/%s"), name, name);
1273 int ret = Run(cmd, &output, NULL, CP_UTF8);
1274 if (!ret)
1275 {
1276 int i = 0, pos = 0;
1277 while (pos >= 0)
1278 {
1279 if (!output.Tokenize(_T("\n"), pos).IsEmpty())
1280 ++i;
1281 }
1282 if (i >= 2)
1283 return false;
1284 }
1285
1286 return true;
1287 }
1288
1289 /*
1290 Checks if a branch or tag with the given name exists
1291 isBranch is true -> branch, tag otherwise
1292 */
1293 bool CGit::BranchTagExists(const CString& name, bool isBranch /*= true*/)
1294 {
1295 CString cmd, output;
1296
1297 cmd = _T("git show-ref ");
1298 if (isBranch)
1299 cmd += _T("--heads ");
1300 else
1301 cmd += _T("--tags ");
1302
1303 cmd += _T("refs/heads/") + name;
1304 cmd += _T(" refs/tags/") + name;
1305
1306 int ret = Run(cmd, &output, NULL, CP_UTF8);
1307 if (!ret)
1308 {
1309 if (!output.IsEmpty())
1310 return true;
1311 }
1312
1313 return false;
1314 }
1315
1316 CString CGit::DerefFetchHead()
1317 {
1318 CString dotGitPath;
1319 g_GitAdminDir.GetAdminDirPath(m_CurrentDir, dotGitPath);
1320 std::ifstream fetchHeadFile((dotGitPath + L"FETCH_HEAD").GetString(), std::ios::in | std::ios::binary);
1321 int forMergeLineCount = 0;
1322 std::string line;
1323 std::string hashToReturn;
1324 while(getline(fetchHeadFile, line))
1325 {
1326 //Tokenize this line
1327 std::string::size_type prevPos = 0;
1328 std::string::size_type pos = line.find('\t');
1329 if(pos == std::string::npos) continue; //invalid line
1330
1331 std::string hash = line.substr(0, pos);
1332 ++pos; prevPos = pos; pos = line.find('\t', pos); if(pos == std::string::npos) continue;
1333
1334 bool forMerge = pos == prevPos;
1335 ++pos; prevPos = pos; pos = line.size(); if(pos == std::string::npos) continue;
1336
1337 std::string remoteBranch = line.substr(prevPos, pos - prevPos);
1338
1339 //Process this line
1340 if(forMerge)
1341 {
1342 hashToReturn = hash;
1343 ++forMergeLineCount;
1344 if(forMergeLineCount > 1)
1345 return L""; //More then 1 branch to merge found. Octopus merge needed. Cannot pick single ref from FETCH_HEAD
1346 }
1347 }
1348
1349 return CUnicodeUtils::GetUnicode(hashToReturn.c_str());
1350 }
1351
1352 int CGit::GetBranchList(STRING_VECTOR &list,int *current,BRANCH_TYPE type)
1353 {
1354 int ret;
1355 CString cmd, output, cur;
1356 cmd = _T("git.exe branch --no-color");
1357
1358 if((type&BRANCH_ALL) == BRANCH_ALL)
1359 cmd += _T(" -a");
1360 else if(type&BRANCH_REMOTE)
1361 cmd += _T(" -r");
1362
1363 ret = Run(cmd, &output, NULL, CP_UTF8);
1364 if(!ret)
1365 {
1366 int pos=0;
1367 CString one;
1368 while( pos>=0 )
1369 {
1370 one=output.Tokenize(_T("\n"),pos);
1371 one.Trim(L" \r\n\t");
1372 if(one.Find(L" -> ") >= 0 || one.IsEmpty())
1373 continue; // skip something like: refs/origin/HEAD -> refs/origin/master
1374 if(one[0] == _T('*'))
1375 {
1376 one = one.Mid(2);
1377 cur = one;
1378 }
1379 if (one.Left(10) != _T("(no branch") && one.Left(15) != _T("(detached from "))
1380 list.push_back(one);
1381 }
1382 }
1383
1384 if(type & BRANCH_FETCH_HEAD && !DerefFetchHead().IsEmpty())
1385 list.push_back(L"FETCH_HEAD");
1386
1387 std::sort(list.begin(), list.end(), LogicalCompareBranchesPredicate);
1388
1389 if (current && cur.Left(10) != _T("(no branch") && cur.Left(15) != _T("(detached from "))
1390 {
1391 for (unsigned int i = 0; i < list.size(); ++i)
1392 {
1393 if (list[i] == cur)
1394 {
1395 *current = i;
1396 break;
1397 }
1398 }
1399 }
1400
1401 return ret;
1402 }
1403
1404 int CGit::GetRemoteList(STRING_VECTOR &list)
1405 {
1406 if (this->m_IsUseLibGit2)
1407 {
1408 git_repository *repo = NULL;
1409
1410 CStringA gitdir = CUnicodeUtils::GetMulti(CTGitPath(m_CurrentDir).GetGitPathString(), CP_UTF8);
1411 if (git_repository_open(&repo, gitdir.GetBuffer()))
1412 {
1413 gitdir.ReleaseBuffer();
1414 return -1;
1415 }
1416 gitdir.ReleaseBuffer();
1417
1418 git_strarray remotes;
1419
1420 if (git_remote_list(&remotes, repo))
1421 {
1422 git_repository_free(repo);
1423 return -1;
1424 }
1425
1426 for (size_t i = 0; i < remotes.count; ++i)
1427 {
1428 CStringA remote(remotes.strings[i]);
1429 list.push_back(CUnicodeUtils::GetUnicode(remote));
1430 }
1431
1432 git_strarray_free(&remotes);
1433
1434 git_repository_free(repo);
1435
1436 std::sort(list.begin(), list.end());
1437
1438 return 0;
1439 }
1440 else
1441 {
1442 int ret;
1443 CString cmd, output;
1444 cmd=_T("git.exe remote");
1445 ret = Run(cmd, &output, NULL, CP_UTF8);
1446 if(!ret)
1447 {
1448 int pos=0;
1449 CString one;
1450 while( pos>=0 )
1451 {
1452 one=output.Tokenize(_T("\n"),pos);
1453 if (!one.IsEmpty())
1454 list.push_back(one);
1455 }
1456 }
1457 return ret;
1458 }
1459 }
1460
1461 int CGit::GetRemoteTags(CString remote, STRING_VECTOR &list)
1462 {
1463 CString cmd, out, err;
1464 cmd.Format(_T("git.exe ls-remote -t \"%s\""), remote);
1465 if (Run(cmd, &out, &err, CP_UTF8))
1466 {
1467 MessageBox(NULL, err, _T("TortoiseGit"), MB_ICONERROR);
1468 return -1;
1469 }
1470
1471 int pos = 0;
1472 while (pos >= 0)
1473 {
1474 CString one = out.Tokenize(_T("\n"), pos).Mid(51).Trim(); // sha1, tab + refs/tags/
1475 // dot not include annotated tags twice; this works, because an annotated tag appears twice (one normal tag and one with ^{} at the end)
1476 if (one.Find(_T("^{}")) >= 1)
1477 continue;
1478 if (!one.IsEmpty())
1479 list.push_back(one);
1480 }
1481 std::sort(list.begin(), list.end(), LogicalComparePredicate);
1482 return 0;
1483 }
1484
1485 int libgit2_addto_list_each_ref_fn(git_reference *ref, void *payload)
1486 {
1487 STRING_VECTOR *list = (STRING_VECTOR*)payload;
1488 CString str;
1489 g_Git.StringAppend(&str, (BYTE*)git_reference_name(ref), CP_UTF8);
1490 list->push_back(str);
1491 return 0;
1492 }
1493
1494 int CGit::GetRefList(STRING_VECTOR &list)
1495 {
1496 if (this->m_IsUseLibGit2)
1497 {
1498 git_repository *repo = NULL;
1499
1500 CStringA gitdir = CUnicodeUtils::GetMulti(CTGitPath(m_CurrentDir).GetGitPathString(), CP_UTF8);
1501 if (git_repository_open(&repo, gitdir.GetBuffer()))
1502 {
1503 gitdir.ReleaseBuffer();
1504 return -1;
1505 }
1506 gitdir.ReleaseBuffer();
1507
1508 if (git_reference_foreach(repo, libgit2_addto_list_each_ref_fn, &list))
1509 {
1510 git_repository_free(repo);
1511 return -1;
1512 }
1513
1514 git_repository_free(repo);
1515
1516 std::sort(list.begin(), list.end(), LogicalComparePredicate);
1517
1518 return 0;
1519 }
1520 else
1521 {
1522 CString cmd, output;
1523 cmd=_T("git.exe show-ref -d");
1524 int ret = Run(cmd, &output, NULL, CP_UTF8);
1525 if(!ret)
1526 {
1527 int pos=0;
1528 CString one;
1529 while( pos>=0 )
1530 {
1531 one=output.Tokenize(_T("\n"),pos);
1532 int start=one.Find(_T(" "),0);
1533 if(start>0)
1534 {
1535 CString name;
1536 name=one.Right(one.GetLength()-start-1);
1537 list.push_back(name);
1538 }
1539 }
1540 std::sort(list.begin(), list.end(), LogicalComparePredicate);
1541 }
1542 return ret;
1543 }
1544 }
1545
1546 typedef struct map_each_ref_payload {
1547 git_repository * repo;
1548 MAP_HASH_NAME * map;
1549 } map_each_ref_payload;
1550
1551 int libgit2_addto_map_each_ref_fn(git_reference *ref, void *payload)
1552 {
1553 map_each_ref_payload *payloadContent = (map_each_ref_payload*)payload;
1554
1555 CString str;
1556 g_Git.StringAppend(&str, (BYTE*)git_reference_name(ref), CP_UTF8);
1557
1558 git_object * gitObject = NULL;
1559
1560 do
1561 {
1562 if (git_revparse_single(&gitObject, payloadContent->repo, git_reference_name(ref)))
1563 {
1564 break;
1565 }
1566
1567 if (git_object_type(gitObject) == GIT_OBJ_TAG)
1568 {
1569 str += _T("^{}"); // deref tag
1570 git_object * derefedTag = NULL;
1571 if (git_object_peel(&derefedTag, gitObject, GIT_OBJ_ANY))
1572 {
1573 break;
1574 }
1575 git_object_free(gitObject);
1576 gitObject = derefedTag;
1577 }
1578
1579 const git_oid * oid = git_object_id(gitObject);
1580 if (oid == NULL)
1581 {
1582 break;
1583 }
1584
1585 CGitHash hash((char *)oid->id);
1586 (*payloadContent->map)[hash].push_back(str);
1587 } while (false);
1588
1589 if (gitObject)
1590 {
1591 git_object_free(gitObject);
1592 return 0;
1593 }
1594
1595 return 1;
1596 }
1597
1598 int CGit::GetMapHashToFriendName(MAP_HASH_NAME &map)
1599 {
1600 if (this->m_IsUseLibGit2)
1601 {
1602 git_repository *repo = NULL;
1603
1604 CStringA gitdir = CUnicodeUtils::GetMulti(CTGitPath(m_CurrentDir).GetGitPathString(), CP_UTF8);
1605 if (git_repository_open(&repo, gitdir.GetBuffer()))
1606 {
1607 gitdir.ReleaseBuffer();
1608 return -1;
1609 }
1610 gitdir.ReleaseBuffer();
1611
1612 map_each_ref_payload payloadContent = { repo, &map };
1613
1614 if (git_reference_foreach(repo, libgit2_addto_map_each_ref_fn, &payloadContent))
1615 {
1616 git_repository_free(repo);
1617 return -1;
1618 }
1619
1620 git_repository_free(repo);
1621
1622 for (auto it = map.begin(); it != map.end(); ++it)
1623 {
1624 std::sort(it->second.begin(), it->second.end());
1625 }
1626
1627 return 0;
1628 }
1629 else
1630 {
1631 CString cmd, output;
1632 cmd=_T("git.exe show-ref -d");
1633 int ret = Run(cmd, &output, NULL, CP_UTF8);
1634 if(!ret)
1635 {
1636 int pos=0;
1637 CString one;
1638 while( pos>=0 )
1639 {
1640 one=output.Tokenize(_T("\n"),pos);
1641 int start=one.Find(_T(" "),0);
1642 if(start>0)
1643 {
1644 CString name;
1645 name=one.Right(one.GetLength()-start-1);
1646
1647 CString hash;
1648 hash=one.Left(start);
1649
1650 map[CGitHash(hash)].push_back(name);
1651 }
1652 }
1653 }
1654 return ret;
1655 }
1656 }
1657
1658 static void SetLibGit2SearchPath(int level, const CString &value)
1659 {
1660 CStringA valueA = CUnicodeUtils::GetMulti(value, CP_UTF8);
1661 git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, level, valueA.GetBuffer());
1662 valueA.ReleaseBuffer();
1663 }
1664
1665 BOOL CGit::CheckMsysGitDir()
1666 {
1667 if (m_bInitialized)
1668 {
1669 return TRUE;
1670 }
1671
1672 this->m_Environment.clear();
1673 m_Environment.CopyProcessEnvironment();
1674
1675 TCHAR *oldpath;
1676 size_t homesize,size;
1677
1678 // set HOME if not set already
1679 _tgetenv_s(&homesize, NULL, 0, _T("HOME"));
1680 if (!homesize)
1681 {
1682 CString home = GetHomeDirectory();
1683 m_Environment.SetEnv(_T("HOME"), home.GetBuffer());
1684 home.ReleaseBuffer();
1685 }
1686 CString str;
1687
1688 //setup ssh client
1689 CString sshclient=CRegString(_T("Software\\TortoiseGit\\SSH"));
1690 if (sshclient.IsEmpty())
1691 sshclient = CRegString(_T("Software\\TortoiseGit\\SSH"), _T(""), FALSE, HKEY_LOCAL_MACHINE);
1692
1693 if(!sshclient.IsEmpty())
1694 {
1695 m_Environment.SetEnv(_T("GIT_SSH"), sshclient.GetBuffer());
1696 m_Environment.SetEnv(_T("SVN_SSH"), sshclient.GetBuffer());
1697 }
1698 else
1699 {
1700 TCHAR sPlink[MAX_PATH];
1701 GetModuleFileName(NULL, sPlink, _countof(sPlink));
1702 LPTSTR ptr = _tcsrchr(sPlink, _T('\\'));
1703 if (ptr) {
1704 _tcscpy_s(ptr + 1, MAX_PATH - (ptr - sPlink + 1), _T("TortoiseGitPLink.exe"));
1705 m_Environment.SetEnv(_T("GIT_SSH"), sPlink);
1706 m_Environment.SetEnv(_T("SVN_SSH"), sPlink);
1707 }
1708 }
1709
1710 {
1711 TCHAR sAskPass[MAX_PATH];
1712 GetModuleFileName(NULL, sAskPass, _countof(sAskPass));
1713 LPTSTR ptr = _tcsrchr(sAskPass, _T('\\'));
1714 if (ptr)
1715 {
1716 _tcscpy_s(ptr + 1, MAX_PATH - (ptr - sAskPass + 1), _T("SshAskPass.exe"));
1717 m_Environment.SetEnv(_T("DISPLAY"),_T(":9999"));
1718 m_Environment.SetEnv(_T("SSH_ASKPASS"),sAskPass);
1719 m_Environment.SetEnv(_T("GIT_ASKPASS"),sAskPass);
1720 }
1721 }
1722
1723 // add git/bin path to PATH
1724
1725 CRegString msysdir=CRegString(REG_MSYSGIT_PATH,_T(""),FALSE);
1726 str=msysdir;
1727 if(str.IsEmpty() || !FileExists(str + _T("\\git.exe")))
1728 {
1729 CRegString msyslocalinstalldir = CRegString(REG_MSYSGIT_INSTALL_LOCAL, _T(""), FALSE, HKEY_CURRENT_USER);
1730 str = msyslocalinstalldir;
1731 str.TrimRight(_T("\\"));
1732 if (str.IsEmpty())
1733 {
1734 CRegString msysinstalldir = CRegString(REG_MSYSGIT_INSTALL, _T(""), FALSE, HKEY_LOCAL_MACHINE);
1735 str = msysinstalldir;
1736 str.TrimRight(_T("\\"));
1737 }
1738 if ( !str.IsEmpty() )
1739 {
1740 str += "\\bin";
1741 msysdir=str;
1742 CGit::ms_LastMsysGitDir = str;
1743 msysdir.write();
1744 }
1745 else
1746 {
1747 // search PATH if git/bin directory is already present
1748 if ( FindGitPath() )
1749 {
1750 m_bInitialized = TRUE;
1751 msysdir = CGit::ms_LastMsysGitDir;
1752 msysdir.write();
1753 return TRUE;
1754 }
1755
1756 return FALSE;
1757 }
1758 }
1759 else
1760 {
1761 CGit::ms_LastMsysGitDir = str;
1762 }
1763
1764 // check for git.exe existance (maybe it was deinstalled in the meantime)
1765 if (!FileExists(CGit::ms_LastMsysGitDir + _T("\\git.exe")))
1766 return FALSE;
1767
1768 // Configure libgit2 search paths
1769 CString msysGitDir;
1770 PathCanonicalize(msysGitDir.GetBufferSetLength(MAX_PATH), CGit::ms_LastMsysGitDir + _T("\\..\\etc"));
1771 msysGitDir.ReleaseBuffer();
1772 SetLibGit2SearchPath(GIT_CONFIG_LEVEL_SYSTEM, msysGitDir);
1773 SetLibGit2SearchPath(GIT_CONFIG_LEVEL_GLOBAL, g_Git.GetHomeDirectory());
1774 SetLibGit2SearchPath(GIT_CONFIG_LEVEL_XDG, g_Git.GetGitGlobalXDGConfigPath());
1775
1776 //set path
1777 _tdupenv_s(&oldpath,&size,_T("PATH"));
1778
1779 CString path;
1780 path.Format(_T("%s;%s"),oldpath,str + _T(";")+ (CString)CRegString(REG_MSYSGIT_EXTRA_PATH,_T(""),FALSE));
1781
1782 m_Environment.SetEnv(_T("PATH"),path.GetBuffer());
1783
1784 CString str1 = m_Environment.GetEnv(_T("PATH"));
1785
1786 CString sOldPath = oldpath;
1787 free(oldpath);
1788
1789 m_bInitialized = TRUE;
1790 return true;
1791 }
1792
1793 CString CGit::GetHomeDirectory()
1794 {
1795 const wchar_t * homeDir = wget_windows_home_directory();
1796 return CString(homeDir, (int)wcslen(homeDir));
1797 }
1798
1799 CString CGit::GetGitLocalConfig()
1800 {
1801 CString path;
1802 g_GitAdminDir.GetAdminDirPath(g_Git.m_CurrentDir, path);
1803 path += _T("config");
1804 return path;
1805 }
1806
1807 CString CGit::GetGitGlobalConfig()
1808 {
1809 return g_Git.GetHomeDirectory() + _T("\\.gitconfig");
1810 }
1811
1812 CString CGit::GetGitGlobalXDGConfigPath()
1813 {
1814 return g_Git.GetHomeDirectory() + _T("\\.config\\git");
1815 }
1816
1817 CString CGit::GetGitGlobalXDGConfig()
1818 {
1819 return g_Git.GetGitGlobalXDGConfigPath() + _T("\\config");
1820 }
1821
1822 CString CGit::GetGitSystemConfig()
1823 {
1824 const wchar_t * systemConfig = wget_msysgit_etc();
1825 return CString(systemConfig, (int)wcslen(systemConfig));
1826 }
1827
1828 BOOL CGit::CheckCleanWorkTree()
1829 {
1830 CString out;
1831 CString cmd;
1832 cmd=_T("git.exe rev-parse --verify HEAD");
1833
1834 if(Run(cmd,&out,CP_UTF8))
1835 return FALSE;
1836
1837 cmd=_T("git.exe update-index --ignore-submodules --refresh");
1838 if(Run(cmd,&out,CP_UTF8))
1839 return FALSE;
1840
1841 cmd=_T("git.exe diff-files --quiet --ignore-submodules");
1842 if(Run(cmd,&out,CP_UTF8))
1843 return FALSE;
1844
1845 cmd=_T("git diff-index --cached --quiet HEAD --ignore-submodules");
1846 if(Run(cmd,&out,CP_UTF8))
1847 return FALSE;
1848
1849 return TRUE;
1850 }
1851 int CGit::Revert(CString commit, CTGitPathList &list, bool)
1852 {
1853 int ret;
1854 for (int i = 0; i < list.GetCount(); ++i)
1855 {
1856 ret = Revert(commit, (CTGitPath&)list[i]);
1857 if(ret)
1858 return ret;
1859 }
1860 return 0;
1861 }
1862 int CGit::Revert(CString commit, CTGitPath &path)
1863 {
1864 CString cmd, out;
1865
1866 if(path.m_Action & CTGitPath::LOGACTIONS_REPLACED && !path.GetGitOldPathString().IsEmpty())
1867 {
1868 if (CTGitPath(path.GetGitOldPathString()).IsDirectory())
1869 {
1870 CString err;
1871 err.Format(_T("Cannot revert renaming of \"%s\". A directory with the old name \"%s\" exists."), path.GetGitPathString(), path.GetGitOldPathString());
1872 ::MessageBox(NULL, err, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
1873 return -1;
1874 }
1875 CString force;
1876 // if the filenames only differ in case, we have to pass "-f"
1877 if (path.GetGitPathString().CompareNoCase(path.GetGitOldPathString()) == 0)
1878 force = _T("-f ");
1879 cmd.Format(_T("git.exe mv %s-- \"%s\" \"%s\""), force, path.GetGitPathString(), path.GetGitOldPathString());
1880 if (Run(cmd, &out, CP_UTF8))
1881 {
1882 ::MessageBox(NULL, out, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
1883 return -1;
1884 }
1885
1886 cmd.Format(_T("git.exe checkout %s -f -- \"%s\""), commit, path.GetGitOldPathString());
1887 if (Run(cmd, &out, CP_UTF8))
1888 {
1889 ::MessageBox(NULL, out, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
1890 return -1;
1891 }
1892
1893 }
1894 else if(path.m_Action & CTGitPath::LOGACTIONS_ADDED)
1895 { //To init git repository, there are not HEAD, so we can use git reset command
1896 cmd.Format(_T("git.exe rm -f --cached -- \"%s\""),path.GetGitPathString());
1897
1898 if (Run(cmd, &out, CP_UTF8))
1899 {
1900 ::MessageBox(NULL, out, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
1901 return -1;
1902 }
1903 }
1904 else
1905 {
1906 cmd.Format(_T("git.exe checkout %s -f -- \"%s\""), commit, path.GetGitPathString());
1907 if (Run(cmd, &out, CP_UTF8))
1908 {
1909 ::MessageBox(NULL, out, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
1910 return -1;
1911 }
1912 }
1913
1914 if (path.m_Action & CTGitPath::LOGACTIONS_DELETED)
1915 {
1916 cmd.Format(_T("git.exe add -f -- \"%s\""), path.GetGitPathString());
1917 if (Run(cmd, &out, CP_UTF8))
1918 {
1919 ::MessageBox(NULL, out, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
1920 return -1;
1921 }
1922 }
1923
1924 return 0;
1925 }
1926
1927 int CGit::ListConflictFile(CTGitPathList &list,CTGitPath *path)
1928 {
1929 BYTE_VECTOR vector;
1930
1931 CString cmd;
1932 if(path)
1933 cmd.Format(_T("git.exe ls-files -u -t -z -- \"%s\""),path->GetGitPathString());
1934 else
1935 cmd=_T("git.exe ls-files -u -t -z");
1936
1937 if (Run(cmd, &vector))
1938 {
1939 return -1;
1940 }
1941
1942 if (list.ParserFromLsFile(vector))
1943 return -1;
1944
1945 return 0;
1946 }
1947
1948 bool CGit::IsFastForward(const CString &from, const CString &to, CGitHash * commonAncestor)
1949 {
1950 CString base;
1951 CGitHash basehash,hash;
1952 CString cmd, err;
1953 cmd.Format(_T("git.exe merge-base %s %s"), FixBranchName(to), FixBranchName(from));
1954
1955 if (Run(cmd, &base, &err, CP_UTF8))
1956 {
1957 return false;
1958 }
1959 basehash = base.Trim();
1960
1961 GetHash(hash, from);
1962
1963 if (commonAncestor)
1964 *commonAncestor = basehash;
1965
1966 return hash == basehash;
1967 }
1968
1969 unsigned int CGit::Hash2int(CGitHash &hash)
1970 {
1971 int ret=0;
1972 for (int i = 0; i < 4; ++i)
1973 {
1974 ret = ret << 8;
1975 ret |= hash.m_hash[i];
1976 }
1977 return ret;
1978 }
1979
1980 int CGit::RefreshGitIndex()
1981 {
1982 if(g_Git.m_IsUseGitDLL)
1983 {
1984 CAutoLocker lock(g_Git.m_critGitDllSec);
1985 try
1986 {
1987 return [] { return git_run_cmd("update-index","update-index -q --refresh"); }();
1988
1989 }catch(...)
1990 {
1991 return -1;
1992 }
1993
1994 }
1995 else
1996 {
1997 CString cmd,output;
1998 cmd=_T("git.exe update-index --refresh");
1999 return Run(cmd, &output, CP_UTF8);
2000 }
2001 }
2002
2003 int CGit::GetOneFile(CString Refname, CTGitPath &path, const CString &outputfile)
2004 {
2005 if(g_Git.m_IsUseGitDLL)
2006 {
2007 CAutoLocker lock(g_Git.m_critGitDllSec);
2008 try
2009 {
2010 g_Git.CheckAndInitDll();
2011 CStringA ref, patha, outa;
2012 ref = CUnicodeUtils::GetMulti(Refname, CP_UTF8);
2013 patha = CUnicodeUtils::GetMulti(path.GetGitPathString(), CP_UTF8);
2014 outa = CUnicodeUtils::GetMulti(outputfile, CP_UTF8);
2015 ::DeleteFile(outputfile);
2016 return git_checkout_file((const char*)ref.GetBuffer(),(const char*)patha.GetBuffer(),(const char*)outa.GetBuffer());
2017
2018 }catch(...)
2019 {
2020 return -1;
2021 }
2022 }
2023 else
2024 {
2025 CString cmd;
2026 cmd.Format(_T("git.exe cat-file -p %s:\"%s\""), Refname, path.GetGitPathString());
2027 return RunLogFile(cmd,outputfile);
2028 }
2029 }
2030 void CEnvironment::CopyProcessEnvironment()
2031 {
2032 TCHAR *porig = GetEnvironmentStrings();
2033 TCHAR *p = porig;
2034 while(*p !=0 || *(p+1) !=0)
2035 this->push_back(*p++);
2036
2037 push_back(_T('\0'));
2038 push_back(_T('\0'));
2039
2040 FreeEnvironmentStrings(porig);
2041 }
2042
2043 CString CEnvironment::GetEnv(TCHAR *name)
2044 {
2045 CString str;
2046 for (size_t i = 0; i < size(); ++i)
2047 {
2048 str = &(*this)[i];
2049 int start =0;
2050 CString sname = str.Tokenize(_T("="),start);
2051 if(sname.CompareNoCase(name) == 0)
2052 {
2053 return &(*this)[i+start];
2054 }
2055 i+=str.GetLength();
2056 }
2057 return _T("");
2058 }
2059
2060 void CEnvironment::SetEnv(TCHAR *name, TCHAR* value)
2061 {
2062 unsigned int i;
2063 for (i = 0; i < size(); ++i)
2064 {
2065 CString str = &(*this)[i];
2066 int start =0;
2067 CString sname = str.Tokenize(_T("="),start);
2068 if(sname.CompareNoCase(name) == 0)
2069 {
2070 break;
2071 }
2072 i+=str.GetLength();
2073 }
2074
2075 if(i == size())
2076 {
2077 i -= 1; // roll back terminate \0\0
2078 this->push_back(_T('\0'));
2079 }
2080
2081 CEnvironment::iterator it;
2082 it=this->begin();
2083 it += i;
2084
2085 while(*it && i<size())
2086 {
2087 this->erase(it);
2088 it=this->begin();
2089 it += i;
2090 }
2091
2092 while(*name)
2093 {
2094 this->insert(it,*name++);
2095 ++i;
2096 it= begin()+i;
2097 }
2098
2099 this->insert(it, _T('='));
2100 ++i;
2101 it= begin()+i;
2102
2103 while(*value)
2104 {
2105 this->insert(it,*value++);
2106 ++i;
2107 it= begin()+i;
2108 }
2109
2110 }
2111
2112 int CGit::GetGitEncode(TCHAR* configkey)
2113 {
2114 CString str=GetConfigValue(configkey);
2115
2116 if(str.IsEmpty())
2117 return CP_UTF8;
2118
2119 return CUnicodeUtils::GetCPCode(str);
2120 }
2121
2122
2123 int CGit::GetDiffPath(CTGitPathList *PathList, CGitHash *hash1, CGitHash *hash2, char *arg)
2124 {
2125 GIT_FILE file=0;
2126 int ret=0;
2127 GIT_DIFF diff=0;
2128
2129 CAutoLocker lock(g_Git.m_critGitDllSec);
2130
2131 if(arg == NULL)
2132 diff = GetGitDiff();
2133 else
2134 git_open_diff(&diff, arg);
2135
2136 if(diff ==NULL)
2137 return -1;
2138
2139 bool isStat = 0;
2140 if(arg == NULL)
2141 isStat = true;
2142 else
2143 isStat = !!strstr(arg, "stat");
2144
2145 int count=0;
2146
2147 if(hash2 == NULL)
2148 ret = git_root_diff(diff, hash1->m_hash, &file, &count,isStat);
2149 else
2150 ret = git_diff(diff,hash2->m_hash,hash1->m_hash,&file,&count,isStat);
2151
2152 if(ret)
2153 return -1;
2154
2155 CTGitPath path;
2156 CString strnewname;
2157 CString stroldname;
2158
2159 for (int j = 0; j < count; ++j)
2160 {
2161 path.Reset();
2162 char *newname;
2163 char *oldname;
2164
2165 strnewname.Empty();
2166 stroldname.Empty();
2167
2168 int mode=0,IsBin=0,inc=0,dec=0;
2169 git_get_diff_file(diff,file,j,&newname,&oldname,
2170 &mode,&IsBin,&inc,&dec);
2171
2172 StringAppend(&strnewname, (BYTE*)newname, CP_UTF8);
2173 StringAppend(&stroldname, (BYTE*)oldname, CP_UTF8);
2174
2175 path.SetFromGit(strnewname,&stroldname);
2176 path.ParserAction((BYTE)mode);
2177
2178 if(IsBin)
2179 {
2180 path.m_StatAdd=_T("-");
2181 path.m_StatDel=_T("-");
2182 }
2183 else
2184 {
2185 path.m_StatAdd.Format(_T("%d"),inc);
2186 path.m_StatDel.Format(_T("%d"),dec);
2187 }
2188 PathList->AddPath(path);
2189 }
2190 git_diff_flush(diff);
2191
2192 if(arg)
2193 git_close_diff(diff);
2194
2195 return 0;
2196 }
2197
2198 int CGit::GetShortHASHLength()
2199 {
2200 return 7;
2201 }
2202
2203 CString CGit::GetShortName(CString ref, REF_TYPE *out_type)
2204 {
2205 CString str=ref;
2206 CString shortname;
2207 REF_TYPE type = CGit::UNKNOWN;
2208
2209 if (CGit::GetShortName(str, shortname, _T("refs/heads/")))
2210 {
2211 type = CGit::LOCAL_BRANCH;
2212
2213 }
2214 else if (CGit::GetShortName(str, shortname, _T("refs/remotes/")))
2215 {
2216 type = CGit::REMOTE_BRANCH;
2217 }
2218 else if (CGit::GetShortName(str, shortname, _T("refs/tags/")))
2219 {
2220 type = CGit::TAG;
2221 }
2222 else if (CGit::GetShortName(str, shortname, _T("refs/stash")))
2223 {
2224 type = CGit::STASH;
2225 shortname=_T("stash");
2226 }
2227 else if (CGit::GetShortName(str, shortname, _T("refs/bisect/")))
2228 {
2229 if (shortname.Find(_T("good")) == 0)
2230 {
2231 type = CGit::BISECT_GOOD;
2232 shortname = _T("good");
2233 }
2234
2235 if (shortname.Find(_T("bad")) == 0)
2236 {
2237 type = CGit::BISECT_BAD;
2238 shortname = _T("bad");
2239 }
2240 }
2241 else if (CGit::GetShortName(str, shortname, _T("refs/notes/")))
2242 {
2243 type = CGit::NOTES;
2244 }
2245 else if (CGit::GetShortName(str, shortname, _T("refs/")))
2246 {
2247 type = CGit::UNKNOWN;
2248 }
2249 else
2250 {
2251 type = CGit::UNKNOWN;
2252 shortname = ref;
2253 }
2254
2255 if(out_type)
2256 *out_type = type;
2257
2258 return shortname;
2259 }
2260
2261 bool CGit::UsingLibGit2(int cmd)
2262 {
2263 if (cmd >= 0 && cmd < 32)
2264 return ((1 << cmd) & m_IsUseLibGit2_mask) ? true : false;
2265 return false;
2266 }
2267
2268 CString CGit::GetUnifiedDiffCmd(const CTGitPath& path, const git_revnum_t& rev1, const git_revnum_t& rev2, bool bMerge, bool bCombine, int diffContext)
2269 {
2270 CString cmd;
2271 if (rev2 == GitRev::GetWorkingCopy())
2272 cmd.Format(_T("git.exe diff --stat -p %s"), rev1);
2273 else if (rev1 == GitRev::GetWorkingCopy())
2274 cmd.Format(_T("git.exe diff -R --stat -p %s"), rev2);
2275 else
2276 {
2277 CString merge;
2278 if (bMerge)
2279 merge += _T(" -m");
2280
2281 if (bCombine)
2282 merge += _T(" -c");
2283
2284 CString unified;
2285 if (diffContext > 0)
2286 unified.Format(_T(" --unified=%d"), diffContext);
2287 cmd.Format(_T("git.exe diff-tree -r -p %s %s --stat %s %s"), merge, unified, rev1, rev2);
2288 }
2289
2290 if (!path.IsEmpty())
2291 {
2292 cmd += _T(" -- \"");
2293 cmd += path.GetGitPathString();
2294 cmd += _T("\"");
2295 }
2296
2297 return cmd;
2298 }
2299
2300 static int UnifiedDiffToFile(const git_diff_delta * /* delta */, const git_diff_range * /* range */, char /* line_origin */, const char *content, size_t content_len, void *payload)
2301 {
2302 ATLASSERT(payload && content);
2303 fwrite(content, 1, content_len, (FILE *)payload);
2304 return 0;
2305 }
2306
2307 static int resolve_to_tree(git_repository *repo, const char *identifier, git_tree **tree)
2308 {
2309 ATLASSERT(repo && identifier && tree);
2310
2311 /* try to resolve identifier */
2312 git_object *obj = nullptr;
2313 if (git_revparse_single(&obj, repo, identifier))
2314 return -1;
2315
2316 if (obj == nullptr)
2317 return GIT_ENOTFOUND;
2318
2319 int err = 0;
2320 switch (git_object_type(obj))
2321 {
2322 case GIT_OBJ_TREE:
2323 *tree = (git_tree *)obj;
2324 break;
2325 case GIT_OBJ_COMMIT:
2326 err = git_commit_tree(tree, (git_commit *)obj);
2327 git_object_free(obj);
2328 break;
2329 default:
2330 err = GIT_ENOTFOUND;
2331 }
2332
2333 return err;
2334 }
2335
2336 /* use libgit2 get unified diff */
2337 static int GetUnifiedDiffLibGit2(const CTGitPath& /*path*/, const git_revnum_t& rev1, const git_revnum_t& rev2, git_diff_data_cb callback, void *data, bool /* bMerge */)
2338 {
2339 git_repository *repo = nullptr;
2340 CStringA gitdirA = CUnicodeUtils::GetMulti(CTGitPath(g_Git.m_CurrentDir).GetGitPathString(), CP_UTF8);
2341 CStringA tree1 = CUnicodeUtils::GetMulti(rev1, CP_UTF8);
2342 CStringA tree2 = CUnicodeUtils::GetMulti(rev2, CP_UTF8);
2343 int ret = 0;
2344
2345 if (git_repository_open(&repo, gitdirA.GetBuffer()))
2346 {
2347 gitdirA.ReleaseBuffer();
2348 return -1;
2349 }
2350 gitdirA.ReleaseBuffer();
2351
2352 int isHeadOrphan = git_repository_head_orphan(repo);
2353 if (isHeadOrphan != 0)
2354 {
2355 git_repository_free(repo);
2356 if (isHeadOrphan == 1)
2357 return 0;
2358 else
2359 return -1;
2360 }
2361
2362 git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
2363 git_diff_list *diff = nullptr;
2364
2365 if (rev1 == GitRev::GetWorkingCopy() || rev2 == GitRev::GetWorkingCopy())
2366 {
2367 git_tree *t1 = nullptr;
2368 git_diff_list *diff2 = nullptr;
2369
2370 do
2371 {
2372 if (rev1 != GitRev::GetWorkingCopy())
2373 {
2374 if (resolve_to_tree(repo, tree1, &t1))
2375 {
2376 ret = -1;
2377 break;
2378 }
2379 }
2380 if (rev2 != GitRev::GetWorkingCopy())
2381 {
2382 if (resolve_to_tree(repo, tree2, &t1))
2383 {
2384 ret = -1;
2385 break;
2386 }
2387 }
2388
2389 ret = git_diff_tree_to_index(&diff, repo, t1, nullptr, &opts);
2390 if (ret)
2391 break;
2392
2393 ret = git_diff_index_to_workdir(&diff2, repo, nullptr, &opts);
2394 if (ret)
2395 break;
2396
2397 ret = git_diff_merge(diff, diff2);
2398 if (ret)
2399 break;
2400
2401 ret = git_diff_print_patch(diff, callback, data);
2402 if (ret)
2403 break;
2404 } while(0);
2405 if (diff)
2406 git_diff_list_free(diff);
2407 if (diff2)
2408 git_diff_list_free(diff2);
2409 if (t1)
2410 git_tree_free(t1);
2411 }
2412 else
2413 {
2414 git_tree *t1 = nullptr, *t2 = nullptr;
2415 do
2416 {
2417 if (tree1.IsEmpty() && tree2.IsEmpty())
2418 {
2419 ret = -1;
2420 break;
2421 }
2422
2423 if (tree1.IsEmpty())
2424 {
2425 tree1 = tree2;
2426 tree2.Empty();
2427 }
2428
2429 if (!tree1.IsEmpty() && resolve_to_tree(repo, tree1, &t1))
2430 {
2431 ret = -1;
2432 break;
2433 }
2434
2435 if (tree2.IsEmpty())
2436 {
2437 /* don't check return value, there are not parent commit at first commit*/
2438 resolve_to_tree(repo, tree1 + "~1", &t2);
2439 }
2440 else if (resolve_to_tree(repo, tree2, &t2))
2441 {
2442 ret = -1;
2443 break;
2444 }
2445 if (git_diff_tree_to_tree(&diff, repo, t2, t1, &opts))
2446 {
2447 ret = -1;
2448 break;
2449 }
2450 if(git_diff_print_patch(diff, callback, data))
2451 {
2452 ret = -1;
2453 break;
2454 }
2455 } while(0);
2456
2457 if (diff)
2458 git_diff_list_free(diff);
2459 if (t1)
2460 git_tree_free(t1);
2461 if (t2)
2462 git_tree_free(t2);
2463 }
2464 git_repository_free(repo);
2465
2466 return ret;
2467 }
2468
2469 int CGit::GetUnifiedDiff(const CTGitPath& path, const git_revnum_t& rev1, const git_revnum_t& rev2, CString patchfile, bool bMerge, bool bCombine, int diffContext)
2470 {
2471 if (UsingLibGit2(GIT_CMD_DIFF))
2472 {
2473 FILE *file = nullptr;
2474 _tfopen_s(&file, patchfile, _T("w"));
2475 if (file == nullptr)
2476 return -1;
2477 int ret = GetUnifiedDiffLibGit2(path, rev1, rev2, UnifiedDiffToFile, file, bMerge);
2478 fclose(file);
2479 return ret;
2480 }
2481 else
2482 {
2483 CString cmd;
2484 cmd = GetUnifiedDiffCmd(path, rev1, rev2, bMerge, bCombine, diffContext);
2485 return g_Git.RunLogFile(cmd, patchfile);
2486 }
2487 }
2488
2489 static int UnifiedDiffToStringA(const git_diff_delta * /*delta*/, const git_diff_range * /*range*/, char /*line_origin*/, const char *content, size_t content_len, void *payload)
2490 {
2491 ATLASSERT(payload && content);
2492 CStringA *str = (CStringA*) payload;
2493 str->Append(content, content_len);
2494 return 0;
2495 }
2496
2497 int CGit::GetUnifiedDiff(const CTGitPath& path, const git_revnum_t& rev1, const git_revnum_t& rev2, CStringA * buffer, bool bMerge, bool bCombine, int diffContext)
2498 {
2499 if (UsingLibGit2(GIT_CMD_DIFF))
2500 return GetUnifiedDiffLibGit2(path, rev1, rev2, UnifiedDiffToStringA, buffer, bMerge);
2501 else
2502 {
2503 CString cmd;
2504 cmd = GetUnifiedDiffCmd(path, rev1, rev2, bMerge, bCombine, diffContext);
2505 BYTE_VECTOR vector;
2506 int ret = Run(cmd, &vector);
2507 if (!vector.empty())
2508 buffer->Append((char *)&vector[0]);
2509 return ret;
2510 }
2511 }
Windows Explorer Extension to Operate Git