src/Git/Git.cpp

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