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