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