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