src/Git/Git.cpp

   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 "atlconv.h"
  23 #include "GitRev.h"
  24 #include "registry.h"
  25 #include "GitConfig.h"
  26 #include <map>
  27 #include "UnicodeUtils.h"
  28 #include "gitdll.h"
  29 #include <fstream>
  30 #include "git2.h"
  31
  32 int CGit::m_LogEncode=CP_UTF8;
  33 typedef CComCritSecLock<CComCriticalSection> CAutoLocker;
  34
  35 static LPTSTR nextpath(wchar_t *path, wchar_t *buf, size_t buflen)
  36 {
  37         wchar_t term, *base = path;
  38
  39         if (path == NULL || buf == NULL || buflen == 0)
  40                 return NULL;
  41
  42         term = (*path == L'"') ? *path++ : L';';
  43
  44         for (buflen--; *path && *path != term && buflen; buflen--)
  45                 *buf++ = *path++;
  46
  47         *buf = L'\0'; /* reserved a byte via initial subtract */
  48
  49         while (*path == term || *path == L';')
  50                 path++;
  51
  52         return (path != base) ? path : NULL;
  53 }
  54
  55 static inline BOOL FileExists(LPCTSTR lpszFileName)
  56 {
  57         struct _stat st;
  58         return _tstat(lpszFileName, &st) == 0;
  59 }
  60
  61 static BOOL FindGitPath()
  62 {
  63         size_t size;
  64         _tgetenv_s(&size, NULL, 0, _T("PATH"));
  65
  66         if (!size)
  67         {
  68                 return FALSE;
  69         }
  70
  71         TCHAR *env = (TCHAR*)alloca(size * sizeof(TCHAR));
  72         _tgetenv_s(&size, env, size, _T("PATH"));
  73
  74         TCHAR buf[MAX_PATH];
  75
  76         // search in all paths defined in PATH
  77         while ((env = nextpath(env, buf, MAX_PATH - 1)) != NULL && *buf)
  78         {
  79                 TCHAR *pfin = buf + _tcslen(buf)-1;
  80
  81                 // ensure trailing slash
  82                 if (*pfin != _T('/') && *pfin != _T('\\'))
  83                         _tcscpy_s(++pfin, 2, _T("\\")); // we have enough space left, MAX_PATH-1 is used in nextpath above
  84
  85                 const size_t len = _tcslen(buf);
  86
  87                 if ((len + 7) < MAX_PATH)
  88                         _tcscpy_s(pfin + 1, MAX_PATH - len, _T("git.exe"));
  89                 else
  90                         break;
  91
  92                 if ( FileExists(buf) )
  93                 {
  94                         // dir found
  95                         pfin[1] = 0;
  96                         CGit::ms_LastMsysGitDir = buf;
  97                         CGit::ms_LastMsysGitDir.TrimRight(_T("\\"));
  98                         return TRUE;
  99                 }
 100         }
 101
 102         return FALSE;
 103 }
 104
 105 static bool g_bSortLogical;
 106 static bool g_bSortLocalBranchesFirst;
 107
 108 static void GetSortOptions()
 109 {
 110         g_bSortLogical = !CRegDWORD(L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer\\NoStrCmpLogical", 0, false, HKEY_CURRENT_USER);
 111         if (g_bSortLogical)
 112                 g_bSortLogical = !CRegDWORD(L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer\\NoStrCmpLogical", 0, false, HKEY_LOCAL_MACHINE);
 113         g_bSortLocalBranchesFirst = !CRegDWORD(L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer\\NoSortLocalBranchesFirst", 0, false, HKEY_CURRENT_USER);
 114         if (g_bSortLocalBranchesFirst)
 115                 g_bSortLocalBranchesFirst = !CRegDWORD(L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer\\NoSortLocalBranchesFirst", 0, false, HKEY_LOCAL_MACHINE);
 116 }
 117
 118 static int LogicalComparePredicate(CString &left, CString &right)
 119 {
 120         if (g_bSortLogical)
 121                 return StrCmpLogicalW(left, right) < 0;
 122         return StrCmpI(left, right) < 0;
 123 }
 124
 125 static int LogicalCompareBranchesPredicate(CString &left, CString &right)
 126 {
 127         if (g_bSortLocalBranchesFirst)
 128         {
 129                 int leftIsRemote = left.Find(_T("remotes/"));
 130                 int rightIsRemote = right.Find(_T("remotes/"));
 131
 132                 if (leftIsRemote == 0 && rightIsRemote < 0)
 133                         return false;
 134                 else if (leftIsRemote < 0 && rightIsRemote == 0)
 135                         return true;
 136         }
 137         if (g_bSortLogical)
 138                 return StrCmpLogicalW(left, right) < 0;
 139         return StrCmpI(left, right) < 0;
 140 }
 141
 142 #define MAX_DIRBUFFER 1000
 143 #define CALL_OUTPUT_READ_CHUNK_SIZE 1024
 144
 145 CString CGit::ms_LastMsysGitDir;
 146 CGit g_Git;
 147
 148
 149 CGit::CGit(void)
 150 {
 151         GetCurrentDirectory(MAX_DIRBUFFER,m_CurrentDir.GetBuffer(MAX_DIRBUFFER));
 152         m_CurrentDir.ReleaseBuffer();
 153         m_IsGitDllInited = false;
 154         m_GitDiff=0;
 155         m_GitSimpleListDiff=0;
 156         m_IsUseGitDLL = !!CRegDWORD(_T("Software\\TortoiseGit\\UsingGitDLL"),1);
 157         m_IsUseLibGit2 = !!CRegDWORD(_T("Software\\TortoiseGit\\UseLibgit2"), TRUE);
 158         GetSortOptions();
 159         this->m_bInitialized =false;
 160         CheckMsysGitDir();
 161         m_critGitDllSec.Init();
 162 }
 163
 164 CGit::~CGit(void)
 165 {
 166         if(this->m_GitDiff)
 167         {
 168                 git_close_diff(m_GitDiff);
 169                 m_GitDiff=0;
 170         }
 171         if(this->m_GitSimpleListDiff)
 172         {
 173                 git_close_diff(m_GitSimpleListDiff);
 174                 m_GitSimpleListDiff=0;
 175         }
 176 }
 177
 178 bool CGit::IsBranchNameValid(CString branchname)
 179 {
 180         if (branchname.IsEmpty())
 181                 return false;
 182
 183         for(int i=0; i < branchname.GetLength(); i++)
 184         {
 185                 TCHAR c = branchname.GetAt(i);
 186                 if (c <= ' ' || c == '~' || c == '^' || c == ':' || c == '\\' || c == '?' || c == '[')
 187                         return false;
 188         }
 189
 190         if (branchname.Find(L".") == 0 || branchname.Find(L"/.") >= 0 || branchname.Find(L"..") >= 0 || branchname.Find(L"@{") >= 0 || branchname.ReverseFind('*') >= 0)
 191                 return false;
 192
 193         CString reverseBranchname = branchname.MakeReverse();
 194         if (branchname.Find(L'.') == 0 || branchname.Find(L'/') == 0 || reverseBranchname.Find(L"kcol.") >= 0)
 195                 return false;
 196
 197         return true;
 198 }
 199
 200 static char g_Buffer[4096];
 201
 202 int CGit::RunAsync(CString cmd, PROCESS_INFORMATION *piOut, HANDLE *hReadOut, HANDLE *hErrReadOut, CString *StdioFile)
 203 {
 204         SECURITY_ATTRIBUTES sa;
 205         HANDLE hRead, hWrite, hReadErr = NULL, hWriteErr = NULL;
 206         HANDLE hStdioFile = NULL;
 207
 208         sa.nLength = sizeof(SECURITY_ATTRIBUTES);
 209         sa.lpSecurityDescriptor=NULL;
 210         sa.bInheritHandle=TRUE;
 211         if(!CreatePipe(&hRead,&hWrite,&sa,0))
 212         {
 213                 return TGIT_GIT_ERROR_OPEN_PIP;
 214         }
 215         if (hErrReadOut && !CreatePipe(&hReadErr, &hWriteErr, &sa, 0))
 216                 return TGIT_GIT_ERROR_OPEN_PIP;
 217
 218         if(StdioFile)
 219         {
 220                 hStdioFile=CreateFile(*StdioFile,GENERIC_WRITE,FILE_SHARE_READ | FILE_SHARE_WRITE,
 221                                                                 &sa,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
 222         }
 223
 224         STARTUPINFO si;
 225         PROCESS_INFORMATION pi;
 226         si.cb=sizeof(STARTUPINFO);
 227         GetStartupInfo(&si);
 228
 229         if (hErrReadOut)
 230                 si.hStdError = hWriteErr;
 231         else
 232                 si.hStdError = hWrite;
 233         if(StdioFile)
 234                 si.hStdOutput=hStdioFile;
 235         else
 236                 si.hStdOutput=hWrite;
 237
 238         si.wShowWindow=SW_HIDE;
 239         si.dwFlags=STARTF_USESTDHANDLES|STARTF_USESHOWWINDOW;
 240
 241         LPTSTR pEnv = (!m_Environment.empty()) ? &m_Environment[0]: NULL;
 242         DWORD dwFlags = pEnv ? CREATE_UNICODE_ENVIRONMENT : 0;
 243
 244         //DETACHED_PROCESS make ssh recognize that it has no console to launch askpass to input password.
 245         dwFlags |= DETACHED_PROCESS | CREATE_NEW_PROCESS_GROUP;
 246
 247         memset(&this->m_CurrentGitPi,0,sizeof(PROCESS_INFORMATION));
 248         memset(&pi, 0, sizeof(PROCESS_INFORMATION));
 249
 250         if(cmd.Find(_T("git")) == 0)
 251         {
 252                 int firstSpace = cmd.Find(_T(" "));
 253                 if (firstSpace > 0)
 254                         cmd = _T('"')+CGit::ms_LastMsysGitDir+_T("\\")+ cmd.Left(firstSpace) + _T('"')+ cmd.Mid(firstSpace);
 255                 else
 256                         cmd=_T('"')+CGit::ms_LastMsysGitDir+_T("\\")+cmd+_T('"');
 257         }
 258
 259         if(!CreateProcess(NULL,(LPWSTR)cmd.GetString(), NULL,NULL,TRUE,dwFlags,pEnv,(LPWSTR)m_CurrentDir.GetString(),&si,&pi))
 260         {
 261                 LPVOID lpMsgBuf;
 262                 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
 263                                                 NULL,GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
 264                                                 (LPTSTR)&lpMsgBuf,
 265                                                 0,NULL);
 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 BOOL CGit::IsOrphanBranch(CString ref)
 311 {
 312         if (ref.IsEmpty())
 313                 ref = _T("HEAD");
 314
 315         CString cmdout;
 316         if (Run(_T("git.exe rev-parse --revs-only ") + ref, &cmdout, CP_UTF8))
 317         {
 318                 return TRUE;
 319         }
 320         if(cmdout.IsEmpty())
 321                 return TRUE;
 322
 323         return FALSE;
 324 }
 325
 326 BOOL CGit::IsInitRepos()
 327 {
 328         return IsOrphanBranch(_T("HEAD"));
 329 }
 330
 331 DWORD WINAPI CGit::AsyncReadStdErrThread(LPVOID lpParam)
 332 {
 333         PASYNCREADSTDERRTHREADARGS pDataArray;
 334         pDataArray = (PASYNCREADSTDERRTHREADARGS)lpParam;
 335
 336         DWORD readnumber;
 337         BYTE data[CALL_OUTPUT_READ_CHUNK_SIZE];
 338         while (ReadFile(pDataArray->fileHandle, data, CALL_OUTPUT_READ_CHUNK_SIZE, &readnumber, NULL))
 339         {
 340                 if (pDataArray->pcall->OnOutputErrData(data,readnumber))
 341                         break;
 342         }
 343
 344         return 0;
 345 }
 346
 347 int CGit::Run(CGitCall* pcall)
 348 {
 349         PROCESS_INFORMATION pi;
 350         HANDLE hRead, hReadErr;
 351         if(RunAsync(pcall->GetCmd(),&pi,&hRead, &hReadErr))
 352                 return TGIT_GIT_ERROR_CREATE_PROCESS;
 353
 354         HANDLE thread;
 355         ASYNCREADSTDERRTHREADARGS threadArguments;
 356         threadArguments.fileHandle = hReadErr;
 357         threadArguments.pcall = pcall;
 358         thread = CreateThread(NULL, 0, AsyncReadStdErrThread, &threadArguments, 0, NULL);
 359
 360         DWORD readnumber;
 361         BYTE data[CALL_OUTPUT_READ_CHUNK_SIZE];
 362         bool bAborted=false;
 363         while(ReadFile(hRead,data,CALL_OUTPUT_READ_CHUNK_SIZE,&readnumber,NULL))
 364         {
 365                 // TODO: when OnOutputData() returns 'true', abort git-command. Send CTRL-C signal?
 366                 if(!bAborted)//For now, flush output when command aborted.
 367                         if(pcall->OnOutputData(data,readnumber))
 368                                 bAborted=true;
 369         }
 370         if(!bAborted)
 371                 pcall->OnEnd();
 372
 373         if (thread)
 374                 WaitForSingleObject(thread, INFINITE);
 375
 376         CloseHandle(pi.hThread);
 377
 378         WaitForSingleObject(pi.hProcess, INFINITE);
 379         DWORD exitcode =0;
 380
 381         if(!GetExitCodeProcess(pi.hProcess,&exitcode))
 382         {
 383                 return TGIT_GIT_ERROR_GET_EXIT_CODE;
 384         }
 385
 386         CloseHandle(pi.hProcess);
 387
 388         CloseHandle(hRead);
 389         CloseHandle(hReadErr);
 390         return exitcode;
 391 }
 392 class CGitCall_ByteVector : public CGitCall
 393 {
 394 public:
 395         CGitCall_ByteVector(CString cmd,BYTE_VECTOR* pvector, BYTE_VECTOR* pvectorErr = NULL):CGitCall(cmd),m_pvector(pvector),m_pvectorErr(pvectorErr){}
 396         virtual bool OnOutputData(const BYTE* data, size_t size)
 397         {
 398                 if (size == 0)
 399                         return false;
 400                 size_t oldsize=m_pvector->size();
 401                 m_pvector->resize(m_pvector->size()+size);
 402                 memcpy(&*(m_pvector->begin()+oldsize),data,size);
 403                 return false;
 404         }
 405         virtual bool OnOutputErrData(const BYTE* data, size_t size)
 406         {
 407                 if (!m_pvectorErr || size == 0)
 408                         return false;
 409                 size_t oldsize = m_pvectorErr->size();
 410                 m_pvectorErr->resize(m_pvectorErr->size() + size);
 411                 memcpy(&*(m_pvectorErr->begin() + oldsize), data, size);
 412                 return false;
 413         }
 414         BYTE_VECTOR* m_pvector;
 415         BYTE_VECTOR* m_pvectorErr;
 416
 417 };
 418 int CGit::Run(CString cmd,BYTE_VECTOR *vector, BYTE_VECTOR *vectorErr)
 419 {
 420         CGitCall_ByteVector call(cmd, vector, vectorErr);
 421         return Run(&call);
 422 }
 423 int CGit::Run(CString cmd, CString* output, int code)
 424 {
 425         CString err;
 426         int ret;
 427         ret = Run(cmd, output, &err, code);
 428
 429         if (output && !err.IsEmpty())
 430         {
 431                 if (!output->IsEmpty())
 432                         *output += _T("\n");
 433                 *output += err;
 434         }
 435
 436         return ret;
 437 }
 438 int CGit::Run(CString cmd, CString* output, CString* outputErr, int code)
 439 {
 440         BYTE_VECTOR vector, vectorErr;
 441         int ret;
 442         if (outputErr)
 443                 ret = Run(cmd, &vector, &vectorErr);
 444         else
 445                 ret = Run(cmd, &vector);
 446
 447         vector.push_back(0);
 448         StringAppend(output, &(vector[0]), code);
 449
 450         if (outputErr)
 451         {
 452                 vectorErr.push_back(0);
 453                 StringAppend(outputErr, &(vectorErr[0]), code);
 454         }
 455
 456         return ret;
 457 }
 458
 459 CString CGit::GetUserName(void)
 460 {
 461         CEnvironment env;
 462         env.CopyProcessEnvironment();
 463         CString envname = env.GetEnv(_T("GIT_AUTHOR_NAME"));
 464         if (!envname.IsEmpty())
 465                 return envname;
 466         return GetConfigValue(L"user.name", this->GetGitEncode(L"i18n.commitencoding"));
 467 }
 468 CString CGit::GetUserEmail(void)
 469 {
 470         CEnvironment env;
 471         env.CopyProcessEnvironment();
 472         CString envmail = env.GetEnv(_T("GIT_AUTHOR_EMAIL"));
 473         if (!envmail.IsEmpty())
 474                 return envmail;
 475
 476         return GetConfigValue(L"user.email");
 477 }
 478
 479 CString CGit::GetConfigValue(CString name,int encoding, CString *GitPath, BOOL RemoveCR)
 480 {
 481         CString configValue;
 482         int start = 0;
 483         if(this->m_IsUseGitDLL)
 484         {
 485                 CString *git_path=NULL;
 486
 487                 CAutoLocker lock(g_Git.m_critGitDllSec);
 488
 489                 try
 490                 {
 491                         CTGitPath path;
 492
 493                         CheckAndInitDll();
 494                         git_path = GitPath;
 495
 496                 }catch(...)
 497                 {
 498                 }
 499                 CStringA key, value;
 500                 key =  CUnicodeUtils::GetMulti(name, encoding);
 501                 CStringA p;
 502                 if(git_path)
 503                         p = CUnicodeUtils::GetMulti(*GitPath, CP_UTF8);
 504
 505                 if(git_get_config(key.GetBuffer(), value.GetBufferSetLength(4096), 4096, p.GetBuffer()))
 506                         return CString();
 507                 else
 508                 {
 509                         StringAppend(&configValue,(BYTE*)value.GetBuffer(),encoding);
 510                         if(RemoveCR)
 511                                 return configValue.Tokenize(_T("\n"),start);
 512                         return configValue;
 513                 }
 514
 515         }
 516         else
 517         {
 518                 CString cmd;
 519                 cmd.Format(L"git.exe config %s", name);
 520                 Run(cmd, &configValue, NULL, encoding);
 521                 if(RemoveCR)
 522                         return configValue.Tokenize(_T("\n"),start);
 523                 return configValue;
 524         }
 525 }
 526
 527 int CGit::SetConfigValue(CString key, CString value, CONFIG_TYPE type, int encoding, CString *GitPath)
 528 {
 529         if(this->m_IsUseGitDLL)
 530         {
 531                 CAutoLocker lock(g_Git.m_critGitDllSec);
 532
 533                 try
 534                 {
 535                         CheckAndInitDll();
 536
 537                 }catch(...)
 538                 {
 539                 }
 540                 CStringA keya, valuea;
 541                 keya = CUnicodeUtils::GetMulti(key, CP_UTF8);
 542                 valuea = CUnicodeUtils::GetMulti(value, encoding);
 543                 CStringA p;
 544                 if(GitPath)
 545                         p = CUnicodeUtils::GetMulti(*GitPath, CP_UTF8);
 546
 547                 return get_set_config(keya.GetBuffer(), valuea.GetBuffer(), type, p.GetBuffer());
 548
 549         }
 550         else
 551         {
 552                 CString cmd;
 553                 CString option;
 554                 switch(type)
 555                 {
 556                 case CONFIG_GLOBAL:
 557                         option = _T("--global");
 558                         break;
 559                 case CONFIG_SYSTEM:
 560                         option = _T("--system");
 561                         break;
 562                 default:
 563                         break;
 564                 }
 565                 cmd.Format(_T("git.exe config %s %s \"%s\""), option, key, value);
 566                 CString out;
 567                 if (Run(cmd, &out, NULL, encoding))
 568                 {
 569                         return -1;
 570                 }
 571         }
 572         return 0;
 573 }
 574
 575 int CGit::UnsetConfigValue(CString key, CONFIG_TYPE type, int encoding, CString *GitPath)
 576 {
 577         if(this->m_IsUseGitDLL)
 578         {
 579                 CAutoLocker lock(g_Git.m_critGitDllSec);
 580
 581                 try
 582                 {
 583                         CheckAndInitDll();
 584                 }catch(...)
 585                 {
 586                 }
 587                 CStringA keya;
 588                 keya = CUnicodeUtils::GetMulti(key, CP_UTF8);
 589                 CStringA p;
 590                 if(GitPath)
 591                         p=CUnicodeUtils::GetMulti(*GitPath,CP_ACP);
 592
 593                 return get_set_config(keya.GetBuffer(), NULL, type, p.GetBuffer());
 594         }
 595         else
 596         {
 597                 CString cmd;
 598                 CString option;
 599                 switch(type)
 600                 {
 601                 case CONFIG_GLOBAL:
 602                         option = _T("--global");
 603                         break;
 604                 case CONFIG_SYSTEM:
 605                         option = _T("--system");
 606                         break;
 607                 default:
 608                         break;
 609                 }
 610                 cmd.Format(_T("git.exe config %s --unset %s"), option, key);
 611                 CString out;
 612                 if (Run(cmd, &out, NULL, encoding))
 613                 {
 614                         return -1;
 615                 }
 616         }
 617         return 0;
 618 }
 619
 620 CString CGit::GetCurrentBranch(void)
 621 {
 622         CString output;
 623         //Run(_T("git.exe branch"),&branch);
 624
 625         if(this->GetCurrentBranchFromFile(this->m_CurrentDir,output))
 626         {
 627                 return _T("(no branch)");
 628         }
 629         else
 630                 return output;
 631
 632 }
 633
 634 CString CGit::GetSymbolicRef(const wchar_t* symbolicRefName, bool bStripRefsHeads)
 635 {
 636         CString refName;
 637         if(this->m_IsUseGitDLL)
 638         {
 639                 unsigned char sha1[20];
 640                 int flag;
 641
 642                 CAutoLocker lock(g_Git.m_critGitDllSec);
 643                 const char *refs_heads_master = git_resolve_ref(CUnicodeUtils::GetUTF8(CString(symbolicRefName)), sha1, 0, &flag);
 644                 if(refs_heads_master && (flag&REF_ISSYMREF))
 645                 {
 646                         StringAppend(&refName,(BYTE*)refs_heads_master);
 647                         if(bStripRefsHeads)
 648                                 refName = StripRefName(refName);
 649                 }
 650
 651         }
 652         else
 653         {
 654                 CString cmd;
 655                 cmd.Format(L"git symbolic-ref %s", symbolicRefName);
 656                 if (Run(cmd, &refName, NULL, CP_UTF8) != 0)
 657                         return CString();//Error
 658                 int iStart = 0;
 659                 refName = refName.Tokenize(L"\n", iStart);
 660                 if(bStripRefsHeads)
 661                         refName = StripRefName(refName);
 662         }
 663         return refName;
 664 }
 665
 666 CString CGit::GetFullRefName(CString shortRefName)
 667 {
 668         CString refName;
 669         CString cmd;
 670         cmd.Format(L"git rev-parse --symbolic-full-name %s", shortRefName);
 671         if (Run(cmd, &refName, NULL, CP_UTF8) != 0)
 672                 return CString();//Error
 673         int iStart = 0;
 674         return refName.Tokenize(L"\n", iStart);
 675 }
 676
 677 CString CGit::StripRefName(CString refName)
 678 {
 679         if(wcsncmp(refName, L"refs/heads/", 11) == 0)
 680                 refName = refName.Mid(11);
 681         else if(wcsncmp(refName, L"refs/", 5) == 0)
 682                 refName = refName.Mid(5);
 683         int start =0;
 684         return refName.Tokenize(_T("\n"),start);
 685 }
 686
 687 int CGit::GetCurrentBranchFromFile(const CString &sProjectRoot, CString &sBranchOut)
 688 {
 689         // read current branch name like git-gui does, by parsing the .git/HEAD file directly
 690
 691         if ( sProjectRoot.IsEmpty() )
 692                 return -1;
 693
 694         CString sDotGitPath;
 695         if (!g_GitAdminDir.GetAdminDirPath(sProjectRoot, sDotGitPath))
 696                 return -1;
 697
 698         CString sHeadFile = sDotGitPath + _T("HEAD");
 699
 700         FILE *pFile;
 701         _tfopen_s(&pFile, sHeadFile.GetString(), _T("r"));
 702
 703         if (!pFile)
 704         {
 705                 return -1;
 706         }
 707
 708         char s[256] = {0};
 709         fgets(s, sizeof(s), pFile);
 710
 711         fclose(pFile);
 712
 713         const char *pfx = "ref: refs/heads/";
 714         const int len = 16;//strlen(pfx)
 715
 716         if ( !strncmp(s, pfx, len) )
 717         {
 718                 //# We're on a branch.  It might not exist.  But
 719                 //# HEAD looks good enough to be a branch.
 720                 CStringA utf8Branch(s + len);
 721                 sBranchOut = CUnicodeUtils::GetUnicode(utf8Branch);
 722                 sBranchOut.TrimRight(_T(" \r\n\t"));
 723
 724                 if ( sBranchOut.IsEmpty() )
 725                         return -1;
 726         }
 727         else
 728         {
 729                 //# Assume this is a detached head.
 730                 sBranchOut = "HEAD";
 731
 732                 return 1;
 733         }
 734
 735         return 0;
 736 }
 737
 738 int CGit::BuildOutputFormat(CString &format,bool IsFull)
 739 {
 740         CString log;
 741         log.Format(_T("#<%c>%%x00"),LOG_REV_ITEM_BEGIN);
 742         format += log;
 743         if(IsFull)
 744         {
 745                 log.Format(_T("#<%c>%%an%%x00"),LOG_REV_AUTHOR_NAME);
 746                 format += log;
 747                 log.Format(_T("#<%c>%%ae%%x00"),LOG_REV_AUTHOR_EMAIL);
 748                 format += log;
 749                 log.Format(_T("#<%c>%%ai%%x00"),LOG_REV_AUTHOR_DATE);
 750                 format += log;
 751                 log.Format(_T("#<%c>%%cn%%x00"),LOG_REV_COMMIT_NAME);
 752                 format += log;
 753                 log.Format(_T("#<%c>%%ce%%x00"),LOG_REV_COMMIT_EMAIL);
 754                 format += log;
 755                 log.Format(_T("#<%c>%%ci%%x00"),LOG_REV_COMMIT_DATE);
 756                 format += log;
 757                 log.Format(_T("#<%c>%%b%%x00"),LOG_REV_COMMIT_BODY);
 758                 format += log;
 759         }
 760
 761         log.Format(_T("#<%c>%%m%%H%%x00"),LOG_REV_COMMIT_HASH);
 762         format += log;
 763         log.Format(_T("#<%c>%%P%%x00"),LOG_REV_COMMIT_PARENT);
 764         format += log;
 765         log.Format(_T("#<%c>%%s%%x00"),LOG_REV_COMMIT_SUBJECT);
 766         format += log;
 767
 768         if(IsFull)
 769         {
 770                 log.Format(_T("#<%c>%%x00"),LOG_REV_COMMIT_FILE);
 771                 format += log;
 772         }
 773         return 0;
 774 }
 775
 776 int CGit::GetLog(BYTE_VECTOR& logOut, const CString &hash,  CTGitPath *path ,int count,int mask,CString *from,CString *to)
 777 {
 778         CGitCall_ByteVector gitCall(CString(), &logOut, NULL);
 779         return GetLog(&gitCall,hash,path,count,mask,from,to);
 780 }
 781
 782 CString CGit::GetLogCmd( const CString &hash, CTGitPath *path, int count, int mask,CString *from,CString *to,bool paramonly,
 783                                                 CFilterData *Filter)
 784 {
 785         CString cmd;
 786         CString num;
 787         CString since;
 788
 789         CString file;
 790
 791         if(path)
 792                 file.Format(_T(" -- \"%s\""),path->GetGitPathString());
 793
 794         if(count>0)
 795                 num.Format(_T("-n%d"),count);
 796
 797         CString param;
 798
 799         if(mask& LOG_INFO_STAT )
 800                 param += _T(" --numstat ");
 801         if(mask& LOG_INFO_FILESTATE)
 802                 param += _T(" --raw ");
 803
 804         if(mask& LOG_INFO_FULLHISTORY)
 805                 param += _T(" --full-history ");
 806
 807         if(mask& LOG_INFO_BOUNDARY)
 808                 param += _T(" --left-right --boundary ");
 809
 810         if(mask& CGit::LOG_INFO_ALL_BRANCH)
 811                 param += _T(" --all ");
 812
 813         if(mask& CGit::LOG_INFO_DETECT_COPYRENAME)
 814                 param += _T(" -C ");
 815
 816         if(mask& CGit::LOG_INFO_DETECT_RENAME )
 817                 param += _T(" -M ");
 818
 819         if(mask& CGit::LOG_INFO_FIRST_PARENT )
 820                 param += _T(" --first-parent ");
 821
 822         if(mask& CGit::LOG_INFO_NO_MERGE )
 823                 param += _T(" --no-merges ");
 824
 825         if(mask& CGit::LOG_INFO_FOLLOW)
 826                 param += _T(" --follow ");
 827
 828         if(mask& CGit::LOG_INFO_SHOW_MERGEDFILE)
 829                 param += _T(" -c ");
 830
 831         if(mask& CGit::LOG_INFO_FULL_DIFF)
 832                 param += _T(" --full-diff ");
 833
 834         if(mask& CGit::LOG_INFO_SIMPILFY_BY_DECORATION)
 835                 param += _T(" --simplify-by-decoration ");
 836
 837         if(from != NULL && to != NULL)
 838         {
 839                 CString range;
 840                 range.Format(_T(" %s..%s "),FixBranchName(*from),FixBranchName(*to));
 841                 param += range;
 842         }
 843         else if(to != NULL && hash.IsEmpty())
 844         {
 845                 CString range;
 846                 range.Format(_T(" %s "), FixBranchName(*to));
 847                 param += range;
 848         }
 849         param+=hash;
 850
 851         CString st1,st2;
 852
 853         if( Filter && (Filter->m_From != -1))
 854         {
 855                 st1.Format(_T(" --max-age=%I64u "), Filter->m_From);
 856                 param += st1;
 857         }
 858
 859         if( Filter && (Filter->m_To != -1))
 860         {
 861                 st2.Format(_T(" --min-age=%I64u "), Filter->m_To);
 862                 param += st2;
 863         }
 864
 865         bool isgrep = false;
 866         if( Filter && (!Filter->m_Author.IsEmpty()))
 867         {
 868                 st1.Format(_T(" --author=\"%s\"" ),Filter->m_Author);
 869                 param += st1;
 870                 isgrep = true;
 871         }
 872
 873         if( Filter && (!Filter->m_Committer.IsEmpty()))
 874         {
 875                 st1.Format(_T(" --committer=\"%s\"" ),Filter->m_Author);
 876                 param += st1;
 877                 isgrep = true;
 878         }
 879
 880         if( Filter && (!Filter->m_MessageFilter.IsEmpty()))
 881         {
 882                 st1.Format(_T(" --grep=\"%s\"" ),Filter->m_MessageFilter);
 883                 param += st1;
 884                 isgrep = true;
 885         }
 886
 887         if(Filter && isgrep)
 888         {
 889                 if(!Filter->m_IsRegex)
 890                         param += _T(" --fixed-strings ");
 891
 892                 param += _T(" --regexp-ignore-case --extended-regexp ");
 893         }
 894
 895         if (CRegDWORD(_T("Software\\TortoiseGit\\LogTopoOrder"), TRUE))
 896                 param += _T(" --topo-order");
 897
 898         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
 899                 cmd.Format(_T("--ignore-this-parameter %s -z %s --parents "), num, param);
 900         else
 901         {
 902                 CString log;
 903                 BuildOutputFormat(log,!(mask&CGit::LOG_INFO_ONLY_HASH));
 904                 cmd.Format(_T("git.exe log %s -z %s --parents --pretty=format:\"%s\""),
 905                                 num,param,log);
 906         }
 907
 908         cmd += file;
 909
 910         return cmd;
 911 }
 912 //int CGit::GetLog(CGitCall* pgitCall, const CString &hash,  CTGitPath *path ,int count,int mask)
 913 int CGit::GetLog(CGitCall* pgitCall, const CString &hash, CTGitPath *path, int count, int mask,CString *from,CString *to)
 914 {
 915         pgitCall->SetCmd( GetLogCmd(hash,path,count,mask,from,to) );
 916
 917         return Run(pgitCall);
 918 //      return Run(cmd,&logOut);
 919 }
 920
 921 #define BUFSIZE 512
 922 void GetTempPath(CString &path)
 923 {
 924         TCHAR lpPathBuffer[BUFSIZE];
 925         DWORD dwRetVal;
 926         DWORD dwBufSize=BUFSIZE;
 927         dwRetVal = GetTortoiseGitTempPath(dwBufSize,            // length of the buffer
 928                                                         lpPathBuffer);  // buffer for path
 929         if (dwRetVal > dwBufSize || (dwRetVal == 0))
 930         {
 931                 path=_T("");
 932         }
 933         path.Format(_T("%s"),lpPathBuffer);
 934 }
 935 CString GetTempFile()
 936 {
 937         TCHAR lpPathBuffer[BUFSIZE];
 938         DWORD dwRetVal;
 939         DWORD dwBufSize=BUFSIZE;
 940         TCHAR szTempName[BUFSIZE];
 941         UINT uRetVal;
 942
 943         dwRetVal = GetTortoiseGitTempPath(dwBufSize,            // length of the buffer
 944                                                         lpPathBuffer);  // buffer for path
 945         if (dwRetVal > dwBufSize || (dwRetVal == 0))
 946         {
 947                 return _T("");
 948         }
 949          // Create a temporary file.
 950         uRetVal = GetTempFileName(lpPathBuffer,         // directory for tmp files
 951                                                                 TEXT("Patch"),  // temp file name prefix
 952                                                                 0,                              // create unique name
 953                                                                 szTempName);    // buffer for name
 954
 955
 956         if (uRetVal == 0)
 957         {
 958                 return _T("");
 959         }
 960
 961         return CString(szTempName);
 962
 963 }
 964
 965 DWORD GetTortoiseGitTempPath(DWORD nBufferLength, LPTSTR lpBuffer)
 966 {
 967         DWORD result = ::GetTempPath(nBufferLength, lpBuffer);
 968         if (result == 0) return 0;
 969         if (lpBuffer == NULL || (result + 13 > nBufferLength))
 970         {
 971                 if (lpBuffer)
 972                         lpBuffer[0] = '\0';
 973                 return result + 13;
 974         }
 975
 976         _tcscat(lpBuffer, _T("TortoiseGit\\"));
 977         CreateDirectory(lpBuffer, NULL);
 978
 979         return result + 13;
 980 }
 981
 982 int CGit::RunLogFile(CString cmd,const CString &filename)
 983 {
 984         STARTUPINFO si;
 985         PROCESS_INFORMATION pi;
 986         si.cb=sizeof(STARTUPINFO);
 987         GetStartupInfo(&si);
 988
 989         SECURITY_ATTRIBUTES   psa={sizeof(psa),NULL,TRUE};;
 990         psa.bInheritHandle=TRUE;
 991
 992         HANDLE houtfile=CreateFile(filename,GENERIC_WRITE,FILE_SHARE_READ | FILE_SHARE_WRITE,
 993                         &psa,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
 994
 995         si.wShowWindow = SW_HIDE;
 996         si.dwFlags = STARTF_USESTDHANDLES|STARTF_USESHOWWINDOW;
 997         si.hStdOutput = houtfile;
 998
 999         LPTSTR pEnv = (!m_Environment.empty()) ? &m_Environment[0]: NULL;
1000         DWORD dwFlags = pEnv ? CREATE_UNICODE_ENVIRONMENT : 0;
1001
1002         if(cmd.Find(_T("git")) == 0)
1003                 cmd=CGit::ms_LastMsysGitDir+_T("\\")+cmd;
1004
1005         if(!CreateProcess(NULL,(LPWSTR)cmd.GetString(), NULL,NULL,TRUE,dwFlags,pEnv,(LPWSTR)m_CurrentDir.GetString(),&si,&pi))
1006         {
1007                 LPVOID lpMsgBuf;
1008                 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,
1009                                                 NULL,GetLastError(),MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
1010                                                 (LPTSTR)&lpMsgBuf,
1011                                                 0,NULL);
1012                 return TGIT_GIT_ERROR_CREATE_PROCESS;
1013         }
1014
1015         WaitForSingleObject(pi.hProcess,INFINITE);
1016
1017         CloseHandle(pi.hThread);
1018         CloseHandle(pi.hProcess);
1019         CloseHandle(houtfile);
1020         return TGIT_GIT_SUCCESS;
1021 //      return 0;
1022 }
1023
1024 int CGit::GetHash(CGitHash &hash, TCHAR* friendname)
1025 {
1026         // no need to parse a ref if it's already a 40-byte hash
1027         if (CGitHash::IsValidSHA1(friendname))
1028         {
1029                 CString sHash(friendname);
1030                 hash = CGitHash(sHash);
1031                 return 0;
1032         }
1033
1034         if (m_IsUseLibGit2)
1035         {
1036                 git_repository *repo = NULL;
1037                 CStringA gitdirA = CUnicodeUtils::GetMulti(CTGitPath(m_CurrentDir).GetGitPathString(), CP_UTF8);
1038                 if (git_repository_open(&repo, gitdirA.GetBuffer()))
1039                 {
1040                         gitdirA.ReleaseBuffer();
1041                         return -1;
1042                 }
1043                 gitdirA.ReleaseBuffer();
1044
1045                 int isHeadOrphan = git_repository_head_orphan(repo);
1046                 if (isHeadOrphan != 0)
1047                 {
1048                         git_repository_free(repo);
1049                         hash.Empty();
1050                         if (isHeadOrphan == 1)
1051                                 return 0;
1052                         else
1053                                 return -1;
1054                 }
1055
1056                 CStringA refnameA = CUnicodeUtils::GetMulti(friendname, CP_UTF8);
1057
1058                 git_object * gitObject = NULL;
1059                 if (git_revparse_single(&gitObject, repo, refnameA.GetBuffer()))
1060                 {
1061                         refnameA.ReleaseBuffer();
1062                         git_repository_free(repo);
1063                         return -1;
1064                 }
1065                 refnameA.ReleaseBuffer();
1066
1067                 const git_oid * oid = git_object_id(gitObject);
1068                 if (oid == NULL)
1069                 {
1070                         git_object_free(gitObject);
1071                         git_repository_free(repo);
1072                         return -1;
1073                 }
1074
1075                 hash = CGitHash((char *)oid->id);
1076
1077                 git_object_free(gitObject); // also frees oid
1078                 git_repository_free(repo);
1079
1080                 return 0;
1081         }
1082         else
1083         {
1084                 CString cmd;
1085                 cmd.Format(_T("git.exe rev-parse %s" ),FixBranchName(friendname));
1086                 int ret = Run(cmd, &gitLastErr, NULL, CP_UTF8);
1087                 hash = CGitHash(gitLastErr.Trim());
1088                 return ret;
1089         }
1090 }
1091
1092 int CGit::GetInitAddList(CTGitPathList &outputlist)
1093 {
1094         CString cmd;
1095         BYTE_VECTOR cmdout;
1096
1097         cmd=_T("git.exe ls-files -s -t -z");
1098         outputlist.Clear();
1099         if (Run(cmd, &cmdout))
1100                 return -1;
1101
1102         outputlist.ParserFromLsFile(cmdout);
1103         for(int i=0;i<outputlist.GetCount();i++)
1104                 const_cast<CTGitPath&>(outputlist[i]).m_Action = CTGitPath::LOGACTIONS_ADDED;
1105
1106         return 0;
1107 }
1108 int CGit::GetCommitDiffList(const CString &rev1,const CString &rev2,CTGitPathList &outputlist)
1109 {
1110         CString cmd;
1111
1112         if(rev1 == GIT_REV_ZERO || rev2 == GIT_REV_ZERO)
1113         {
1114                 //rev1=+_T("");
1115                 if(rev1 == GIT_REV_ZERO)
1116                         cmd.Format(_T("git.exe diff -r --raw -C -M --numstat -z %s"),rev2);
1117                 else
1118                         cmd.Format(_T("git.exe diff -r -R --raw -C -M --numstat -z %s"),rev1);
1119         }
1120         else
1121         {
1122                 cmd.Format(_T("git.exe diff-tree -r --raw -C -M --numstat -z %s %s"),rev2,rev1);
1123         }
1124
1125         BYTE_VECTOR out;
1126         if (Run(cmd, &out))
1127                 return -1;
1128
1129         outputlist.ParserFromLog(out);
1130
1131         return 0;
1132 }
1133
1134 int addto_list_each_ref_fn(const char *refname, const unsigned char * /*sha1*/, int /*flags*/, void *cb_data)
1135 {
1136         STRING_VECTOR *list = (STRING_VECTOR*)cb_data;
1137         CString str;
1138         g_Git.StringAppend(&str, (BYTE*)refname, CP_UTF8);
1139         list->push_back(str);
1140         return 0;
1141 }
1142
1143 int CGit::GetTagList(STRING_VECTOR &list)
1144 {
1145         if (this->m_IsUseLibGit2)
1146         {
1147                 git_repository *repo = NULL;
1148
1149                 CStringA gitdir = CUnicodeUtils::GetMulti(CTGitPath(m_CurrentDir).GetGitPathString(), CP_UTF8);
1150                 if (git_repository_open(&repo, gitdir.GetBuffer()))
1151                 {
1152                         gitdir.ReleaseBuffer();
1153                         return -1;
1154                 }
1155                 gitdir.ReleaseBuffer();
1156
1157                 git_strarray tag_names;
1158
1159                 if (git_tag_list(&tag_names, repo))
1160                 {
1161                         git_repository_free(repo);
1162                         return -1;
1163                 }
1164
1165                 for (size_t i = 0; i < tag_names.count; i++)
1166                 {
1167                         CStringA tagName(tag_names.strings[i]);
1168                         list.push_back(CUnicodeUtils::GetUnicode(tagName));
1169                 }
1170
1171                 git_strarray_free(&tag_names);
1172
1173                 git_repository_free(repo);
1174
1175                 std::sort(list.begin(), list.end(), LogicalComparePredicate);
1176
1177                 return 0;
1178         }
1179         else
1180         {
1181                 CString cmd, output;
1182                 cmd=_T("git.exe tag -l");
1183                 int ret = Run(cmd, &output, NULL, CP_UTF8);
1184                 if(!ret)
1185                 {
1186                         int pos=0;
1187                         CString one;
1188                         while( pos>=0 )
1189                         {
1190                                 one=output.Tokenize(_T("\n"),pos);
1191                                 if (!one.IsEmpty())
1192                                         list.push_back(one);
1193                         }
1194                         std::sort(list.begin(), list.end(), LogicalComparePredicate);
1195                 }
1196                 return ret;
1197         }
1198 }
1199
1200 CString CGit::GetGitLastErr(CString msg)
1201 {
1202         if (this->m_IsUseLibGit2)
1203         {
1204                 const git_error *libgit2err = giterr_last();
1205                 if (libgit2err)
1206                 {
1207                         CString lastError = CUnicodeUtils::GetUnicode(CStringA(libgit2err->message));
1208                         giterr_clear();
1209                         return msg + _T("\nlibgit2 returned: ") + lastError;
1210                 }
1211                 else
1212                 {
1213                         return msg + _T("\nUnknown libgit2 error.");
1214                 }
1215         }
1216         else if (gitLastErr.IsEmpty())
1217                 return msg + _T("\nUnknown git.exe error.");
1218         else
1219         {
1220                 CString lastError = gitLastErr;
1221                 gitLastErr.Empty();
1222                 return msg + _T("\n") + lastError;
1223         }
1224 }
1225
1226 CString CGit::FixBranchName_Mod(CString& branchName)
1227 {
1228         if(branchName == "FETCH_HEAD")
1229                 branchName = DerefFetchHead();
1230         return branchName;
1231 }
1232
1233 CString CGit::FixBranchName(const CString& branchName)
1234 {
1235         CString tempBranchName = branchName;
1236         FixBranchName_Mod(tempBranchName);
1237         return tempBranchName;
1238 }
1239
1240 bool CGit::IsBranchTagNameUnique(const CString& name)
1241 {
1242         CString output;
1243
1244         CString cmd;
1245         cmd.Format(_T("git show-ref --tags --heads refs/heads/%s refs/tags/%s"), name, name);
1246         int ret = Run(cmd, &output, NULL, CP_UTF8);
1247         if (!ret)
1248         {
1249                 int i = 0, pos = 0;
1250                 while (pos >= 0)
1251                 {
1252                         if (!output.Tokenize(_T("\n"), pos).IsEmpty())
1253                                 i++;
1254                 }
1255                 if (i >= 2)
1256                         return false;
1257         }
1258
1259         return true;
1260 }
1261
1262 /*
1263 Checks if a branch or tag with the given name exists
1264 isBranch is true -> branch, tag otherwise
1265 */
1266 bool CGit::BranchTagExists(const CString& name, bool isBranch /*= true*/)
1267 {
1268         CString cmd, output;
1269
1270         cmd = _T("git show-ref ");
1271         if (isBranch)
1272                 cmd += _T("--heads ");
1273         else
1274                 cmd += _T("--tags ");
1275
1276         cmd += _T("refs/heads/") + name;
1277         cmd += _T(" refs/tags/") + name;
1278
1279         int ret = Run(cmd, &output, NULL, CP_UTF8);
1280         if (!ret)
1281         {
1282                 if (!output.IsEmpty())
1283                         return true;
1284         }
1285
1286         return false;
1287 }
1288
1289 CString CGit::DerefFetchHead()
1290 {
1291         using namespace std;
1292         CString dotGitPath;
1293         g_GitAdminDir.GetAdminDirPath(m_CurrentDir, dotGitPath);
1294         ifstream fetchHeadFile((dotGitPath + L"FETCH_HEAD").GetString(), ios::in | ios::binary);
1295         int forMergeLineCount = 0;
1296         string line;
1297         string hashToReturn;
1298         while(getline(fetchHeadFile, line))
1299         {
1300                 //Tokenize this line
1301                 string::size_type prevPos = 0;
1302                 string::size_type pos = line.find('\t');
1303                 if(pos == string::npos) continue; //invalid line
1304
1305                 string hash = line.substr(0, pos);
1306                 ++pos; prevPos = pos; pos = line.find('\t', pos); if(pos == string::npos) continue;
1307
1308                 bool forMerge = pos == prevPos;
1309                 ++pos; prevPos = pos; pos = line.size(); if(pos == string::npos) continue;
1310
1311                 string remoteBranch = line.substr(prevPos, pos - prevPos);
1312
1313                 //Process this line
1314                 if(forMerge)
1315                 {
1316                         hashToReturn = hash;
1317                         ++forMergeLineCount;
1318                         if(forMergeLineCount > 1)
1319                                 return L""; //More then 1 branch to merge found. Octopus merge needed. Cannot pick single ref from FETCH_HEAD
1320                 }
1321         }
1322
1323         return CUnicodeUtils::GetUnicode(hashToReturn.c_str());
1324 }
1325
1326 int CGit::GetBranchList(STRING_VECTOR &list,int *current,BRANCH_TYPE type)
1327 {
1328         int ret;
1329         CString cmd, output, cur;
1330         cmd = _T("git.exe branch --no-color");
1331
1332         if((type&BRANCH_ALL) == BRANCH_ALL)
1333                 cmd += _T(" -a");
1334         else if(type&BRANCH_REMOTE)
1335                 cmd += _T(" -r");
1336
1337         ret = Run(cmd, &output, NULL, CP_UTF8);
1338         if(!ret)
1339         {
1340                 int pos=0;
1341                 CString one;
1342                 while( pos>=0 )
1343                 {
1344                         one=output.Tokenize(_T("\n"),pos);
1345                         one.Trim(L" \r\n\t");
1346                         if(one.Find(L" -> ") >= 0 || one.IsEmpty())
1347                                 continue; // skip something like: refs/origin/HEAD -> refs/origin/master
1348                         if(one[0] == _T('*'))
1349                         {
1350                                 one = one.Mid(2);
1351                                 cur = one;
1352                         }
1353                         if (one != _T("(no branch)"))
1354                                 list.push_back(one);
1355                 }
1356         }
1357
1358         if(type & BRANCH_FETCH_HEAD && !DerefFetchHead().IsEmpty())
1359                 list.push_back(L"FETCH_HEAD");
1360
1361         std::sort(list.begin(), list.end(), LogicalCompareBranchesPredicate);
1362
1363         if (current && cur != _T("(no branch)"))
1364         {
1365                 for (unsigned int i = 0; i < list.size(); i++)
1366                 {
1367                         if (list[i] == cur)
1368                         {
1369                                 *current = i;
1370                                 break;
1371                         }
1372                 }
1373         }
1374
1375         return ret;
1376 }
1377
1378 int CGit::GetRemoteList(STRING_VECTOR &list)
1379 {
1380         if (this->m_IsUseLibGit2)
1381         {
1382                 git_repository *repo = NULL;
1383
1384                 CStringA gitdir = CUnicodeUtils::GetMulti(CTGitPath(m_CurrentDir).GetGitPathString(), CP_UTF8);
1385                 if (git_repository_open(&repo, gitdir.GetBuffer()))
1386                 {
1387                         gitdir.ReleaseBuffer();
1388                         return -1;
1389                 }
1390                 gitdir.ReleaseBuffer();
1391
1392                 git_strarray remotes;
1393
1394                 if (git_remote_list(&remotes, repo))
1395                 {
1396                         git_repository_free(repo);
1397                         return -1;
1398                 }
1399
1400                 for (size_t i = 0; i < remotes.count; i++)
1401                 {
1402                         CStringA remote(remotes.strings[i]);
1403                         list.push_back(CUnicodeUtils::GetUnicode(remote));
1404                 }
1405
1406                 git_strarray_free(&remotes);
1407
1408                 git_repository_free(repo);
1409
1410                 std::sort(list.begin(), list.end());
1411
1412                 return 0;
1413         }
1414         else
1415         {
1416                 int ret;
1417                 CString cmd, output;
1418                 cmd=_T("git.exe remote");
1419                 ret = Run(cmd, &output, NULL, CP_UTF8);
1420                 if(!ret)
1421                 {
1422                         int pos=0;
1423                         CString one;
1424                         while( pos>=0 )
1425                         {
1426                                 one=output.Tokenize(_T("\n"),pos);
1427                                 if (!one.IsEmpty())
1428                                         list.push_back(one);
1429                         }
1430                 }
1431                 return ret;
1432         }
1433 }
1434
1435 int CGit::GetRemoteTags(CString remote, STRING_VECTOR &list)
1436 {
1437         CString cmd, out, err;
1438         cmd.Format(_T("git.exe ls-remote -t \"%s\""), remote);
1439         if (Run(cmd, &out, &err, CP_UTF8))
1440         {
1441                 MessageBox(NULL, err, _T("TortoiseGit"), MB_ICONERROR);
1442                 return -1;
1443         }
1444
1445         int pos = 0;
1446         while (pos >= 0)
1447         {
1448                 CString one = out.Tokenize(_T("\n"), pos).Mid(51).Trim(); // sha1, tab + refs/tags/
1449                 // dot not include annotated tags twice; this works, because an annotated tag appears twice (one normal tag and one with ^{} at the end)
1450                 if (one.Find(_T("^{}")) >= 1)
1451                         continue;
1452                 if (!one.IsEmpty())
1453                         list.push_back(one);
1454         }
1455         std::sort(list.begin(), list.end(), LogicalComparePredicate);
1456         return 0;
1457 }
1458
1459 int libgit2_addto_list_each_ref_fn(const char *refname, void *payload)
1460 {
1461         STRING_VECTOR *list = (STRING_VECTOR*)payload;
1462         CString str;
1463         g_Git.StringAppend(&str, (BYTE*)refname, CP_UTF8);
1464         list->push_back(str);
1465         return 0;
1466 }
1467
1468 int CGit::GetRefList(STRING_VECTOR &list)
1469 {
1470         if (this->m_IsUseLibGit2)
1471         {
1472                 git_repository *repo = NULL;
1473
1474                 CStringA gitdir = CUnicodeUtils::GetMulti(CTGitPath(m_CurrentDir).GetGitPathString(), CP_UTF8);
1475                 if (git_repository_open(&repo, gitdir.GetBuffer()))
1476                 {
1477                         gitdir.ReleaseBuffer();
1478                         return -1;
1479                 }
1480                 gitdir.ReleaseBuffer();
1481
1482                 if (git_reference_foreach(repo, GIT_REF_LISTALL, libgit2_addto_list_each_ref_fn, &list))
1483                 {
1484                         git_repository_free(repo);
1485                         return -1;
1486                 }
1487
1488                 git_repository_free(repo);
1489
1490                 std::sort(list.begin(), list.end(), LogicalComparePredicate);
1491
1492                 return 0;
1493         }
1494         else
1495         {
1496                 CString cmd, output;
1497                 cmd=_T("git.exe show-ref -d");
1498                 int ret = Run(cmd, &output, NULL, CP_UTF8);
1499                 if(!ret)
1500                 {
1501                         int pos=0;
1502                         CString one;
1503                         while( pos>=0 )
1504                         {
1505                                 one=output.Tokenize(_T("\n"),pos);
1506                                 int start=one.Find(_T(" "),0);
1507                                 if(start>0)
1508                                 {
1509                                         CString name;
1510                                         name=one.Right(one.GetLength()-start-1);
1511                                         list.push_back(name);
1512                                 }
1513                         }
1514                         std::sort(list.begin(), list.end(), LogicalComparePredicate);
1515                 }
1516                 return ret;
1517         }
1518 }
1519
1520 typedef struct map_each_ref_payload {
1521         git_repository * repo;
1522         MAP_HASH_NAME * map;
1523 } map_each_ref_payload;
1524
1525 int libgit2_addto_map_each_ref_fn(const char *refname, void *payload)
1526 {
1527         map_each_ref_payload *payloadContent = (map_each_ref_payload*)payload;
1528
1529         CString str;
1530         g_Git.StringAppend(&str, (BYTE*)refname, CP_UTF8);
1531
1532         git_object * gitObject = NULL;
1533
1534         do
1535         {
1536                 if (git_revparse_single(&gitObject, payloadContent->repo, refname))
1537                 {
1538                         break;
1539                 }
1540
1541                 if (git_object_type(gitObject) == GIT_OBJ_TAG)
1542                 {
1543                         str += _T("^{}"); // deref tag
1544                         git_object * derefedTag = NULL;
1545                         if (git_object_peel(&derefedTag, gitObject, GIT_OBJ_ANY))
1546                         {
1547                                 break;
1548                         }
1549                         git_object_free(gitObject);
1550                         gitObject = derefedTag;
1551                 }
1552
1553                 const git_oid * oid = git_object_id(gitObject);
1554                 if (oid == NULL)
1555                 {
1556                         break;
1557                 }
1558
1559                 CGitHash hash((char *)oid->id);
1560                 (*payloadContent->map)[hash].push_back(str);
1561         } while (false);
1562
1563         if (gitObject)
1564         {
1565                 git_object_free(gitObject);
1566                 return 0;
1567         }
1568
1569         return 1;
1570 }
1571
1572 int CGit::GetMapHashToFriendName(MAP_HASH_NAME &map)
1573 {
1574         if (this->m_IsUseLibGit2)
1575         {
1576                 git_repository *repo = NULL;
1577
1578                 CStringA gitdir = CUnicodeUtils::GetMulti(CTGitPath(m_CurrentDir).GetGitPathString(), CP_UTF8);
1579                 if (git_repository_open(&repo, gitdir.GetBuffer()))
1580                 {
1581                         gitdir.ReleaseBuffer();
1582                         return -1;
1583                 }
1584                 gitdir.ReleaseBuffer();
1585
1586                 map_each_ref_payload payloadContent = { repo, &map };
1587
1588                 if (git_reference_foreach(repo, GIT_REF_LISTALL, libgit2_addto_map_each_ref_fn, &payloadContent))
1589                 {
1590                         git_repository_free(repo);
1591                         return -1;
1592                 }
1593
1594                 git_repository_free(repo);
1595
1596                 for (auto it = map.begin(); it != map.end(); ++it)
1597                 {
1598                         std::sort(it->second.begin(), it->second.end());
1599                 }
1600
1601                 return 0;
1602         }
1603         else
1604         {
1605                 CString cmd, output;
1606                 cmd=_T("git.exe show-ref -d");
1607                 int ret = Run(cmd, &output, NULL, CP_UTF8);
1608                 if(!ret)
1609                 {
1610                         int pos=0;
1611                         CString one;
1612                         while( pos>=0 )
1613                         {
1614                                 one=output.Tokenize(_T("\n"),pos);
1615                                 int start=one.Find(_T(" "),0);
1616                                 if(start>0)
1617                                 {
1618                                         CString name;
1619                                         name=one.Right(one.GetLength()-start-1);
1620
1621                                         CString hash;
1622                                         hash=one.Left(start);
1623
1624                                         map[CGitHash(hash)].push_back(name);
1625                                 }
1626                         }
1627                 }
1628                 return ret;
1629         }
1630 }
1631
1632 BOOL CGit::CheckMsysGitDir()
1633 {
1634         if (m_bInitialized)
1635         {
1636                 return TRUE;
1637         }
1638
1639         this->m_Environment.clear();
1640         m_Environment.CopyProcessEnvironment();
1641
1642         TCHAR *oldpath;
1643         size_t homesize,size;
1644
1645         // set HOME if not set already
1646         _tgetenv_s(&homesize, NULL, 0, _T("HOME"));
1647         if (!homesize)
1648         {
1649                 CString home = GetHomeDirectory();
1650                 m_Environment.SetEnv(_T("HOME"), home.GetBuffer());
1651                 home.ReleaseBuffer();
1652         }
1653         CString str;
1654
1655         //setup ssh client
1656         CString sshclient=CRegString(_T("Software\\TortoiseGit\\SSH"));
1657
1658         if(!sshclient.IsEmpty())
1659         {
1660                 m_Environment.SetEnv(_T("GIT_SSH"), sshclient.GetBuffer());
1661                 m_Environment.SetEnv(_T("SVN_SSH"), sshclient.GetBuffer());
1662         }
1663         else
1664         {
1665                 TCHAR sPlink[MAX_PATH];
1666                 GetModuleFileName(NULL, sPlink, _countof(sPlink));
1667                 LPTSTR ptr = _tcsrchr(sPlink, _T('\\'));
1668                 if (ptr) {
1669                         _tcscpy_s(ptr + 1, MAX_PATH - (ptr - sPlink + 1), _T("TortoiseGitPLink.exe"));
1670                         m_Environment.SetEnv(_T("GIT_SSH"), sPlink);
1671                         m_Environment.SetEnv(_T("SVN_SSH"), sPlink);
1672                 }
1673         }
1674
1675         {
1676                 TCHAR sAskPass[MAX_PATH];
1677                 GetModuleFileName(NULL, sAskPass, _countof(sAskPass));
1678                 LPTSTR ptr = _tcsrchr(sAskPass, _T('\\'));
1679                 if (ptr)
1680                 {
1681                         _tcscpy_s(ptr + 1, MAX_PATH - (ptr - sAskPass + 1), _T("SshAskPass.exe"));
1682                         m_Environment.SetEnv(_T("DISPLAY"),_T(":9999"));
1683                         m_Environment.SetEnv(_T("SSH_ASKPASS"),sAskPass);
1684                         m_Environment.SetEnv(_T("GIT_ASKPASS"),sAskPass);
1685                 }
1686         }
1687
1688         // add git/bin path to PATH
1689
1690         CRegString msysdir=CRegString(REG_MSYSGIT_PATH,_T(""),FALSE);
1691         str=msysdir;
1692         if(str.IsEmpty() || !FileExists(str + _T("\\git.exe")))
1693         {
1694                 CRegString msyslocalinstalldir = CRegString(REG_MSYSGIT_INSTALL32, _T(""), FALSE, HKEY_CURRENT_USER);
1695                 str = msyslocalinstalldir;
1696                 str.TrimRight(_T("\\"));
1697                 if (str.IsEmpty())
1698                 {
1699                         CRegString msysinstalldir = CRegString(REG_MSYSGIT_INSTALL, _T(""), FALSE, HKEY_LOCAL_MACHINE);
1700                         str = msysinstalldir;
1701                         str.TrimRight(_T("\\"));
1702                 }
1703                 if ( !str.IsEmpty() )
1704                 {
1705                         str += "\\bin";
1706                         msysdir=str;
1707                         CGit::ms_LastMsysGitDir = str;
1708                         msysdir.write();
1709                 }
1710                 else
1711                 {
1712                         // search PATH if git/bin directory is already present
1713                         if ( FindGitPath() )
1714                         {
1715                                 m_bInitialized = TRUE;
1716                                 msysdir = CGit::ms_LastMsysGitDir;
1717                                 msysdir.write();
1718                                 return TRUE;
1719                         }
1720
1721                         return FALSE;
1722                 }
1723         }
1724         else
1725         {
1726                 CGit::ms_LastMsysGitDir = str;
1727         }
1728
1729         // check for git.exe existance (maybe it was deinstalled in the meantime)
1730         if (!FileExists(CGit::ms_LastMsysGitDir + _T("\\git.exe")))
1731                 return FALSE;
1732
1733         //set path
1734         _tdupenv_s(&oldpath,&size,_T("PATH"));
1735
1736         CString path;
1737         path.Format(_T("%s;%s"),oldpath,str + _T(";")+ (CString)CRegString(REG_MSYSGIT_EXTRA_PATH,_T(""),FALSE));
1738
1739         m_Environment.SetEnv(_T("PATH"),path.GetBuffer());
1740
1741         CString str1 = m_Environment.GetEnv(_T("PATH"));
1742
1743         CString sOldPath = oldpath;
1744         free(oldpath);
1745
1746         m_bInitialized = TRUE;
1747         return true;
1748 }
1749
1750 CString CGit::GetHomeDirectory()
1751 {
1752         const wchar_t * homeDir = wget_windows_home_directory();
1753         return CString(homeDir, (int)wcslen(homeDir));
1754 }
1755
1756 CString CGit::GetGitLocalConfig()
1757 {
1758         CString path;
1759         g_GitAdminDir.GetAdminDirPath(g_Git.m_CurrentDir, path);
1760         path += _T("config");
1761         return path;
1762 }
1763
1764 CString CGit::GetGitGlobalConfig()
1765 {
1766         return g_Git.GetHomeDirectory() + _T("\\.gitconfig");
1767 }
1768
1769 CString CGit::GetGitGlobalXDGConfigPath()
1770 {
1771         return g_Git.GetHomeDirectory() + _T("\\.config\\git");
1772 }
1773
1774 CString CGit::GetGitGlobalXDGConfig()
1775 {
1776         return g_Git.GetGitGlobalXDGConfigPath() + _T("\\config");
1777 }
1778
1779 CString CGit::GetGitSystemConfig()
1780 {
1781         const wchar_t * systemConfig = wget_msysgit_etc();
1782         return CString(systemConfig, (int)wcslen(systemConfig));
1783 }
1784
1785 BOOL CGit::CheckCleanWorkTree()
1786 {
1787         CString out;
1788         CString cmd;
1789         cmd=_T("git.exe rev-parse --verify HEAD");
1790
1791         if(Run(cmd,&out,CP_UTF8))
1792                 return FALSE;
1793
1794         cmd=_T("git.exe update-index --ignore-submodules --refresh");
1795         if(Run(cmd,&out,CP_UTF8))
1796                 return FALSE;
1797
1798         cmd=_T("git.exe diff-files --quiet --ignore-submodules");
1799         if(Run(cmd,&out,CP_UTF8))
1800                 return FALSE;
1801
1802         cmd=_T("git diff-index --cached --quiet HEAD --ignore-submodules");
1803         if(Run(cmd,&out,CP_UTF8))
1804                 return FALSE;
1805
1806         return TRUE;
1807 }
1808 int CGit::Revert(CString commit, CTGitPathList &list, bool)
1809 {
1810         int ret;
1811         for(int i=0;i<list.GetCount();i++)
1812         {
1813                 ret = Revert(commit, (CTGitPath&)list[i]);
1814                 if(ret)
1815                         return ret;
1816         }
1817         return 0;
1818 }
1819 int CGit::Revert(CString commit, CTGitPath &path)
1820 {
1821         CString cmd, out;
1822
1823         if(path.m_Action & CTGitPath::LOGACTIONS_REPLACED && !path.GetGitOldPathString().IsEmpty())
1824         {
1825                 if (CTGitPath(path.GetGitOldPathString()).IsDirectory())
1826                 {
1827                         CString err;
1828                         err.Format(_T("Cannot revert renaming of \"%s\". A directory with the old name \"%s\" exists."), path.GetGitPathString(), path.GetGitOldPathString());
1829                         ::MessageBox(NULL, err, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
1830                         return -1;
1831                 }
1832                 CString force;
1833                 // if the filenames only differ in case, we have to pass "-f"
1834                 if (path.GetGitPathString().CompareNoCase(path.GetGitOldPathString()) == 0)
1835                         force = _T("-f ");
1836                 cmd.Format(_T("git.exe mv %s-- \"%s\" \"%s\""), force, path.GetGitPathString(), path.GetGitOldPathString());
1837                 if (Run(cmd, &out, CP_UTF8))
1838                 {
1839                         ::MessageBox(NULL, out, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
1840                         return -1;
1841                 }
1842
1843                 cmd.Format(_T("git.exe checkout %s -f -- \"%s\""), commit, path.GetGitOldPathString());
1844                 if (Run(cmd, &out, CP_UTF8))
1845                 {
1846                         ::MessageBox(NULL, out, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
1847                         return -1;
1848                 }
1849
1850         }
1851         else if(path.m_Action & CTGitPath::LOGACTIONS_ADDED)
1852         {       //To init git repository, there are not HEAD, so we can use git reset command
1853                 cmd.Format(_T("git.exe rm -f --cached -- \"%s\""),path.GetGitPathString());
1854
1855                 if (Run(cmd, &out, CP_UTF8))
1856                 {
1857                         ::MessageBox(NULL, out, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
1858                         return -1;
1859                 }
1860         }
1861         else
1862         {
1863                 cmd.Format(_T("git.exe checkout %s -f -- \"%s\""), commit, path.GetGitPathString());
1864                 if (Run(cmd, &out, CP_UTF8))
1865                 {
1866                         ::MessageBox(NULL, out, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
1867                         return -1;
1868                 }
1869         }
1870
1871         if (path.m_Action & CTGitPath::LOGACTIONS_DELETED)
1872         {
1873                 cmd.Format(_T("git.exe add -f -- \"%s\""), path.GetGitPathString());
1874                 if (Run(cmd, &out, CP_UTF8))
1875                 {
1876                         ::MessageBox(NULL, out, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
1877                         return -1;
1878                 }
1879         }
1880
1881         return 0;
1882 }
1883
1884 int CGit::ListConflictFile(CTGitPathList &list,CTGitPath *path)
1885 {
1886         BYTE_VECTOR vector;
1887
1888         CString cmd;
1889         if(path)
1890                 cmd.Format(_T("git.exe ls-files -u -t -z -- \"%s\""),path->GetGitPathString());
1891         else
1892                 cmd=_T("git.exe ls-files -u -t -z");
1893
1894         if (Run(cmd, &vector))
1895         {
1896                 return -1;
1897         }
1898
1899         list.ParserFromLsFile(vector);
1900
1901         return 0;
1902 }
1903
1904 bool CGit::IsFastForward(const CString &from, const CString &to, CGitHash * commonAncestor)
1905 {
1906         CString base;
1907         CGitHash basehash,hash;
1908         CString cmd, err;
1909         cmd.Format(_T("git.exe merge-base %s %s"), FixBranchName(to), FixBranchName(from));
1910
1911         if (Run(cmd, &base, &err, CP_UTF8))
1912         {
1913                 return false;
1914         }
1915         basehash = base.Trim();
1916
1917         GetHash(hash, from);
1918
1919         if (commonAncestor)
1920                 *commonAncestor = basehash;
1921
1922         return hash == basehash;
1923 }
1924
1925 unsigned int CGit::Hash2int(CGitHash &hash)
1926 {
1927         int ret=0;
1928         for(int i=0;i<4;i++)
1929         {
1930                 ret = ret << 8;
1931                 ret |= hash.m_hash[i];
1932         }
1933         return ret;
1934 }
1935
1936 int CGit::RefreshGitIndex()
1937 {
1938         if(g_Git.m_IsUseGitDLL)
1939         {
1940                 CAutoLocker lock(g_Git.m_critGitDllSec);
1941                 try
1942                 {
1943                         return git_run_cmd("update-index","update-index -q --refresh");
1944
1945                 }catch(...)
1946                 {
1947                         return -1;
1948                 }
1949
1950         }
1951         else
1952         {
1953                 CString cmd,output;
1954                 cmd=_T("git.exe update-index --refresh");
1955                 return Run(cmd, &output, CP_UTF8);
1956         }
1957 }
1958
1959 int CGit::GetOneFile(CString Refname, CTGitPath &path, const CString &outputfile)
1960 {
1961         if(g_Git.m_IsUseGitDLL)
1962         {
1963                 CAutoLocker lock(g_Git.m_critGitDllSec);
1964                 try
1965                 {
1966                         g_Git.CheckAndInitDll();
1967                         CStringA ref, patha, outa;
1968                         ref = CUnicodeUtils::GetMulti(Refname, CP_UTF8);
1969                         patha = CUnicodeUtils::GetMulti(path.GetGitPathString(), CP_UTF8);
1970                         outa = CUnicodeUtils::GetMulti(outputfile, CP_UTF8);
1971                         ::DeleteFile(outputfile);
1972                         return git_checkout_file((const char*)ref.GetBuffer(),(const char*)patha.GetBuffer(),(const char*)outa.GetBuffer());
1973
1974                 }catch(...)
1975                 {
1976                         return -1;
1977                 }
1978         }
1979         else
1980         {
1981                 CString cmd;
1982                 cmd.Format(_T("git.exe cat-file -p %s:\"%s\""), Refname, path.GetGitPathString());
1983                 return RunLogFile(cmd,outputfile);
1984         }
1985 }
1986 void CEnvironment::CopyProcessEnvironment()
1987 {
1988         TCHAR *p = GetEnvironmentStrings();
1989         while(*p !=0 || *(p+1) !=0)
1990                 this->push_back(*p++);
1991
1992         push_back(_T('\0'));
1993         push_back(_T('\0'));
1994 }
1995
1996 CString CEnvironment::GetEnv(TCHAR *name)
1997 {
1998         CString str;
1999         for (size_t i = 0; i < size(); i++)
2000         {
2001                 str = &(*this)[i];
2002                 int start =0;
2003                 CString sname = str.Tokenize(_T("="),start);
2004                 if(sname.CompareNoCase(name) == 0)
2005                 {
2006                         return &(*this)[i+start];
2007                 }
2008                 i+=str.GetLength();
2009         }
2010         return _T("");
2011 }
2012
2013 void CEnvironment::SetEnv(TCHAR *name, TCHAR* value)
2014 {
2015         unsigned int i;
2016         for( i=0;i<size();i++)
2017         {
2018                 CString str = &(*this)[i];
2019                 int start =0;
2020                 CString sname = str.Tokenize(_T("="),start);
2021                 if(sname.CompareNoCase(name) == 0)
2022                 {
2023                         break;
2024                 }
2025                 i+=str.GetLength();
2026         }
2027
2028         if(i == size())
2029         {
2030                 i -= 1; // roll back terminate \0\0
2031                 this->push_back(_T('\0'));
2032         }
2033
2034         CEnvironment::iterator it;
2035         it=this->begin();
2036         it += i;
2037
2038         while(*it && i<size())
2039         {
2040                 this->erase(it);
2041                 it=this->begin();
2042                 it += i;
2043         }
2044
2045         while(*name)
2046         {
2047                 this->insert(it,*name++);
2048                 i++;
2049                 it= begin()+i;
2050         }
2051
2052         this->insert(it, _T('='));
2053         i++;
2054         it= begin()+i;
2055
2056         while(*value)
2057         {
2058                 this->insert(it,*value++);
2059                 i++;
2060                 it= begin()+i;
2061         }
2062
2063 }
2064
2065 int CGit::GetGitEncode(TCHAR* configkey)
2066 {
2067         CString str=GetConfigValue(configkey);
2068
2069         if(str.IsEmpty())
2070                 return CP_UTF8;
2071
2072         return CUnicodeUtils::GetCPCode(str);
2073 }
2074
2075
2076 int CGit::GetDiffPath(CTGitPathList *PathList, CGitHash *hash1, CGitHash *hash2, char *arg)
2077 {
2078         GIT_FILE file=0;
2079         int ret=0;
2080         GIT_DIFF diff=0;
2081
2082         CAutoLocker lock(g_Git.m_critGitDllSec);
2083
2084         if(arg == NULL)
2085                 diff = GetGitDiff();
2086         else
2087                 git_open_diff(&diff, arg);
2088
2089         if(diff ==NULL)
2090                 return -1;
2091
2092         bool isStat = 0;
2093         if(arg == NULL)
2094                 isStat = true;
2095         else
2096                 isStat = !!strstr(arg, "stat");
2097
2098         int count=0;
2099
2100         if(hash2 == NULL)
2101                 ret = git_root_diff(diff, hash1->m_hash, &file, &count,isStat);
2102         else
2103                 ret = git_diff(diff,hash2->m_hash,hash1->m_hash,&file,&count,isStat);
2104
2105         if(ret)
2106                 return -1;
2107
2108         CTGitPath path;
2109         CString strnewname;
2110         CString stroldname;
2111
2112         for(int j=0;j<count;j++)
2113         {
2114                 path.Reset();
2115                 char *newname;
2116                 char *oldname;
2117
2118                 strnewname.Empty();
2119                 stroldname.Empty();
2120
2121                 int mode=0,IsBin=0,inc=0,dec=0;
2122                 git_get_diff_file(diff,file,j,&newname,&oldname,
2123                                         &mode,&IsBin,&inc,&dec);
2124
2125                 StringAppend(&strnewname, (BYTE*)newname, CP_UTF8);
2126                 StringAppend(&stroldname, (BYTE*)oldname, CP_UTF8);
2127
2128                 path.SetFromGit(strnewname,&stroldname);
2129                 path.ParserAction((BYTE)mode);
2130
2131                 if(IsBin)
2132                 {
2133                         path.m_StatAdd=_T("-");
2134                         path.m_StatDel=_T("-");
2135                 }
2136                 else
2137                 {
2138                         path.m_StatAdd.Format(_T("%d"),inc);
2139                         path.m_StatDel.Format(_T("%d"),dec);
2140                 }
2141                 PathList->AddPath(path);
2142         }
2143         git_diff_flush(diff);
2144
2145         if(arg)
2146                 git_close_diff(diff);
2147
2148         return 0;
2149 }
2150
2151 int CGit::GetShortHASHLength()
2152 {
2153         return 7;
2154 }
2155
2156 CString CGit::GetShortName(CString ref, REF_TYPE *out_type)
2157 {
2158         CString str=ref;
2159         CString shortname;
2160         REF_TYPE type = CGit::UNKNOWN;
2161
2162         if (CGit::GetShortName(str, shortname, _T("refs/heads/")))
2163         {
2164                 type = CGit::LOCAL_BRANCH;
2165
2166         }
2167         else if (CGit::GetShortName(str, shortname, _T("refs/remotes/")))
2168         {
2169                 type = CGit::REMOTE_BRANCH;
2170         }
2171         else if (CGit::GetShortName(str, shortname, _T("refs/tags/")))
2172         {
2173                 type = CGit::TAG;
2174         }
2175         else if (CGit::GetShortName(str, shortname, _T("refs/stash")))
2176         {
2177                 type = CGit::STASH;
2178                 shortname=_T("stash");
2179         }
2180         else if (CGit::GetShortName(str, shortname, _T("refs/bisect/")))
2181         {
2182                 if (shortname.Find(_T("good")) == 0)
2183                 {
2184                         type = CGit::BISECT_GOOD;
2185                         shortname = _T("good");
2186                 }
2187
2188                 if (shortname.Find(_T("bad")) == 0)
2189                 {
2190                         type = CGit::BISECT_BAD;
2191                         shortname = _T("bad");
2192                 }
2193         }
2194         else if (CGit::GetShortName(str, shortname, _T("refs/notes/")))
2195         {
2196                 type = CGit::NOTES;
2197         }
2198         else
2199         {
2200                 type = CGit::UNKNOWN;
2201                 shortname = _T("Unknown");
2202         }
2203
2204         if(out_type)
2205                 *out_type = type;
2206
2207         return shortname;
2208 }