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