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(++pfin, _T("\\"));
 115
 116                 const size_t len = _tcslen(buf);
 117
 118                 if ((len + 7) < _MAX_PATH)
 119                         _tcscpy(pfin+1, _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                 return CGitHash(CString(friendname));
1011
1012         if(this->m_IsUseGitDLL)
1013         {
1014                 CAutoLocker lock(g_Git.m_critGitDllSec);
1015
1016                 this->CheckAndInitDll();
1017
1018                 CGitHash hash;
1019                 CStringA ref;
1020                 ref = CUnicodeUtils::GetMulti(FixBranchName(friendname), CP_UTF8);
1021                 try
1022                 {
1023                         git_get_sha1(ref, hash.m_hash);
1024
1025                 }catch(...)
1026                 {
1027                 }
1028                 return hash;
1029
1030         }
1031         else
1032         {
1033                 CString cmd;
1034                 CString out;
1035                 cmd.Format(_T("git.exe rev-parse %s" ),FixBranchName(friendname));
1036                 Run(cmd, &out, NULL, CP_UTF8);
1037         //      int pos=out.ReverseFind(_T('\n'));
1038                 out.FindOneOf(_T("\r\n"));
1039                 return CGitHash(out);
1040         }
1041 }
1042
1043 int CGit::GetInitAddList(CTGitPathList &outputlist)
1044 {
1045         CString cmd;
1046         BYTE_VECTOR cmdout;
1047
1048         cmd=_T("git.exe ls-files -s -t -z");
1049         outputlist.Clear();
1050         if (g_Git.Run(cmd, &cmdout))
1051                 return -1;
1052
1053         outputlist.ParserFromLsFile(cmdout);
1054         for(int i=0;i<outputlist.GetCount();i++)
1055                 ((unsigned int)outputlist[i].m_Action) = CTGitPath::LOGACTIONS_ADDED;
1056
1057         return 0;
1058 }
1059 int CGit::GetCommitDiffList(const CString &rev1,const CString &rev2,CTGitPathList &outputlist)
1060 {
1061         CString cmd;
1062
1063         if(rev1 == GIT_REV_ZERO || rev2 == GIT_REV_ZERO)
1064         {
1065                 //rev1=+_T("");
1066                 if(rev1 == GIT_REV_ZERO)
1067                         cmd.Format(_T("git.exe diff -r --raw -C -M --numstat -z %s"),rev2);
1068                 else
1069                         cmd.Format(_T("git.exe diff -r -R --raw -C -M --numstat -z %s"),rev1);
1070         }
1071         else
1072         {
1073                 cmd.Format(_T("git.exe diff-tree -r --raw -C -M --numstat -z %s %s"),rev2,rev1);
1074         }
1075
1076         BYTE_VECTOR out;
1077         if (g_Git.Run(cmd, &out))
1078                 return -1;
1079
1080         outputlist.ParserFromLog(out);
1081
1082         return 0;
1083 }
1084
1085 int addto_list_each_ref_fn(const char *refname, const unsigned char * /*sha1*/, int /*flags*/, void *cb_data)
1086 {
1087         STRING_VECTOR *list = (STRING_VECTOR*)cb_data;
1088         CString str;
1089         g_Git.StringAppend(&str, (BYTE*)refname, CP_UTF8);
1090         list->push_back(str);
1091         return 0;
1092 }
1093
1094 int CGit::GetTagList(STRING_VECTOR &list)
1095 {
1096         if (this->m_IsUseLibGit2)
1097         {
1098                 git_repository *repo = NULL;
1099
1100                 CStringA gitdir = CUnicodeUtils::GetMulti(CTGitPath(g_Git.m_CurrentDir).GetGitPathString(), CP_UTF8);
1101                 if (git_repository_open(&repo, gitdir.GetBuffer()))
1102                 {
1103                         gitdir.ReleaseBuffer();
1104                         return -1;
1105                 }
1106                 gitdir.ReleaseBuffer();
1107
1108                 git_strarray tag_names;
1109
1110                 if (git_tag_list(&tag_names, repo))
1111                 {
1112                         git_repository_free(repo);
1113                         return -1;
1114                 }
1115
1116                 for (size_t i = 0; i < tag_names.count; i++)
1117                 {
1118                         CStringA tagName(tag_names.strings[i]);
1119                         list.push_back(CUnicodeUtils::GetUnicode(tagName).Mid(10)); // strip "refs/tags/"
1120                 }
1121
1122                 git_strarray_free(&tag_names);
1123
1124                 git_repository_free(repo);
1125
1126                 std::sort(list.begin(), list.end(), LogicalComparePredicate);
1127
1128                 return 0;
1129         }
1130         else
1131         {
1132                 CString cmd, output;
1133                 cmd=_T("git.exe tag -l");
1134                 int i=0;
1135                 int ret = g_Git.Run(cmd, &output, NULL, CP_UTF8);
1136                 if(!ret)
1137                 {
1138                         int pos=0;
1139                         CString one;
1140                         while( pos>=0 )
1141                         {
1142                                 i++;
1143                                 one=output.Tokenize(_T("\n"),pos);
1144                                 list.push_back(one);
1145                         }
1146                         std::sort(list.begin(), list.end(), LogicalComparePredicate);
1147                 }
1148                 return ret;
1149         }
1150 }
1151
1152 CString CGit::FixBranchName_Mod(CString& branchName)
1153 {
1154         if(branchName == "FETCH_HEAD")
1155                 branchName = DerefFetchHead();
1156         return branchName;
1157 }
1158
1159 CString CGit::FixBranchName(const CString& branchName)
1160 {
1161         CString tempBranchName = branchName;
1162         FixBranchName_Mod(tempBranchName);
1163         return tempBranchName;
1164 }
1165
1166 bool CGit::IsBranchTagNameUnique(const CString& name)
1167 {
1168         CString output;
1169
1170         int ret = g_Git.Run(_T("git show-ref --tags --heads ") + name, &output, NULL, CP_UTF8);
1171         if (!ret)
1172         {
1173                 int i = 0, pos = 0;
1174                 while (pos >= 0)
1175                 {
1176                         if (!output.Tokenize(_T("\n"), pos).IsEmpty())
1177                                 i++;
1178                 }
1179                 if (i >= 2)
1180                         return false;
1181         }
1182
1183         return true;
1184 }
1185
1186 /*
1187 Checks if a branch or tag with the given name exists
1188 isBranch is true -> branch, tag otherwise
1189 */
1190 bool CGit::BranchTagExists(const CString& name, bool isBranch /*= true*/)
1191 {
1192         CString cmd, output;
1193
1194         cmd = _T("git show-ref ");
1195         if (isBranch)
1196                 cmd += _T("--heads ");
1197         else
1198                 cmd += _T("--tags ");
1199
1200         int ret = g_Git.Run(cmd + name, &output, NULL, CP_UTF8);
1201         if (!ret)
1202         {
1203                 if (!output.IsEmpty())
1204                         return true;
1205         }
1206
1207         return false;
1208 }
1209
1210 CString CGit::DerefFetchHead()
1211 {
1212         using namespace std;
1213         CString dotGitPath;
1214         g_GitAdminDir.GetAdminDirPath(m_CurrentDir, dotGitPath);
1215         ifstream fetchHeadFile((dotGitPath + L"FETCH_HEAD").GetString(), ios::in | ios::binary);
1216         int forMergeLineCount = 0;
1217         string line;
1218         string hashToReturn;
1219         while(getline(fetchHeadFile, line))
1220         {
1221                 //Tokenize this line
1222                 string::size_type prevPos = 0;
1223                 string::size_type pos = line.find('\t');
1224                 if(pos == string::npos) continue; //invalid line
1225
1226                 string hash = line.substr(0, pos);
1227                 ++pos; prevPos = pos; pos = line.find('\t', pos); if(pos == string::npos) continue;
1228
1229                 bool forMerge = pos == prevPos;
1230                 ++pos; prevPos = pos; pos = line.size(); if(pos == string::npos) continue;
1231
1232                 string remoteBranch = line.substr(prevPos, pos - prevPos);
1233
1234                 //Process this line
1235                 if(forMerge)
1236                 {
1237                         hashToReturn = hash;
1238                         ++forMergeLineCount;
1239                         if(forMergeLineCount > 1)
1240                                 return L""; //More then 1 branch to merge found. Octopus merge needed. Cannot pick single ref from FETCH_HEAD
1241                 }
1242         }
1243
1244         return CUnicodeUtils::GetUnicode(hashToReturn.c_str());
1245 }
1246
1247 int CGit::GetBranchList(STRING_VECTOR &list,int *current,BRANCH_TYPE type)
1248 {
1249         int ret;
1250         CString cmd, output, cur;
1251         cmd = _T("git.exe branch --no-color");
1252
1253         if((type&BRANCH_ALL) == BRANCH_ALL)
1254                 cmd += _T(" -a");
1255         else if(type&BRANCH_REMOTE)
1256                 cmd += _T(" -r");
1257
1258         ret = g_Git.Run(cmd, &output, NULL, CP_UTF8);
1259         if(!ret)
1260         {
1261                 int pos=0;
1262                 CString one;
1263                 while( pos>=0 )
1264                 {
1265                         one=output.Tokenize(_T("\n"),pos);
1266                         one.Trim(L" \r\n\t");
1267                         if(one.Find(L" -> ") >= 0 || one.IsEmpty())
1268                                 continue; // skip something like: refs/origin/HEAD -> refs/origin/master
1269                         if(one[0] == _T('*'))
1270                         {
1271                                 one = one.Mid(2);
1272                                 cur = one;
1273                         }
1274                         if (one != _T("(no branch)"))
1275                                 list.push_back(one);
1276                 }
1277         }
1278
1279         if(type & BRANCH_FETCH_HEAD && !DerefFetchHead().IsEmpty())
1280                 list.push_back(L"FETCH_HEAD");
1281
1282         std::sort(list.begin(), list.end(), LogicalComparePredicate);
1283
1284         if (current && cur != _T("(no branch)"))
1285         {
1286                 for (unsigned int i = 0; i < list.size(); i++)
1287                 {
1288                         if (list[i] == cur)
1289                         {
1290                                 *current = i;
1291                                 break;
1292                         }
1293                 }
1294         }
1295
1296         return ret;
1297 }
1298
1299 int CGit::GetRemoteList(STRING_VECTOR &list)
1300 {
1301         if (this->m_IsUseLibGit2)
1302         {
1303                 git_repository *repo = NULL;
1304
1305                 CStringA gitdir = CUnicodeUtils::GetMulti(CTGitPath(g_Git.m_CurrentDir).GetGitPathString(), CP_UTF8);
1306                 if (git_repository_open(&repo, gitdir.GetBuffer()))
1307                 {
1308                         gitdir.ReleaseBuffer();
1309                         return -1;
1310                 }
1311                 gitdir.ReleaseBuffer();
1312
1313                 git_strarray remotes;
1314
1315                 if (git_remote_list(&remotes, repo))
1316                 {
1317                         git_repository_free(repo);
1318                         return -1;
1319                 }
1320
1321                 for (size_t i = 0; i < remotes.count; i++)
1322                 {
1323                         CStringA remote(remotes.strings[i]);
1324                         list.push_back(CUnicodeUtils::GetUnicode(remote));
1325                 }
1326
1327                 git_strarray_free(&remotes);
1328
1329                 git_repository_free(repo);
1330
1331                 std::sort(list.begin(), list.end());
1332
1333                 return 0;
1334         }
1335         else
1336         {
1337                 int ret;
1338                 CString cmd, output;
1339                 cmd=_T("git.exe remote");
1340                 ret = g_Git.Run(cmd, &output, NULL, CP_UTF8);
1341                 if(!ret)
1342                 {
1343                         int pos=0;
1344                         CString one;
1345                         while( pos>=0 )
1346                         {
1347                                 one=output.Tokenize(_T("\n"),pos);
1348                                 if (!one.IsEmpty())
1349                                         list.push_back(one);
1350                         }
1351                 }
1352                 return ret;
1353         }
1354 }
1355
1356 int CGit::GetRemoteTags(CString remote, STRING_VECTOR &list)
1357 {
1358         CString cmd, out, err;
1359         cmd.Format(_T("git.exe ls-remote -t \"%s\""), remote);
1360         if (g_Git.Run(cmd, &out, &err, CP_UTF8))
1361         {
1362                 MessageBox(NULL, err, _T("TortoiseGit"), MB_ICONERROR);
1363                 return -1;
1364         }
1365
1366         int pos = 0;
1367         while (pos >= 0)
1368         {
1369                 CString one = out.Tokenize(_T("\n"), pos).Mid(51).Trim(); // sha1, tab + refs/tags/
1370                 if (one.Find(_T("^{}")) >= 1)
1371                         one = one.Left(one.GetLength() - 3);
1372                 list.push_back(one);
1373         }
1374         std::sort(list.begin(), list.end(), LogicalComparePredicate);
1375         return 0;
1376 }
1377
1378 int CGit::GetRefList(STRING_VECTOR &list)
1379 {
1380         int ret;
1381         if(this->m_IsUseGitDLL)
1382         {
1383                 CAutoLocker lock(g_Git.m_critGitDllSec);
1384                 ret = git_for_each_ref_in("",addto_list_each_ref_fn, &list);
1385                 std::sort(list.begin(), list.end(), LogicalComparePredicate);
1386         }
1387         else
1388         {
1389                 CString cmd, output;
1390                 cmd=_T("git.exe show-ref -d");
1391                 ret = g_Git.Run(cmd, &output, NULL, CP_UTF8);
1392                 if(!ret)
1393                 {
1394                         int pos=0;
1395                         CString one;
1396                         while( pos>=0 )
1397                         {
1398                                 one=output.Tokenize(_T("\n"),pos);
1399                                 int start=one.Find(_T(" "),0);
1400                                 if(start>0)
1401                                 {
1402                                         CString name;
1403                                         name=one.Right(one.GetLength()-start-1);
1404                                         list.push_back(name);
1405                                 }
1406                         }
1407                 }
1408         }
1409         return ret;
1410 }
1411
1412 int addto_map_each_ref_fn(const char *refname, const unsigned char *sha1, int /*flags*/, void *cb_data)
1413 {
1414         MAP_HASH_NAME *map = (MAP_HASH_NAME*)cb_data;
1415         CString str;
1416         g_Git.StringAppend(&str, (BYTE*)refname, CP_UTF8);
1417         CGitHash hash((char*)sha1);
1418
1419         (*map)[hash].push_back(str);
1420
1421         if(strncmp(refname, "refs/tags", 9) == 0)
1422         {
1423                 try
1424                 {
1425                         GIT_HASH refhash;
1426                         if(!git_deref_tag(sha1, refhash))
1427                         {
1428                                 (*map)[(char*)refhash].push_back(str+_T("^{}"));
1429                         }
1430                 }
1431                 catch (char* msg)
1432                 {
1433                         CString err(msg);
1434                         ::MessageBox(NULL, _T("Could not get (readable) reference for hash ") + hash.ToString() + _T(".\nlibgit reports:\n") + err, _T("TortoiseGit"), MB_ICONERROR);
1435                 }
1436         }
1437         return 0;
1438 }
1439
1440 int CGit::GetMapHashToFriendName(MAP_HASH_NAME &map)
1441 {
1442         int ret;
1443         if(this->m_IsUseGitDLL)
1444         {
1445                 CAutoLocker lock(g_Git.m_critGitDllSec);
1446                 return git_for_each_ref_in("",addto_map_each_ref_fn, &map);
1447
1448         }
1449         else
1450         {
1451                 CString cmd, output;
1452                 cmd=_T("git.exe show-ref -d");
1453                 ret = g_Git.Run(cmd, &output, NULL, CP_UTF8);
1454                 if(!ret)
1455                 {
1456                         int pos=0;
1457                         CString one;
1458                         while( pos>=0 )
1459                         {
1460                                 one=output.Tokenize(_T("\n"),pos);
1461                                 int start=one.Find(_T(" "),0);
1462                                 if(start>0)
1463                                 {
1464                                         CString name;
1465                                         name=one.Right(one.GetLength()-start-1);
1466
1467                                         CString hash;
1468                                         hash=one.Left(start);
1469
1470                                         map[CGitHash(hash)].push_back(name);
1471                                 }
1472                         }
1473                 }
1474         }
1475         return ret;
1476 }
1477
1478 BOOL CGit::CheckMsysGitDir()
1479 {
1480         if (m_bInitialized)
1481         {
1482                 return TRUE;
1483         }
1484
1485         this->m_Environment.clear();
1486         m_Environment.CopyProcessEnvironment();
1487
1488         TCHAR *oldpath;
1489         size_t homesize,size;
1490
1491         // set HOME if not set already
1492         _tgetenv_s(&homesize, NULL, 0, _T("HOME"));
1493         if (!homesize)
1494         {
1495                 CString home = g_Git.GetHomeDirectory();
1496                 m_Environment.SetEnv(_T("HOME"), home.GetBuffer());
1497                 home.ReleaseBuffer();
1498         }
1499         CString str;
1500
1501         //setup ssh client
1502         CString sshclient=CRegString(_T("Software\\TortoiseGit\\SSH"));
1503
1504         if(!sshclient.IsEmpty())
1505         {
1506                 m_Environment.SetEnv(_T("GIT_SSH"), sshclient.GetBuffer());
1507                 m_Environment.SetEnv(_T("SVN_SSH"), sshclient.GetBuffer());
1508         }
1509         else
1510         {
1511                 TCHAR sPlink[MAX_PATH];
1512                 GetModuleFileName(NULL, sPlink, _countof(sPlink));
1513                 LPTSTR ptr = _tcsrchr(sPlink, _T('\\'));
1514                 if (ptr) {
1515                         _tcscpy(ptr + 1, _T("TortoisePlink.exe"));
1516                         m_Environment.SetEnv(_T("GIT_SSH"), sPlink);
1517                         m_Environment.SetEnv(_T("SVN_SSH"), sPlink);
1518                 }
1519         }
1520
1521         {
1522                 TCHAR sAskPass[MAX_PATH];
1523                 GetModuleFileName(NULL, sAskPass, _countof(sAskPass));
1524                 LPTSTR ptr = _tcsrchr(sAskPass, _T('\\'));
1525                 if (ptr)
1526                 {
1527                         _tcscpy(ptr + 1, _T("SshAskPass.exe"));
1528                         m_Environment.SetEnv(_T("DISPLAY"),_T(":9999"));
1529                         m_Environment.SetEnv(_T("SSH_ASKPASS"),sAskPass);
1530                         m_Environment.SetEnv(_T("GIT_ASKPASS"),sAskPass);
1531                 }
1532         }
1533
1534         // add git/bin path to PATH
1535
1536         CRegString msysdir=CRegString(REG_MSYSGIT_PATH,_T(""),FALSE);
1537         str=msysdir;
1538         if(str.IsEmpty() || !FileExists(str + _T("\\git.exe")))
1539         {
1540                 CRegString msysinstalldir=CRegString(REG_MSYSGIT_INSTALL,_T(""),FALSE,HKEY_LOCAL_MACHINE);
1541                 str=msysinstalldir;
1542                 if ( !str.IsEmpty() )
1543                 {
1544                         str += (str[str.GetLength()-1] != '\\') ? "\\bin" : "bin";
1545                         msysdir=str;
1546                         CGit::ms_LastMsysGitDir = str;
1547                         msysdir.write();
1548                 }
1549                 else
1550                 {
1551                         // search PATH if git/bin directory is already present
1552                         if ( FindGitPath() )
1553                         {
1554                                 m_bInitialized = TRUE;
1555                                 msysdir = CGit::ms_LastMsysGitDir;
1556                                 msysdir.write();
1557                                 return TRUE;
1558                         }
1559
1560                         return FALSE;
1561                 }
1562         }
1563         else
1564         {
1565                 CGit::ms_LastMsysGitDir = str;
1566         }
1567
1568         // check for git.exe existance (maybe it was deinstalled in the meantime)
1569         if (!FileExists(CGit::ms_LastMsysGitDir + _T("\\git.exe")))
1570                 return FALSE;
1571
1572         //set path
1573         _tdupenv_s(&oldpath,&size,_T("PATH"));
1574
1575         CString path;
1576         path.Format(_T("%s;%s"),oldpath,str + _T(";")+ (CString)CRegString(REG_MSYSGIT_EXTRA_PATH,_T(""),FALSE));
1577
1578         m_Environment.SetEnv(_T("PATH"),path.GetBuffer());
1579
1580         CString str1 = m_Environment.GetEnv(_T("PATH"));
1581
1582         CString sOldPath = oldpath;
1583         free(oldpath);
1584
1585         m_bInitialized = TRUE;
1586         return true;
1587 }
1588
1589 CString CGit::GetHomeDirectory()
1590 {
1591         const wchar_t * homeDir = wget_windows_home_directory();
1592         return CString(homeDir, (int)wcslen(homeDir));
1593 }
1594
1595 CString CGit::GetGitSystemConfig()
1596 {
1597         const wchar_t * systemConfig = wget_msysgit_etc();
1598         return CString(systemConfig, (int)wcslen(systemConfig));
1599 }
1600
1601 BOOL CGit::CheckCleanWorkTree()
1602 {
1603         CString out;
1604         CString cmd;
1605         cmd=_T("git.exe rev-parse --verify HEAD");
1606
1607         if(g_Git.Run(cmd,&out,CP_UTF8))
1608                 return FALSE;
1609
1610         cmd=_T("git.exe update-index --ignore-submodules --refresh");
1611         if(g_Git.Run(cmd,&out,CP_UTF8))
1612                 return FALSE;
1613
1614         cmd=_T("git.exe diff-files --quiet --ignore-submodules");
1615         if(g_Git.Run(cmd,&out,CP_UTF8))
1616                 return FALSE;
1617
1618         cmd=_T("git diff-index --cached --quiet HEAD --ignore-submodules");
1619         if(g_Git.Run(cmd,&out,CP_UTF8))
1620                 return FALSE;
1621
1622         return TRUE;
1623 }
1624 int CGit::Revert(CString commit, CTGitPathList &list, bool)
1625 {
1626         int ret;
1627         for(int i=0;i<list.GetCount();i++)
1628         {
1629                 ret = Revert(commit, (CTGitPath&)list[i]);
1630                 if(ret)
1631                         return ret;
1632         }
1633         return 0;
1634 }
1635 int CGit::Revert(CString commit, CTGitPath &path)
1636 {
1637         CString cmd, out;
1638
1639         if(path.m_Action & CTGitPath::LOGACTIONS_REPLACED && !path.GetGitOldPathString().IsEmpty())
1640         {
1641                 if (CTGitPath(path.GetGitOldPathString()).IsDirectory())
1642                 {
1643                         CString err;
1644                         err.Format(_T("Cannot revert renaming of \"%s\". A directory with the old name \"%s\" exists."), path.GetGitPathString(), path.GetGitOldPathString());
1645                         ::MessageBox(NULL, err, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
1646                         return -1;
1647                 }
1648                 CString force;
1649                 // if the filenames only differ in case, we have to pass "-f"
1650                 if (path.GetGitPathString().CompareNoCase(path.GetGitOldPathString()) == 0)
1651                         force = _T("-f ");
1652                 cmd.Format(_T("git.exe mv %s-- \"%s\" \"%s\""), force, path.GetGitPathString(), path.GetGitOldPathString());
1653                 if (g_Git.Run(cmd, &out, CP_UTF8))
1654                 {
1655                         ::MessageBox(NULL, out, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
1656                         return -1;
1657                 }
1658
1659                 cmd.Format(_T("git.exe checkout %s -f -- \"%s\""), commit, path.GetGitOldPathString());
1660                 if (g_Git.Run(cmd, &out, CP_UTF8))
1661                 {
1662                         ::MessageBox(NULL, out, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
1663                         return -1;
1664                 }
1665
1666         }
1667         else if(path.m_Action & CTGitPath::LOGACTIONS_ADDED)
1668         {       //To init git repository, there are not HEAD, so we can use git reset command
1669                 cmd.Format(_T("git.exe rm -f --cached -- \"%s\""),path.GetGitPathString());
1670
1671                 if (g_Git.Run(cmd, &out, CP_UTF8))
1672                 {
1673                         ::MessageBox(NULL, out, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
1674                         return -1;
1675                 }
1676         }
1677         else
1678         {
1679                 cmd.Format(_T("git.exe checkout %s -f -- \"%s\""), commit, path.GetGitPathString());
1680                 if (g_Git.Run(cmd, &out, CP_UTF8))
1681                 {
1682                         ::MessageBox(NULL, out, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
1683                         return -1;
1684                 }
1685         }
1686
1687         if (path.m_Action & CTGitPath::LOGACTIONS_DELETED)
1688         {
1689                 cmd.Format(_T("git.exe add -f -- \"%s\""), 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         return 0;
1698 }
1699
1700 int CGit::ListConflictFile(CTGitPathList &list,CTGitPath *path)
1701 {
1702         BYTE_VECTOR vector;
1703
1704         CString cmd;
1705         if(path)
1706                 cmd.Format(_T("git.exe ls-files -u -t -z -- \"%s\""),path->GetGitPathString());
1707         else
1708                 cmd=_T("git.exe ls-files -u -t -z");
1709
1710         if (g_Git.Run(cmd, &vector))
1711         {
1712                 return -1;
1713         }
1714
1715         list.ParserFromLsFile(vector);
1716
1717         return 0;
1718 }
1719
1720 bool CGit::IsFastForward(const CString &from, const CString &to)
1721 {
1722         CString base;
1723         CGitHash basehash,hash;
1724         CString cmd, err;
1725         cmd.Format(_T("git.exe merge-base %s %s"), FixBranchName(to), FixBranchName(from));
1726
1727         if (g_Git.Run(cmd, &base, &err, CP_UTF8))
1728         {
1729                 //CMessageBox::Show(NULL, base + _T("\n") + err, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
1730                 return false;
1731         }
1732         basehash = base;
1733
1734         hash=g_Git.GetHash(from);
1735
1736         return hash == basehash;
1737 }
1738
1739 unsigned int CGit::Hash2int(CGitHash &hash)
1740 {
1741         int ret=0;
1742         for(int i=0;i<4;i++)
1743         {
1744                 ret = ret << 8;
1745                 ret |= hash.m_hash[i];
1746         }
1747         return ret;
1748 }
1749
1750 int CGit::RefreshGitIndex()
1751 {
1752         if(g_Git.m_IsUseGitDLL)
1753         {
1754                 CAutoLocker lock(g_Git.m_critGitDllSec);
1755                 try
1756                 {
1757                         return git_run_cmd("update-index","update-index -q --refresh");
1758
1759                 }catch(...)
1760                 {
1761                         return -1;
1762                 }
1763
1764         }
1765         else
1766         {
1767                 CString cmd,output;
1768                 cmd=_T("git.exe update-index --refresh");
1769                 return Run(cmd, &output, CP_UTF8);
1770         }
1771 }
1772
1773 int CGit::GetOneFile(CString Refname, CTGitPath &path, const CString &outputfile)
1774 {
1775         if(g_Git.m_IsUseGitDLL)
1776         {
1777                 CAutoLocker lock(g_Git.m_critGitDllSec);
1778                 try
1779                 {
1780                         g_Git.CheckAndInitDll();
1781                         CStringA ref, patha, outa;
1782                         ref = CUnicodeUtils::GetMulti(Refname, CP_UTF8);
1783                         patha = CUnicodeUtils::GetMulti(path.GetGitPathString(), CP_UTF8);
1784                         outa = CUnicodeUtils::GetMulti(outputfile, CP_UTF8);
1785                         ::DeleteFile(outputfile);
1786                         return git_checkout_file((const char*)ref.GetBuffer(),(const char*)patha.GetBuffer(),(const char*)outa.GetBuffer());
1787
1788                 }catch(...)
1789                 {
1790                         return -1;
1791                 }
1792         }
1793         else
1794         {
1795                 CString cmd;
1796                 cmd.Format(_T("git.exe cat-file -p %s:\"%s\""), Refname, path.GetGitPathString());
1797                 return g_Git.RunLogFile(cmd,outputfile);
1798         }
1799 }
1800 void CEnvironment::CopyProcessEnvironment()
1801 {
1802         TCHAR *p = GetEnvironmentStrings();
1803         while(*p !=0 || *(p+1) !=0)
1804                 this->push_back(*p++);
1805
1806         push_back(_T('\0'));
1807         push_back(_T('\0'));
1808 }
1809
1810 CString CEnvironment::GetEnv(TCHAR *name)
1811 {
1812         CString str;
1813         for(int i=0;i<size();i++)
1814         {
1815                 str = &(*this)[i];
1816                 int start =0;
1817                 CString sname = str.Tokenize(_T("="),start);
1818                 if(sname.CompareNoCase(name) == 0)
1819                 {
1820                         return &(*this)[i+start];
1821                 }
1822                 i+=str.GetLength();
1823         }
1824         return _T("");
1825 }
1826
1827 void CEnvironment::SetEnv(TCHAR *name, TCHAR* value)
1828 {
1829         unsigned int i;
1830         for( i=0;i<size();i++)
1831         {
1832                 CString str = &(*this)[i];
1833                 int start =0;
1834                 CString sname = str.Tokenize(_T("="),start);
1835                 if(sname.CompareNoCase(name) == 0)
1836                 {
1837                         break;
1838                 }
1839                 i+=str.GetLength();
1840         }
1841
1842         if(i == size())
1843         {
1844                 i -= 1; // roll back terminate \0\0
1845                 this->push_back(_T('\0'));
1846         }
1847
1848         CEnvironment::iterator it;
1849         it=this->begin();
1850         it += i;
1851
1852         while(*it && i<size())
1853         {
1854                 this->erase(it);
1855                 it=this->begin();
1856                 it += i;
1857         }
1858
1859         while(*name)
1860         {
1861                 this->insert(it,*name++);
1862                 i++;
1863                 it= begin()+i;
1864         }
1865
1866         this->insert(it, _T('='));
1867         i++;
1868         it= begin()+i;
1869
1870         while(*value)
1871         {
1872                 this->insert(it,*value++);
1873                 i++;
1874                 it= begin()+i;
1875         }
1876
1877 }
1878
1879 int CGit::GetGitEncode(TCHAR* configkey)
1880 {
1881         CString str=GetConfigValue(configkey);
1882
1883         if(str.IsEmpty())
1884                 return CP_UTF8;
1885
1886         return CUnicodeUtils::GetCPCode(str);
1887 }
1888
1889
1890 int CGit::GetDiffPath(CTGitPathList *PathList, CGitHash *hash1, CGitHash *hash2, char *arg)
1891 {
1892         GIT_FILE file=0;
1893         int ret=0;
1894         GIT_DIFF diff=0;
1895
1896         CAutoLocker lock(g_Git.m_critGitDllSec);
1897
1898         if(arg == NULL)
1899                 diff = GetGitDiff();
1900         else
1901                 git_open_diff(&diff, arg);
1902
1903         if(diff ==NULL)
1904                 return -1;
1905
1906         bool isStat = 0;
1907         if(arg == NULL)
1908                 isStat = true;
1909         else
1910                 isStat = !!strstr(arg, "stat");
1911
1912         int count=0;
1913
1914         if(hash2 == NULL)
1915                 ret = git_root_diff(diff, hash1->m_hash, &file, &count,isStat);
1916         else
1917                 ret = git_diff(diff,hash2->m_hash,hash1->m_hash,&file,&count,isStat);
1918
1919         if(ret)
1920                 return -1;
1921
1922         CTGitPath path;
1923         CString strnewname;
1924         CString stroldname;
1925
1926         for(int j=0;j<count;j++)
1927         {
1928                 path.Reset();
1929                 char *newname;
1930                 char *oldname;
1931
1932                 strnewname.Empty();
1933                 stroldname.Empty();
1934
1935                 int mode=0,IsBin=0,inc=0,dec=0;
1936                 git_get_diff_file(diff,file,j,&newname,&oldname,
1937                                         &mode,&IsBin,&inc,&dec);
1938
1939                 StringAppend(&strnewname, (BYTE*)newname, CP_UTF8);
1940                 StringAppend(&stroldname, (BYTE*)oldname, CP_UTF8);
1941
1942                 path.SetFromGit(strnewname,&stroldname);
1943                 path.ParserAction((BYTE)mode);
1944
1945                 if(IsBin)
1946                 {
1947                         path.m_StatAdd=_T("-");
1948                         path.m_StatDel=_T("-");
1949                 }
1950                 else
1951                 {
1952                         path.m_StatAdd.Format(_T("%d"),inc);
1953                         path.m_StatDel.Format(_T("%d"),dec);
1954                 }
1955                 PathList->AddPath(path);
1956         }
1957         git_diff_flush(diff);
1958
1959         if(arg)
1960                 git_close_diff(diff);
1961
1962         return 0;
1963 }
1964
1965 int CGit::GetShortHASHLength()
1966 {
1967         return 7;
1968 }