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         outputlist.ParserFromLsFile(cmdout);
1078         for(int i = 0; i < outputlist.GetCount(); ++i)
1079                 const_cast<CTGitPath&>(outputlist[i]).m_Action = CTGitPath::LOGACTIONS_ADDED;
1080
1081         return 0;
1082 }
1083 int CGit::GetCommitDiffList(const CString &rev1,const CString &rev2,CTGitPathList &outputlist)
1084 {
1085         CString cmd;
1086
1087         if(rev1 == GIT_REV_ZERO || rev2 == GIT_REV_ZERO)
1088         {
1089                 //rev1=+_T("");
1090                 if(rev1 == GIT_REV_ZERO)
1091                         cmd.Format(_T("git.exe diff -r --raw -C -M --numstat -z %s"),rev2);
1092                 else
1093                         cmd.Format(_T("git.exe diff -r -R --raw -C -M --numstat -z %s"),rev1);
1094         }
1095         else
1096         {
1097                 cmd.Format(_T("git.exe diff-tree -r --raw -C -M --numstat -z %s %s"),rev2,rev1);
1098         }
1099
1100         BYTE_VECTOR out;
1101         if (Run(cmd, &out))
1102                 return -1;
1103
1104         outputlist.ParserFromLog(out);
1105
1106         return 0;
1107 }
1108
1109 int addto_list_each_ref_fn(const char *refname, const unsigned char * /*sha1*/, int /*flags*/, void *cb_data)
1110 {
1111         STRING_VECTOR *list = (STRING_VECTOR*)cb_data;
1112         CString str;
1113         g_Git.StringAppend(&str, (BYTE*)refname, CP_UTF8);
1114         list->push_back(str);
1115         return 0;
1116 }
1117
1118 int CGit::GetTagList(STRING_VECTOR &list)
1119 {
1120         if (this->m_IsUseLibGit2)
1121         {
1122                 git_repository *repo = NULL;
1123
1124                 CStringA gitdir = CUnicodeUtils::GetMulti(CTGitPath(m_CurrentDir).GetGitPathString(), CP_UTF8);
1125                 if (git_repository_open(&repo, gitdir.GetBuffer()))
1126                 {
1127                         gitdir.ReleaseBuffer();
1128                         return -1;
1129                 }
1130                 gitdir.ReleaseBuffer();
1131
1132                 git_strarray tag_names;
1133
1134                 if (git_tag_list(&tag_names, repo))
1135                 {
1136                         git_repository_free(repo);
1137                         return -1;
1138                 }
1139
1140                 for (size_t i = 0; i < tag_names.count; ++i)
1141                 {
1142                         CStringA tagName(tag_names.strings[i]);
1143                         list.push_back(CUnicodeUtils::GetUnicode(tagName));
1144                 }
1145
1146                 git_strarray_free(&tag_names);
1147
1148                 git_repository_free(repo);
1149
1150                 std::sort(list.begin(), list.end(), LogicalComparePredicate);
1151
1152                 return 0;
1153         }
1154         else
1155         {
1156                 CString cmd, output;
1157                 cmd=_T("git.exe tag -l");
1158                 int ret = Run(cmd, &output, NULL, CP_UTF8);
1159                 if(!ret)
1160                 {
1161                         int pos=0;
1162                         CString one;
1163                         while( pos>=0 )
1164                         {
1165                                 one=output.Tokenize(_T("\n"),pos);
1166                                 if (!one.IsEmpty())
1167                                         list.push_back(one);
1168                         }
1169                         std::sort(list.begin(), list.end(), LogicalComparePredicate);
1170                 }
1171                 return ret;
1172         }
1173 }
1174
1175 /**
1176 Use this method only if m_IsUseLibGit2 is used for fallbacks.
1177 If you directly use libgit2 methods, use GetLibGit2LastErr instead.
1178 */
1179 CString CGit::GetGitLastErr(CString msg)
1180 {
1181         if (this->m_IsUseLibGit2)
1182                 return GetLibGit2LastErr(msg);
1183         else if (gitLastErr.IsEmpty())
1184                 return msg + _T("\nUnknown git.exe error.");
1185         else
1186         {
1187                 CString lastError = gitLastErr;
1188                 gitLastErr.Empty();
1189                 return msg + _T("\n") + lastError;
1190         }
1191 }
1192
1193 CString CGit::GetLibGit2LastErr()
1194 {
1195         const git_error *libgit2err = giterr_last();
1196         if (libgit2err)
1197         {
1198                 CString lastError = CUnicodeUtils::GetUnicode(CStringA(libgit2err->message));
1199                 giterr_clear();
1200                 return _T("libgit2 returned: ") + lastError;
1201         }
1202         else
1203                 return _T("An error occoured in libgit2, but no message is available.");
1204 }
1205
1206 CString CGit::GetLibGit2LastErr(CString msg)
1207 {
1208         if (!msg.IsEmpty())
1209                 return msg + _T("\n") + GetLibGit2LastErr();
1210         return GetLibGit2LastErr();
1211 }
1212
1213 CString CGit::FixBranchName_Mod(CString& branchName)
1214 {
1215         if(branchName == "FETCH_HEAD")
1216                 branchName = DerefFetchHead();
1217         return branchName;
1218 }
1219
1220 CString CGit::FixBranchName(const CString& branchName)
1221 {
1222         CString tempBranchName = branchName;
1223         FixBranchName_Mod(tempBranchName);
1224         return tempBranchName;
1225 }
1226
1227 bool CGit::IsBranchTagNameUnique(const CString& name)
1228 {
1229         CString output;
1230
1231         CString cmd;
1232         cmd.Format(_T("git show-ref --tags --heads refs/heads/%s refs/tags/%s"), name, name);
1233         int ret = Run(cmd, &output, NULL, CP_UTF8);
1234         if (!ret)
1235         {
1236                 int i = 0, pos = 0;
1237                 while (pos >= 0)
1238                 {
1239                         if (!output.Tokenize(_T("\n"), pos).IsEmpty())
1240                                 ++i;
1241                 }
1242                 if (i >= 2)
1243                         return false;
1244         }
1245
1246         return true;
1247 }
1248
1249 /*
1250 Checks if a branch or tag with the given name exists
1251 isBranch is true -> branch, tag otherwise
1252 */
1253 bool CGit::BranchTagExists(const CString& name, bool isBranch /*= true*/)
1254 {
1255         CString cmd, output;
1256
1257         cmd = _T("git show-ref ");
1258         if (isBranch)
1259                 cmd += _T("--heads ");
1260         else
1261                 cmd += _T("--tags ");
1262
1263         cmd += _T("refs/heads/") + name;
1264         cmd += _T(" refs/tags/") + name;
1265
1266         int ret = Run(cmd, &output, NULL, CP_UTF8);
1267         if (!ret)
1268         {
1269                 if (!output.IsEmpty())
1270                         return true;
1271         }
1272
1273         return false;
1274 }
1275
1276 CString CGit::DerefFetchHead()
1277 {
1278         using namespace std;
1279         CString dotGitPath;
1280         g_GitAdminDir.GetAdminDirPath(m_CurrentDir, dotGitPath);
1281         ifstream fetchHeadFile((dotGitPath + L"FETCH_HEAD").GetString(), ios::in | ios::binary);
1282         int forMergeLineCount = 0;
1283         string line;
1284         string hashToReturn;
1285         while(getline(fetchHeadFile, line))
1286         {
1287                 //Tokenize this line
1288                 string::size_type prevPos = 0;
1289                 string::size_type pos = line.find('\t');
1290                 if(pos == string::npos) continue; //invalid line
1291
1292                 string hash = line.substr(0, pos);
1293                 ++pos; prevPos = pos; pos = line.find('\t', pos); if(pos == string::npos) continue;
1294
1295                 bool forMerge = pos == prevPos;
1296                 ++pos; prevPos = pos; pos = line.size(); if(pos == string::npos) continue;
1297
1298                 string remoteBranch = line.substr(prevPos, pos - prevPos);
1299
1300                 //Process this line
1301                 if(forMerge)
1302                 {
1303                         hashToReturn = hash;
1304                         ++forMergeLineCount;
1305                         if(forMergeLineCount > 1)
1306                                 return L""; //More then 1 branch to merge found. Octopus merge needed. Cannot pick single ref from FETCH_HEAD
1307                 }
1308         }
1309
1310         return CUnicodeUtils::GetUnicode(hashToReturn.c_str());
1311 }
1312
1313 int CGit::GetBranchList(STRING_VECTOR &list,int *current,BRANCH_TYPE type)
1314 {
1315         int ret;
1316         CString cmd, output, cur;
1317         cmd = _T("git.exe branch --no-color");
1318
1319         if((type&BRANCH_ALL) == BRANCH_ALL)
1320                 cmd += _T(" -a");
1321         else if(type&BRANCH_REMOTE)
1322                 cmd += _T(" -r");
1323
1324         ret = Run(cmd, &output, NULL, CP_UTF8);
1325         if(!ret)
1326         {
1327                 int pos=0;
1328                 CString one;
1329                 while( pos>=0 )
1330                 {
1331                         one=output.Tokenize(_T("\n"),pos);
1332                         one.Trim(L" \r\n\t");
1333                         if(one.Find(L" -> ") >= 0 || one.IsEmpty())
1334                                 continue; // skip something like: refs/origin/HEAD -> refs/origin/master
1335                         if(one[0] == _T('*'))
1336                         {
1337                                 one = one.Mid(2);
1338                                 cur = one;
1339                         }
1340                         if (one != _T("(no branch)"))
1341                                 list.push_back(one);
1342                 }
1343         }
1344
1345         if(type & BRANCH_FETCH_HEAD && !DerefFetchHead().IsEmpty())
1346                 list.push_back(L"FETCH_HEAD");
1347
1348         std::sort(list.begin(), list.end(), LogicalCompareBranchesPredicate);
1349
1350         if (current && cur != _T("(no branch)"))
1351         {
1352                 for (unsigned int i = 0; i < list.size(); ++i)
1353                 {
1354                         if (list[i] == cur)
1355                         {
1356                                 *current = i;
1357                                 break;
1358                         }
1359                 }
1360         }
1361
1362         return ret;
1363 }
1364
1365 int CGit::GetRemoteList(STRING_VECTOR &list)
1366 {
1367         if (this->m_IsUseLibGit2)
1368         {
1369                 git_repository *repo = NULL;
1370
1371                 CStringA gitdir = CUnicodeUtils::GetMulti(CTGitPath(m_CurrentDir).GetGitPathString(), CP_UTF8);
1372                 if (git_repository_open(&repo, gitdir.GetBuffer()))
1373                 {
1374                         gitdir.ReleaseBuffer();
1375                         return -1;
1376                 }
1377                 gitdir.ReleaseBuffer();
1378
1379                 git_strarray remotes;
1380
1381                 if (git_remote_list(&remotes, repo))
1382                 {
1383                         git_repository_free(repo);
1384                         return -1;
1385                 }
1386
1387                 for (size_t i = 0; i < remotes.count; ++i)
1388                 {
1389                         CStringA remote(remotes.strings[i]);
1390                         list.push_back(CUnicodeUtils::GetUnicode(remote));
1391                 }
1392
1393                 git_strarray_free(&remotes);
1394
1395                 git_repository_free(repo);
1396
1397                 std::sort(list.begin(), list.end());
1398
1399                 return 0;
1400         }
1401         else
1402         {
1403                 int ret;
1404                 CString cmd, output;
1405                 cmd=_T("git.exe remote");
1406                 ret = Run(cmd, &output, NULL, CP_UTF8);
1407                 if(!ret)
1408                 {
1409                         int pos=0;
1410                         CString one;
1411                         while( pos>=0 )
1412                         {
1413                                 one=output.Tokenize(_T("\n"),pos);
1414                                 if (!one.IsEmpty())
1415                                         list.push_back(one);
1416                         }
1417                 }
1418                 return ret;
1419         }
1420 }
1421
1422 int CGit::GetRemoteTags(CString remote, STRING_VECTOR &list)
1423 {
1424         CString cmd, out, err;
1425         cmd.Format(_T("git.exe ls-remote -t \"%s\""), remote);
1426         if (Run(cmd, &out, &err, CP_UTF8))
1427         {
1428                 MessageBox(NULL, err, _T("TortoiseGit"), MB_ICONERROR);
1429                 return -1;
1430         }
1431
1432         int pos = 0;
1433         while (pos >= 0)
1434         {
1435                 CString one = out.Tokenize(_T("\n"), pos).Mid(51).Trim(); // sha1, tab + refs/tags/
1436                 // dot not include annotated tags twice; this works, because an annotated tag appears twice (one normal tag and one with ^{} at the end)
1437                 if (one.Find(_T("^{}")) >= 1)
1438                         continue;
1439                 if (!one.IsEmpty())
1440                         list.push_back(one);
1441         }
1442         std::sort(list.begin(), list.end(), LogicalComparePredicate);
1443         return 0;
1444 }
1445
1446 int libgit2_addto_list_each_ref_fn(const char *refname, void *payload)
1447 {
1448         STRING_VECTOR *list = (STRING_VECTOR*)payload;
1449         CString str;
1450         g_Git.StringAppend(&str, (BYTE*)refname, CP_UTF8);
1451         list->push_back(str);
1452         return 0;
1453 }
1454
1455 int CGit::GetRefList(STRING_VECTOR &list)
1456 {
1457         if (this->m_IsUseLibGit2)
1458         {
1459                 git_repository *repo = NULL;
1460
1461                 CStringA gitdir = CUnicodeUtils::GetMulti(CTGitPath(m_CurrentDir).GetGitPathString(), CP_UTF8);
1462                 if (git_repository_open(&repo, gitdir.GetBuffer()))
1463                 {
1464                         gitdir.ReleaseBuffer();
1465                         return -1;
1466                 }
1467                 gitdir.ReleaseBuffer();
1468
1469                 if (git_reference_foreach(repo, GIT_REF_LISTALL, libgit2_addto_list_each_ref_fn, &list))
1470                 {
1471                         git_repository_free(repo);
1472                         return -1;
1473                 }
1474
1475                 git_repository_free(repo);
1476
1477                 std::sort(list.begin(), list.end(), LogicalComparePredicate);
1478
1479                 return 0;
1480         }
1481         else
1482         {
1483                 CString cmd, output;
1484                 cmd=_T("git.exe show-ref -d");
1485                 int ret = Run(cmd, &output, NULL, CP_UTF8);
1486                 if(!ret)
1487                 {
1488                         int pos=0;
1489                         CString one;
1490                         while( pos>=0 )
1491                         {
1492                                 one=output.Tokenize(_T("\n"),pos);
1493                                 int start=one.Find(_T(" "),0);
1494                                 if(start>0)
1495                                 {
1496                                         CString name;
1497                                         name=one.Right(one.GetLength()-start-1);
1498                                         list.push_back(name);
1499                                 }
1500                         }
1501                         std::sort(list.begin(), list.end(), LogicalComparePredicate);
1502                 }
1503                 return ret;
1504         }
1505 }
1506
1507 typedef struct map_each_ref_payload {
1508         git_repository * repo;
1509         MAP_HASH_NAME * map;
1510 } map_each_ref_payload;
1511
1512 int libgit2_addto_map_each_ref_fn(const char *refname, void *payload)
1513 {
1514         map_each_ref_payload *payloadContent = (map_each_ref_payload*)payload;
1515
1516         CString str;
1517         g_Git.StringAppend(&str, (BYTE*)refname, CP_UTF8);
1518
1519         git_object * gitObject = NULL;
1520
1521         do
1522         {
1523                 if (git_revparse_single(&gitObject, payloadContent->repo, refname))
1524                 {
1525                         break;
1526                 }
1527
1528                 if (git_object_type(gitObject) == GIT_OBJ_TAG)
1529                 {
1530                         str += _T("^{}"); // deref tag
1531                         git_object * derefedTag = NULL;
1532                         if (git_object_peel(&derefedTag, gitObject, GIT_OBJ_ANY))
1533                         {
1534                                 break;
1535                         }
1536                         git_object_free(gitObject);
1537                         gitObject = derefedTag;
1538                 }
1539
1540                 const git_oid * oid = git_object_id(gitObject);
1541                 if (oid == NULL)
1542                 {
1543                         break;
1544                 }
1545
1546                 CGitHash hash((char *)oid->id);
1547                 (*payloadContent->map)[hash].push_back(str);
1548         } while (false);
1549
1550         if (gitObject)
1551         {
1552                 git_object_free(gitObject);
1553                 return 0;
1554         }
1555
1556         return 1;
1557 }
1558
1559 int CGit::GetMapHashToFriendName(MAP_HASH_NAME &map)
1560 {
1561         if (this->m_IsUseLibGit2)
1562         {
1563                 git_repository *repo = NULL;
1564
1565                 CStringA gitdir = CUnicodeUtils::GetMulti(CTGitPath(m_CurrentDir).GetGitPathString(), CP_UTF8);
1566                 if (git_repository_open(&repo, gitdir.GetBuffer()))
1567                 {
1568                         gitdir.ReleaseBuffer();
1569                         return -1;
1570                 }
1571                 gitdir.ReleaseBuffer();
1572
1573                 map_each_ref_payload payloadContent = { repo, &map };
1574
1575                 if (git_reference_foreach(repo, GIT_REF_LISTALL, libgit2_addto_map_each_ref_fn, &payloadContent))
1576                 {
1577                         git_repository_free(repo);
1578                         return -1;
1579                 }
1580
1581                 git_repository_free(repo);
1582
1583                 for (auto it = map.begin(); it != map.end(); ++it)
1584                 {
1585                         std::sort(it->second.begin(), it->second.end());
1586                 }
1587
1588                 return 0;
1589         }
1590         else
1591         {
1592                 CString cmd, output;
1593                 cmd=_T("git.exe show-ref -d");
1594                 int ret = Run(cmd, &output, NULL, CP_UTF8);
1595                 if(!ret)
1596                 {
1597                         int pos=0;
1598                         CString one;
1599                         while( pos>=0 )
1600                         {
1601                                 one=output.Tokenize(_T("\n"),pos);
1602                                 int start=one.Find(_T(" "),0);
1603                                 if(start>0)
1604                                 {
1605                                         CString name;
1606                                         name=one.Right(one.GetLength()-start-1);
1607
1608                                         CString hash;
1609                                         hash=one.Left(start);
1610
1611                                         map[CGitHash(hash)].push_back(name);
1612                                 }
1613                         }
1614                 }
1615                 return ret;
1616         }
1617 }
1618
1619 BOOL CGit::CheckMsysGitDir()
1620 {
1621         if (m_bInitialized)
1622         {
1623                 return TRUE;
1624         }
1625
1626         this->m_Environment.clear();
1627         m_Environment.CopyProcessEnvironment();
1628
1629         TCHAR *oldpath;
1630         size_t homesize,size;
1631
1632         // set HOME if not set already
1633         _tgetenv_s(&homesize, NULL, 0, _T("HOME"));
1634         if (!homesize)
1635         {
1636                 CString home = GetHomeDirectory();
1637                 m_Environment.SetEnv(_T("HOME"), home.GetBuffer());
1638                 home.ReleaseBuffer();
1639         }
1640         CString str;
1641
1642         //setup ssh client
1643         CString sshclient=CRegString(_T("Software\\TortoiseGit\\SSH"));
1644
1645         if(!sshclient.IsEmpty())
1646         {
1647                 m_Environment.SetEnv(_T("GIT_SSH"), sshclient.GetBuffer());
1648                 m_Environment.SetEnv(_T("SVN_SSH"), sshclient.GetBuffer());
1649         }
1650         else
1651         {
1652                 TCHAR sPlink[MAX_PATH];
1653                 GetModuleFileName(NULL, sPlink, _countof(sPlink));
1654                 LPTSTR ptr = _tcsrchr(sPlink, _T('\\'));
1655                 if (ptr) {
1656                         _tcscpy_s(ptr + 1, MAX_PATH - (ptr - sPlink + 1), _T("TortoiseGitPLink.exe"));
1657                         m_Environment.SetEnv(_T("GIT_SSH"), sPlink);
1658                         m_Environment.SetEnv(_T("SVN_SSH"), sPlink);
1659                 }
1660         }
1661
1662         {
1663                 TCHAR sAskPass[MAX_PATH];
1664                 GetModuleFileName(NULL, sAskPass, _countof(sAskPass));
1665                 LPTSTR ptr = _tcsrchr(sAskPass, _T('\\'));
1666                 if (ptr)
1667                 {
1668                         _tcscpy_s(ptr + 1, MAX_PATH - (ptr - sAskPass + 1), _T("SshAskPass.exe"));
1669                         m_Environment.SetEnv(_T("DISPLAY"),_T(":9999"));
1670                         m_Environment.SetEnv(_T("SSH_ASKPASS"),sAskPass);
1671                         m_Environment.SetEnv(_T("GIT_ASKPASS"),sAskPass);
1672                 }
1673         }
1674
1675         // add git/bin path to PATH
1676
1677         CRegString msysdir=CRegString(REG_MSYSGIT_PATH,_T(""),FALSE);
1678         str=msysdir;
1679         if(str.IsEmpty() || !FileExists(str + _T("\\git.exe")))
1680         {
1681                 CRegString msyslocalinstalldir = CRegString(REG_MSYSGIT_INSTALL_LOCAL, _T(""), FALSE, HKEY_CURRENT_USER);
1682                 str = msyslocalinstalldir;
1683                 str.TrimRight(_T("\\"));
1684                 if (str.IsEmpty())
1685                 {
1686                         CRegString msysinstalldir = CRegString(REG_MSYSGIT_INSTALL, _T(""), FALSE, HKEY_LOCAL_MACHINE);
1687                         str = msysinstalldir;
1688                         str.TrimRight(_T("\\"));
1689                 }
1690                 if ( !str.IsEmpty() )
1691                 {
1692                         str += "\\bin";
1693                         msysdir=str;
1694                         CGit::ms_LastMsysGitDir = str;
1695                         msysdir.write();
1696                 }
1697                 else
1698                 {
1699                         // search PATH if git/bin directory is already present
1700                         if ( FindGitPath() )
1701                         {
1702                                 m_bInitialized = TRUE;
1703                                 msysdir = CGit::ms_LastMsysGitDir;
1704                                 msysdir.write();
1705                                 return TRUE;
1706                         }
1707
1708                         return FALSE;
1709                 }
1710         }
1711         else
1712         {
1713                 CGit::ms_LastMsysGitDir = str;
1714         }
1715
1716         // check for git.exe existance (maybe it was deinstalled in the meantime)
1717         if (!FileExists(CGit::ms_LastMsysGitDir + _T("\\git.exe")))
1718                 return FALSE;
1719
1720         //set path
1721         _tdupenv_s(&oldpath,&size,_T("PATH"));
1722
1723         CString path;
1724         path.Format(_T("%s;%s"),oldpath,str + _T(";")+ (CString)CRegString(REG_MSYSGIT_EXTRA_PATH,_T(""),FALSE));
1725
1726         m_Environment.SetEnv(_T("PATH"),path.GetBuffer());
1727
1728         CString str1 = m_Environment.GetEnv(_T("PATH"));
1729
1730         CString sOldPath = oldpath;
1731         free(oldpath);
1732
1733         m_bInitialized = TRUE;
1734         return true;
1735 }
1736
1737 CString CGit::GetHomeDirectory()
1738 {
1739         const wchar_t * homeDir = wget_windows_home_directory();
1740         return CString(homeDir, (int)wcslen(homeDir));
1741 }
1742
1743 CString CGit::GetGitLocalConfig()
1744 {
1745         CString path;
1746         g_GitAdminDir.GetAdminDirPath(g_Git.m_CurrentDir, path);
1747         path += _T("config");
1748         return path;
1749 }
1750
1751 CString CGit::GetGitGlobalConfig()
1752 {
1753         return g_Git.GetHomeDirectory() + _T("\\.gitconfig");
1754 }
1755
1756 CString CGit::GetGitGlobalXDGConfigPath()
1757 {
1758         return g_Git.GetHomeDirectory() + _T("\\.config\\git");
1759 }
1760
1761 CString CGit::GetGitGlobalXDGConfig()
1762 {
1763         return g_Git.GetGitGlobalXDGConfigPath() + _T("\\config");
1764 }
1765
1766 CString CGit::GetGitSystemConfig()
1767 {
1768         const wchar_t * systemConfig = wget_msysgit_etc();
1769         return CString(systemConfig, (int)wcslen(systemConfig));
1770 }
1771
1772 BOOL CGit::CheckCleanWorkTree()
1773 {
1774         CString out;
1775         CString cmd;
1776         cmd=_T("git.exe rev-parse --verify HEAD");
1777
1778         if(Run(cmd,&out,CP_UTF8))
1779                 return FALSE;
1780
1781         cmd=_T("git.exe update-index --ignore-submodules --refresh");
1782         if(Run(cmd,&out,CP_UTF8))
1783                 return FALSE;
1784
1785         cmd=_T("git.exe diff-files --quiet --ignore-submodules");
1786         if(Run(cmd,&out,CP_UTF8))
1787                 return FALSE;
1788
1789         cmd=_T("git diff-index --cached --quiet HEAD --ignore-submodules");
1790         if(Run(cmd,&out,CP_UTF8))
1791                 return FALSE;
1792
1793         return TRUE;
1794 }
1795 int CGit::Revert(CString commit, CTGitPathList &list, bool)
1796 {
1797         int ret;
1798         for (int i = 0; i < list.GetCount(); ++i)
1799         {
1800                 ret = Revert(commit, (CTGitPath&)list[i]);
1801                 if(ret)
1802                         return ret;
1803         }
1804         return 0;
1805 }
1806 int CGit::Revert(CString commit, CTGitPath &path)
1807 {
1808         CString cmd, out;
1809
1810         if(path.m_Action & CTGitPath::LOGACTIONS_REPLACED && !path.GetGitOldPathString().IsEmpty())
1811         {
1812                 if (CTGitPath(path.GetGitOldPathString()).IsDirectory())
1813                 {
1814                         CString err;
1815                         err.Format(_T("Cannot revert renaming of \"%s\". A directory with the old name \"%s\" exists."), path.GetGitPathString(), path.GetGitOldPathString());
1816                         ::MessageBox(NULL, err, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
1817                         return -1;
1818                 }
1819                 CString force;
1820                 // if the filenames only differ in case, we have to pass "-f"
1821                 if (path.GetGitPathString().CompareNoCase(path.GetGitOldPathString()) == 0)
1822                         force = _T("-f ");
1823                 cmd.Format(_T("git.exe mv %s-- \"%s\" \"%s\""), force, path.GetGitPathString(), path.GetGitOldPathString());
1824                 if (Run(cmd, &out, CP_UTF8))
1825                 {
1826                         ::MessageBox(NULL, out, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
1827                         return -1;
1828                 }
1829
1830                 cmd.Format(_T("git.exe checkout %s -f -- \"%s\""), commit, path.GetGitOldPathString());
1831                 if (Run(cmd, &out, CP_UTF8))
1832                 {
1833                         ::MessageBox(NULL, out, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
1834                         return -1;
1835                 }
1836
1837         }
1838         else if(path.m_Action & CTGitPath::LOGACTIONS_ADDED)
1839         {       //To init git repository, there are not HEAD, so we can use git reset command
1840                 cmd.Format(_T("git.exe rm -f --cached -- \"%s\""),path.GetGitPathString());
1841
1842                 if (Run(cmd, &out, CP_UTF8))
1843                 {
1844                         ::MessageBox(NULL, out, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
1845                         return -1;
1846                 }
1847         }
1848         else
1849         {
1850                 cmd.Format(_T("git.exe checkout %s -f -- \"%s\""), commit, path.GetGitPathString());
1851                 if (Run(cmd, &out, CP_UTF8))
1852                 {
1853                         ::MessageBox(NULL, out, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
1854                         return -1;
1855                 }
1856         }
1857
1858         if (path.m_Action & CTGitPath::LOGACTIONS_DELETED)
1859         {
1860                 cmd.Format(_T("git.exe add -f -- \"%s\""), path.GetGitPathString());
1861                 if (Run(cmd, &out, CP_UTF8))
1862                 {
1863                         ::MessageBox(NULL, out, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
1864                         return -1;
1865                 }
1866         }
1867
1868         return 0;
1869 }
1870
1871 int CGit::ListConflictFile(CTGitPathList &list,CTGitPath *path)
1872 {
1873         BYTE_VECTOR vector;
1874
1875         CString cmd;
1876         if(path)
1877                 cmd.Format(_T("git.exe ls-files -u -t -z -- \"%s\""),path->GetGitPathString());
1878         else
1879                 cmd=_T("git.exe ls-files -u -t -z");
1880
1881         if (Run(cmd, &vector))
1882         {
1883                 return -1;
1884         }
1885
1886         list.ParserFromLsFile(vector);
1887
1888         return 0;
1889 }
1890
1891 bool CGit::IsFastForward(const CString &from, const CString &to, CGitHash * commonAncestor)
1892 {
1893         CString base;
1894         CGitHash basehash,hash;
1895         CString cmd, err;
1896         cmd.Format(_T("git.exe merge-base %s %s"), FixBranchName(to), FixBranchName(from));
1897
1898         if (Run(cmd, &base, &err, CP_UTF8))
1899         {
1900                 return false;
1901         }
1902         basehash = base.Trim();
1903
1904         GetHash(hash, from);
1905
1906         if (commonAncestor)
1907                 *commonAncestor = basehash;
1908
1909         return hash == basehash;
1910 }
1911
1912 unsigned int CGit::Hash2int(CGitHash &hash)
1913 {
1914         int ret=0;
1915         for (int i = 0; i < 4; ++i)
1916         {
1917                 ret = ret << 8;
1918                 ret |= hash.m_hash[i];
1919         }
1920         return ret;
1921 }
1922
1923 int CGit::RefreshGitIndex()
1924 {
1925         if(g_Git.m_IsUseGitDLL)
1926         {
1927                 CAutoLocker lock(g_Git.m_critGitDllSec);
1928                 try
1929                 {
1930                         return git_run_cmd("update-index","update-index -q --refresh");
1931
1932                 }catch(...)
1933                 {
1934                         return -1;
1935                 }
1936
1937         }
1938         else
1939         {
1940                 CString cmd,output;
1941                 cmd=_T("git.exe update-index --refresh");
1942                 return Run(cmd, &output, CP_UTF8);
1943         }
1944 }
1945
1946 int CGit::GetOneFile(CString Refname, CTGitPath &path, const CString &outputfile)
1947 {
1948         if(g_Git.m_IsUseGitDLL)
1949         {
1950                 CAutoLocker lock(g_Git.m_critGitDllSec);
1951                 try
1952                 {
1953                         g_Git.CheckAndInitDll();
1954                         CStringA ref, patha, outa;
1955                         ref = CUnicodeUtils::GetMulti(Refname, CP_UTF8);
1956                         patha = CUnicodeUtils::GetMulti(path.GetGitPathString(), CP_UTF8);
1957                         outa = CUnicodeUtils::GetMulti(outputfile, CP_UTF8);
1958                         ::DeleteFile(outputfile);
1959                         return git_checkout_file((const char*)ref.GetBuffer(),(const char*)patha.GetBuffer(),(const char*)outa.GetBuffer());
1960
1961                 }catch(...)
1962                 {
1963                         return -1;
1964                 }
1965         }
1966         else
1967         {
1968                 CString cmd;
1969                 cmd.Format(_T("git.exe cat-file -p %s:\"%s\""), Refname, path.GetGitPathString());
1970                 return RunLogFile(cmd,outputfile);
1971         }
1972 }
1973 void CEnvironment::CopyProcessEnvironment()
1974 {
1975         TCHAR *p = GetEnvironmentStrings();
1976         while(*p !=0 || *(p+1) !=0)
1977                 this->push_back(*p++);
1978
1979         push_back(_T('\0'));
1980         push_back(_T('\0'));
1981 }
1982
1983 CString CEnvironment::GetEnv(TCHAR *name)
1984 {
1985         CString str;
1986         for (size_t i = 0; i < size(); ++i)
1987         {
1988                 str = &(*this)[i];
1989                 int start =0;
1990                 CString sname = str.Tokenize(_T("="),start);
1991                 if(sname.CompareNoCase(name) == 0)
1992                 {
1993                         return &(*this)[i+start];
1994                 }
1995                 i+=str.GetLength();
1996         }
1997         return _T("");
1998 }
1999
2000 void CEnvironment::SetEnv(TCHAR *name, TCHAR* value)
2001 {
2002         unsigned int i;
2003         for (i = 0; i < size(); ++i)
2004         {
2005                 CString str = &(*this)[i];
2006                 int start =0;
2007                 CString sname = str.Tokenize(_T("="),start);
2008                 if(sname.CompareNoCase(name) == 0)
2009                 {
2010                         break;
2011                 }
2012                 i+=str.GetLength();
2013         }
2014
2015         if(i == size())
2016         {
2017                 i -= 1; // roll back terminate \0\0
2018                 this->push_back(_T('\0'));
2019         }
2020
2021         CEnvironment::iterator it;
2022         it=this->begin();
2023         it += i;
2024
2025         while(*it && i<size())
2026         {
2027                 this->erase(it);
2028                 it=this->begin();
2029                 it += i;
2030         }
2031
2032         while(*name)
2033         {
2034                 this->insert(it,*name++);
2035                 ++i;
2036                 it= begin()+i;
2037         }
2038
2039         this->insert(it, _T('='));
2040         ++i;
2041         it= begin()+i;
2042
2043         while(*value)
2044         {
2045                 this->insert(it,*value++);
2046                 ++i;
2047                 it= begin()+i;
2048         }
2049
2050 }
2051
2052 int CGit::GetGitEncode(TCHAR* configkey)
2053 {
2054         CString str=GetConfigValue(configkey);
2055
2056         if(str.IsEmpty())
2057                 return CP_UTF8;
2058
2059         return CUnicodeUtils::GetCPCode(str);
2060 }
2061
2062
2063 int CGit::GetDiffPath(CTGitPathList *PathList, CGitHash *hash1, CGitHash *hash2, char *arg)
2064 {
2065         GIT_FILE file=0;
2066         int ret=0;
2067         GIT_DIFF diff=0;
2068
2069         CAutoLocker lock(g_Git.m_critGitDllSec);
2070
2071         if(arg == NULL)
2072                 diff = GetGitDiff();
2073         else
2074                 git_open_diff(&diff, arg);
2075
2076         if(diff ==NULL)
2077                 return -1;
2078
2079         bool isStat = 0;
2080         if(arg == NULL)
2081                 isStat = true;
2082         else
2083                 isStat = !!strstr(arg, "stat");
2084
2085         int count=0;
2086
2087         if(hash2 == NULL)
2088                 ret = git_root_diff(diff, hash1->m_hash, &file, &count,isStat);
2089         else
2090                 ret = git_diff(diff,hash2->m_hash,hash1->m_hash,&file,&count,isStat);
2091
2092         if(ret)
2093                 return -1;
2094
2095         CTGitPath path;
2096         CString strnewname;
2097         CString stroldname;
2098
2099         for (int j = 0; j < count; ++j)
2100         {
2101                 path.Reset();
2102                 char *newname;
2103                 char *oldname;
2104
2105                 strnewname.Empty();
2106                 stroldname.Empty();
2107
2108                 int mode=0,IsBin=0,inc=0,dec=0;
2109                 git_get_diff_file(diff,file,j,&newname,&oldname,
2110                                         &mode,&IsBin,&inc,&dec);
2111
2112                 StringAppend(&strnewname, (BYTE*)newname, CP_UTF8);
2113                 StringAppend(&stroldname, (BYTE*)oldname, CP_UTF8);
2114
2115                 path.SetFromGit(strnewname,&stroldname);
2116                 path.ParserAction((BYTE)mode);
2117
2118                 if(IsBin)
2119                 {
2120                         path.m_StatAdd=_T("-");
2121                         path.m_StatDel=_T("-");
2122                 }
2123                 else
2124                 {
2125                         path.m_StatAdd.Format(_T("%d"),inc);
2126                         path.m_StatDel.Format(_T("%d"),dec);
2127                 }
2128                 PathList->AddPath(path);
2129         }
2130         git_diff_flush(diff);
2131
2132         if(arg)
2133                 git_close_diff(diff);
2134
2135         return 0;
2136 }
2137
2138 int CGit::GetShortHASHLength()
2139 {
2140         return 7;
2141 }
2142
2143 CString CGit::GetShortName(CString ref, REF_TYPE *out_type)
2144 {
2145         CString str=ref;
2146         CString shortname;
2147         REF_TYPE type = CGit::UNKNOWN;
2148
2149         if (CGit::GetShortName(str, shortname, _T("refs/heads/")))
2150         {
2151                 type = CGit::LOCAL_BRANCH;
2152
2153         }
2154         else if (CGit::GetShortName(str, shortname, _T("refs/remotes/")))
2155         {
2156                 type = CGit::REMOTE_BRANCH;
2157         }
2158         else if (CGit::GetShortName(str, shortname, _T("refs/tags/")))
2159         {
2160                 type = CGit::TAG;
2161         }
2162         else if (CGit::GetShortName(str, shortname, _T("refs/stash")))
2163         {
2164                 type = CGit::STASH;
2165                 shortname=_T("stash");
2166         }
2167         else if (CGit::GetShortName(str, shortname, _T("refs/bisect/")))
2168         {
2169                 if (shortname.Find(_T("good")) == 0)
2170                 {
2171                         type = CGit::BISECT_GOOD;
2172                         shortname = _T("good");
2173                 }
2174
2175                 if (shortname.Find(_T("bad")) == 0)
2176                 {
2177                         type = CGit::BISECT_BAD;
2178                         shortname = _T("bad");
2179                 }
2180         }
2181         else if (CGit::GetShortName(str, shortname, _T("refs/notes/")))
2182         {
2183                 type = CGit::NOTES;
2184         }
2185         else
2186         {
2187                 type = CGit::UNKNOWN;
2188                 shortname = _T("Unknown");
2189         }
2190
2191         if(out_type)
2192                 *out_type = type;
2193
2194         return shortname;
2195 }
2196
2197 bool CGit::UsingLibGit2(int cmd)
2198 {
2199         if (cmd >= 0 && cmd < 32)
2200                 return ((1 << cmd) & m_IsUseLibGit2_mask) ? true : false;
2201         return false;
2202 }