src/Git/Git.cpp

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