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