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                 if (size == 0)
 383                         return false;
 384                 size_t oldsize=m_pvector->size();
 385                 m_pvector->resize(m_pvector->size()+size);
 386                 memcpy(&*(m_pvector->begin()+oldsize),data,size);
 387                 return false;
 388         }
 389         virtual bool OnOutputErrData(const BYTE* data, size_t size)
 390         {
 391                 if (!m_pvectorErr || size == 0)
 392                         return false;
 393                 size_t oldsize = m_pvectorErr->size();
 394                 m_pvectorErr->resize(m_pvectorErr->size() + size);
 395                 memcpy(&*(m_pvectorErr->begin() + oldsize), data, size);
 396                 return false;
 397         }
 398         BYTE_VECTOR* m_pvector;
 399         BYTE_VECTOR* m_pvectorErr;
 400
 401 };
 402 int CGit::Run(CString cmd,BYTE_VECTOR *vector, BYTE_VECTOR *vectorErr)
 403 {
 404         CGitCall_ByteVector call(cmd, vector, vectorErr);
 405         return Run(&call);
 406 }
 407 int CGit::Run(CString cmd, CString* output, int code)
 408 {
 409         CString err;
 410         int ret;
 411         ret = Run(cmd, output, &err, code);
 412
 413         if (output && !err.IsEmpty())
 414         {
 415                 if (!output->IsEmpty())
 416                         *output += _T("\n");
 417                 *output += err;
 418         }
 419
 420         return ret;
 421 }
 422 int CGit::Run(CString cmd, CString* output, CString* outputErr, int code)
 423 {
 424         BYTE_VECTOR vector, vectorErr;
 425         int ret;
 426         if (outputErr)
 427                 ret = Run(cmd, &vector, &vectorErr);
 428         else
 429                 ret = Run(cmd, &vector);
 430
 431         vector.push_back(0);
 432         StringAppend(output, &(vector[0]), code);
 433
 434         if (outputErr)
 435         {
 436                 vectorErr.push_back(0);
 437                 StringAppend(outputErr, &(vectorErr[0]), code);
 438         }
 439
 440         return ret;
 441 }
 442
 443 CString CGit::GetUserName(void)
 444 {
 445         CEnvironment env;
 446         env.CopyProcessEnvironment();
 447         CString envname = env.GetEnv(_T("GIT_AUTHOR_NAME"));
 448         if (!envname.IsEmpty())
 449                 return envname;
 450         return GetConfigValue(L"user.name", this->GetGitEncode(L"i18n.commitencoding"));
 451 }
 452 CString CGit::GetUserEmail(void)
 453 {
 454         CEnvironment env;
 455         env.CopyProcessEnvironment();
 456         CString envmail = env.GetEnv(_T("GIT_AUTHOR_EMAIL"));
 457         if (!envmail.IsEmpty())
 458                 return envmail;
 459
 460         return GetConfigValue(L"user.email");
 461 }
 462
 463 CString CGit::GetConfigValue(CString name,int encoding, CString *GitPath, BOOL RemoveCR)
 464 {
 465         CString configValue;
 466         int start = 0;
 467         if(this->m_IsUseGitDLL)
 468         {
 469                 CString *git_path=NULL;
 470
 471                 CAutoLocker lock(g_Git.m_critGitDllSec);
 472
 473                 try
 474                 {
 475                         CTGitPath path;
 476
 477                         CheckAndInitDll();
 478                         git_path = GitPath;
 479
 480                 }catch(...)
 481                 {
 482                 }
 483                 CStringA key, value;
 484                 key =  CUnicodeUtils::GetMulti(name, encoding);
 485                 CStringA p;
 486                 if(git_path)
 487                         p = CUnicodeUtils::GetMulti(*GitPath, CP_UTF8);
 488
 489                 if(git_get_config(key.GetBuffer(), value.GetBufferSetLength(4096), 4096, p.GetBuffer()))
 490                         return CString();
 491                 else
 492                 {
 493                         g_Git.StringAppend(&configValue,(BYTE*)value.GetBuffer(),encoding);
 494                         if(RemoveCR)
 495                                 return configValue.Tokenize(_T("\n"),start);
 496                         return configValue;
 497                 }
 498
 499         }
 500         else
 501         {
 502                 CString cmd;
 503                 cmd.Format(L"git.exe config %s", name);
 504                 Run(cmd, &configValue, NULL, encoding);
 505                 if(RemoveCR)
 506                         return configValue.Tokenize(_T("\n"),start);
 507                 return configValue;
 508         }
 509 }
 510
 511 int CGit::SetConfigValue(CString key, CString value, CONFIG_TYPE type, int encoding, CString *GitPath)
 512 {
 513         if(this->m_IsUseGitDLL)
 514         {
 515                 CAutoLocker lock(g_Git.m_critGitDllSec);
 516
 517                 try
 518                 {
 519                         CheckAndInitDll();
 520
 521                 }catch(...)
 522                 {
 523                 }
 524                 CStringA keya, valuea;
 525                 keya = CUnicodeUtils::GetMulti(key, CP_UTF8);
 526                 valuea = CUnicodeUtils::GetMulti(value, encoding);
 527                 CStringA p;
 528                 if(GitPath)
 529                         p = CUnicodeUtils::GetMulti(*GitPath, CP_UTF8);
 530
 531                 return get_set_config(keya.GetBuffer(), valuea.GetBuffer(), type, p.GetBuffer());
 532
 533         }
 534         else
 535         {
 536                 CString cmd;
 537                 CString option;
 538                 switch(type)
 539                 {
 540                 case CONFIG_GLOBAL:
 541                         option = _T("--global");
 542                         break;
 543                 case CONFIG_SYSTEM:
 544                         option = _T("--system");
 545                         break;
 546                 default:
 547                         break;
 548                 }
 549                 cmd.Format(_T("git.exe config %s %s \"%s\""), option, key, value);
 550                 CString out;
 551                 if (Run(cmd, &out, NULL, encoding))
 552                 {
 553                         return -1;
 554                 }
 555         }
 556         return 0;
 557 }
 558
 559 int CGit::UnsetConfigValue(CString key, CONFIG_TYPE type, int encoding, CString *GitPath)
 560 {
 561         if(this->m_IsUseGitDLL)
 562         {
 563                 CAutoLocker lock(g_Git.m_critGitDllSec);
 564
 565                 try
 566                 {
 567                         CheckAndInitDll();
 568                 }catch(...)
 569                 {
 570                 }
 571                 CStringA keya;
 572                 keya = CUnicodeUtils::GetMulti(key, CP_UTF8);
 573                 CStringA p;
 574                 if(GitPath)
 575                         p=CUnicodeUtils::GetMulti(*GitPath,CP_ACP);
 576
 577                 return get_set_config(keya.GetBuffer(), NULL, type, p.GetBuffer());
 578         }
 579         else
 580         {
 581                 CString cmd;
 582                 CString option;
 583                 switch(type)
 584                 {
 585                 case CONFIG_GLOBAL:
 586                         option = _T("--global");
 587                         break;
 588                 case CONFIG_SYSTEM:
 589                         option = _T("--system");
 590                         break;
 591                 default:
 592                         break;
 593                 }
 594                 cmd.Format(_T("git.exe config %s --unset %s"), option, key);
 595                 CString out;
 596                 if (Run(cmd, &out, NULL, encoding))
 597                 {
 598                         return -1;
 599                 }
 600         }
 601         return 0;
 602 }
 603
 604 CString CGit::GetCurrentBranch(void)
 605 {
 606         CString output;
 607         //Run(_T("git.exe branch"),&branch);
 608
 609         if(this->GetCurrentBranchFromFile(this->m_CurrentDir,output))
 610         {
 611                 return _T("(no branch)");
 612         }
 613         else
 614                 return output;
 615
 616 }
 617
 618 CString CGit::GetSymbolicRef(const wchar_t* symbolicRefName, bool bStripRefsHeads)
 619 {
 620         CString refName;
 621         if(this->m_IsUseGitDLL)
 622         {
 623                 unsigned char sha1[20];
 624                 int flag;
 625
 626                 CAutoLocker lock(g_Git.m_critGitDllSec);
 627                 const char *refs_heads_master = git_resolve_ref(CUnicodeUtils::GetUTF8(CString(symbolicRefName)), sha1, 0, &flag);
 628                 if(refs_heads_master && (flag&REF_ISSYMREF))
 629                 {
 630                         g_Git.StringAppend(&refName,(BYTE*)refs_heads_master);
 631                         if(bStripRefsHeads)
 632                                 refName = StripRefName(refName);
 633                 }
 634
 635         }
 636         else
 637         {
 638                 CString cmd;
 639                 cmd.Format(L"git symbolic-ref %s", symbolicRefName);
 640                 if (Run(cmd, &refName, NULL, CP_UTF8) != 0)
 641                         return CString();//Error
 642                 int iStart = 0;
 643                 refName = refName.Tokenize(L"\n", iStart);
 644                 if(bStripRefsHeads)
 645                         refName = StripRefName(refName);
 646         }
 647         return refName;
 648 }
 649
 650 CString CGit::GetFullRefName(CString shortRefName)
 651 {
 652         CString refName;
 653         CString cmd;
 654         cmd.Format(L"git rev-parse --symbolic-full-name %s", shortRefName);
 655         if (Run(cmd, &refName, NULL, CP_UTF8) != 0)
 656                 return CString();//Error
 657         int iStart = 0;
 658         return refName.Tokenize(L"\n", iStart);
 659 }
 660
 661 CString CGit::StripRefName(CString refName)
 662 {
 663         if(wcsncmp(refName, L"refs/heads/", 11) == 0)
 664                 refName = refName.Mid(11);
 665         else if(wcsncmp(refName, L"refs/", 5) == 0)
 666                 refName = refName.Mid(5);
 667         int start =0;
 668         return refName.Tokenize(_T("\n"),start);
 669 }
 670
 671 int CGit::GetCurrentBranchFromFile(const CString &sProjectRoot, CString &sBranchOut)
 672 {
 673         // read current branch name like git-gui does, by parsing the .git/HEAD file directly
 674
 675         if ( sProjectRoot.IsEmpty() )
 676                 return -1;
 677
 678         CString sDotGitPath;
 679         if (!g_GitAdminDir.GetAdminDirPath(sProjectRoot, sDotGitPath))
 680                 return -1;
 681
 682         CString sHeadFile = sDotGitPath + _T("HEAD");
 683
 684         FILE *pFile;
 685         _tfopen_s(&pFile, sHeadFile.GetString(), _T("r"));
 686
 687         if (!pFile)
 688         {
 689                 return -1;
 690         }
 691
 692         char s[256] = {0};
 693         fgets(s, sizeof(s), pFile);
 694
 695         fclose(pFile);
 696
 697         const char *pfx = "ref: refs/heads/";
 698         const int len = 16;//strlen(pfx)
 699
 700         if ( !strncmp(s, pfx, len) )
 701         {
 702                 //# We're on a branch.  It might not exist.  But
 703                 //# HEAD looks good enough to be a branch.
 704                 CStringA utf8Branch(s + len);
 705                 sBranchOut = CUnicodeUtils::GetUnicode(utf8Branch);
 706                 sBranchOut.TrimRight(_T(" \r\n\t"));
 707
 708                 if ( sBranchOut.IsEmpty() )
 709                         return -1;
 710         }
 711         else
 712         {
 713                 //# Assume this is a detached head.
 714                 sBranchOut = "HEAD";
 715
 716                 return 1;
 717         }
 718
 719         return 0;
 720 }
 721
 722 int CGit::BuildOutputFormat(CString &format,bool IsFull)
 723 {
 724         CString log;
 725         log.Format(_T("#<%c>%%x00"),LOG_REV_ITEM_BEGIN);
 726         format += log;
 727         if(IsFull)
 728         {
 729                 log.Format(_T("#<%c>%%an%%x00"),LOG_REV_AUTHOR_NAME);
 730                 format += log;
 731                 log.Format(_T("#<%c>%%ae%%x00"),LOG_REV_AUTHOR_EMAIL);
 732                 format += log;
 733                 log.Format(_T("#<%c>%%ai%%x00"),LOG_REV_AUTHOR_DATE);
 734                 format += log;
 735                 log.Format(_T("#<%c>%%cn%%x00"),LOG_REV_COMMIT_NAME);
 736                 format += log;
 737                 log.Format(_T("#<%c>%%ce%%x00"),LOG_REV_COMMIT_EMAIL);
 738                 format += log;
 739                 log.Format(_T("#<%c>%%ci%%x00"),LOG_REV_COMMIT_DATE);
 740                 format += log;
 741                 log.Format(_T("#<%c>%%b%%x00"),LOG_REV_COMMIT_BODY);
 742                 format += log;
 743         }
 744
 745         log.Format(_T("#<%c>%%m%%H%%x00"),LOG_REV_COMMIT_HASH);
 746         format += log;
 747         log.Format(_T("#<%c>%%P%%x00"),LOG_REV_COMMIT_PARENT);
 748         format += log;
 749         log.Format(_T("#<%c>%%s%%x00"),LOG_REV_COMMIT_SUBJECT);
 750         format += log;
 751
 752         if(IsFull)
 753         {
 754                 log.Format(_T("#<%c>%%x00"),LOG_REV_COMMIT_FILE);
 755                 format += log;
 756         }
 757         return 0;
 758 }
 759
 760 int CGit::GetLog(BYTE_VECTOR& logOut, const CString &hash,  CTGitPath *path ,int count,int mask,CString *from,CString *to)
 761 {
 762         CGitCall_ByteVector gitCall(CString(), &logOut, NULL);
 763         return GetLog(&gitCall,hash,path,count,mask,from,to);
 764 }
 765
 766 CString CGit::GetLogCmd( const CString &hash, CTGitPath *path, int count, int mask,CString *from,CString *to,bool paramonly,
 767                                                 CFilterData *Filter)
 768 {
 769         CString cmd;
 770         CString num;
 771         CString since;
 772
 773         CString file;
 774
 775         if(path)
 776                 file.Format(_T(" -- \"%s\""),path->GetGitPathString());
 777
 778         if(count>0)
 779                 num.Format(_T("-n%d"),count);
 780
 781         CString param;
 782
 783         if(mask& LOG_INFO_STAT )
 784                 param += _T(" --numstat ");
 785         if(mask& LOG_INFO_FILESTATE)
 786                 param += _T(" --raw ");
 787
 788         if(mask& LOG_INFO_FULLHISTORY)
 789                 param += _T(" --full-history ");
 790
 791         if(mask& LOG_INFO_BOUNDARY)
 792                 param += _T(" --left-right --boundary ");
 793
 794         if(mask& CGit::LOG_INFO_ALL_BRANCH)
 795                 param += _T(" --all ");
 796
 797         if(mask& CGit::LOG_INFO_DETECT_COPYRENAME)
 798                 param += _T(" -C ");
 799
 800         if(mask& CGit::LOG_INFO_DETECT_RENAME )
 801                 param += _T(" -M ");
 802
 803         if(mask& CGit::LOG_INFO_FIRST_PARENT )
 804                 param += _T(" --first-parent ");
 805
 806         if(mask& CGit::LOG_INFO_NO_MERGE )
 807                 param += _T(" --no-merges ");
 808
 809         if(mask& CGit::LOG_INFO_FOLLOW)
 810                 param += _T(" --follow ");
 811
 812         if(mask& CGit::LOG_INFO_SHOW_MERGEDFILE)
 813                 param += _T(" -c ");
 814
 815         if(mask& CGit::LOG_INFO_FULL_DIFF)
 816                 param += _T(" --full-diff ");
 817
 818         if(from != NULL && to != NULL)
 819         {
 820                 CString range;
 821                 range.Format(_T(" %s..%s "),FixBranchName(*from),FixBranchName(*to));
 822                 param += range;
 823         }
 824         else if(to != NULL && hash.IsEmpty())
 825         {
 826                 CString range;
 827                 range.Format(_T(" %s "), FixBranchName(*to));
 828                 param += range;
 829         }
 830         param+=hash;
 831
 832         CString st1,st2;
 833
 834         if( Filter && (Filter->m_From != -1))
 835         {
 836                 st1.Format(_T(" --max-age=%I64u "), Filter->m_From);
 837                 param += st1;
 838         }
 839
 840         if( Filter && (Filter->m_To != -1))
 841         {
 842                 st2.Format(_T(" --min-age=%I64u "), Filter->m_To);
 843                 param += st2;
 844         }
 845
 846         bool isgrep = false;
 847         if( Filter && (!Filter->m_Author.IsEmpty()))
 848         {
 849                 st1.Format(_T(" --author=\"%s\"" ),Filter->m_Author);
 850                 param += st1;
 851                 isgrep = true;
 852         }
 853
 854         if( Filter && (!Filter->m_Committer.IsEmpty()))
 855         {
 856                 st1.Format(_T(" --committer=\"%s\"" ),Filter->m_Author);
 857                 param += st1;
 858                 isgrep = true;
 859         }
 860
 861         if( Filter && (!Filter->m_MessageFilter.IsEmpty()))
 862         {
 863                 st1.Format(_T(" --grep=\"%s\"" ),Filter->m_MessageFilter);
 864                 param += st1;
 865                 isgrep = true;
 866         }
 867
 868         if(Filter && isgrep)
 869         {
 870                 if(!Filter->m_IsRegex)
 871                         param += _T(" --fixed-strings ");
 872
 873                 param += _T(" --regexp-ignore-case --extended-regexp ");
 874         }
 875
 876         if (CRegDWORD(_T("Software\\TortoiseGit\\LogTopoOrder"), TRUE))
 877                 param += _T(" --topo-order");
 878
 879         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
 880                 cmd.Format(_T("--ignore-this-parameter %s -z %s --parents "), num, param);
 881         else
 882         {
 883                 CString log;
 884                 BuildOutputFormat(log,!(mask&CGit::LOG_INFO_ONLY_HASH));
 885                 cmd.Format(_T("git.exe log %s -z %s --parents --pretty=format:\"%s\""),
 886                                 num,param,log);
 887         }
 888
 889         cmd += file;
 890
 891         return cmd;
 892 }
 893 //int CGit::GetLog(CGitCall* pgitCall, const CString &hash,  CTGitPath *path ,int count,int mask)
 894 int CGit::GetLog(CGitCall* pgitCall, const CString &hash, CTGitPath *path, int count, int mask,CString *from,CString *to)
 895 {
 896         pgitCall->SetCmd( GetLogCmd(hash,path,count,mask,from,to) );
 897
 898         return Run(pgitCall);
 899 //      return Run(cmd,&logOut);
 900 }
 901
 902 #define BUFSIZE 512
 903 void GetTempPath(CString &path)
 904 {
 905         TCHAR lpPathBuffer[BUFSIZE];
 906         DWORD dwRetVal;
 907         DWORD dwBufSize=BUFSIZE;
 908         dwRetVal = GetTempPath(dwBufSize,               // length of the buffer
 909                                                         lpPathBuffer);  // buffer for path
 910         if (dwRetVal > dwBufSize || (dwRetVal == 0))
 911         {
 912                 path=_T("");
 913         }
 914         path.Format(_T("%s"),lpPathBuffer);
 915 }
 916 CString GetTempFile()
 917 {
 918         TCHAR lpPathBuffer[BUFSIZE];
 919         DWORD dwRetVal;
 920         DWORD dwBufSize=BUFSIZE;
 921         TCHAR szTempName[BUFSIZE];
 922         UINT uRetVal;
 923
 924         dwRetVal = GetTempPath(dwBufSize,               // length of the buffer
 925                                                         lpPathBuffer);  // buffer for path
 926         if (dwRetVal > dwBufSize || (dwRetVal == 0))
 927         {
 928                 return _T("");
 929         }
 930          // Create a temporary file.
 931         uRetVal = GetTempFileName(lpPathBuffer,         // directory for tmp files
 932                                                                 TEXT("Patch"),  // temp file name prefix
 933                                                                 0,                              // create unique name
 934                                                                 szTempName);    // buffer for name
 935
 936
 937         if (uRetVal == 0)
 938         {
 939                 return _T("");
 940         }
 941
 942         return CString(szTempName);
 943
 944 }
 945
 946 int CGit::RunLogFile(CString cmd,const CString &filename)
 947 {
 948         STARTUPINFO si;
 949         PROCESS_INFORMATION pi;
 950         si.cb=sizeof(STARTUPINFO);
 951         GetStartupInfo(&si);
 952
 953         SECURITY_ATTRIBUTES   psa={sizeof(psa),NULL,TRUE};;
 954         psa.bInheritHandle=TRUE;
 955
 956         HANDLE houtfile=CreateFile(filename,GENERIC_WRITE,FILE_SHARE_READ | FILE_SHARE_WRITE,
 957                         &psa,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
 958
 959         si.wShowWindow = SW_HIDE;
 960         si.dwFlags = STARTF_USESTDHANDLES|STARTF_USESHOWWINDOW;
 961         si.hStdOutput = houtfile;
 962
 963         LPTSTR pEnv = m_Environment.size()? &m_Environment[0]: NULL;
 964         DWORD dwFlags = pEnv ? CREATE_UNICODE_ENVIRONMENT : 0;
 965
 966         if(cmd.Find(_T("git")) == 0)
 967                 cmd=CGit::ms_LastMsysGitDir+_T("\\")+cmd;
 968
 969         if(!CreateProcess(NULL,(LPWSTR)cmd.GetString(), NULL,NULL,TRUE,dwFlags,pEnv,(LPWSTR)m_CurrentDir.GetString(),&si,&pi))
 970         {
 971                 LPVOID lpMsgBuf;
 972                 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,
 973                                                 NULL,GetLastError(),MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
 974                                                 (LPTSTR)&lpMsgBuf,
 975                                                 0,NULL);
 976                 return TGIT_GIT_ERROR_CREATE_PROCESS;
 977         }
 978
 979         WaitForSingleObject(pi.hProcess,INFINITE);
 980
 981         CloseHandle(pi.hThread);
 982         CloseHandle(pi.hProcess);
 983         CloseHandle(houtfile);
 984         return TGIT_GIT_SUCCESS;
 985 //      return 0;
 986 }
 987
 988 CGitHash CGit::GetHash(TCHAR* friendname)
 989 {
 990         if(this->m_IsUseGitDLL)
 991         {
 992                 CAutoLocker lock(g_Git.m_critGitDllSec);
 993
 994                 this->CheckAndInitDll();
 995
 996                 CGitHash hash;
 997                 CStringA ref;
 998                 ref = CUnicodeUtils::GetMulti(FixBranchName(friendname), CP_UTF8);
 999                 try
1000                 {
1001                         git_get_sha1(ref, hash.m_hash);
1002
1003                 }catch(...)
1004                 {
1005                 }
1006                 return hash;
1007
1008         }
1009         else
1010         {
1011                 CString cmd;
1012                 CString out;
1013                 cmd.Format(_T("git.exe rev-parse %s" ),FixBranchName(friendname));
1014                 Run(cmd, &out, NULL, CP_UTF8);
1015         //      int pos=out.ReverseFind(_T('\n'));
1016                 out.FindOneOf(_T("\r\n"));
1017                 return CGitHash(out);
1018         }
1019 }
1020
1021 int CGit::GetInitAddList(CTGitPathList &outputlist)
1022 {
1023         CString cmd;
1024         BYTE_VECTOR cmdout;
1025
1026         cmd=_T("git.exe ls-files -s -t -z");
1027         outputlist.Clear();
1028         if (g_Git.Run(cmd, &cmdout))
1029                 return -1;
1030
1031         outputlist.ParserFromLsFile(cmdout);
1032         for(int i=0;i<outputlist.GetCount();i++)
1033                 ((unsigned int)outputlist[i].m_Action) = CTGitPath::LOGACTIONS_ADDED;
1034
1035         return 0;
1036 }
1037 int CGit::GetCommitDiffList(const CString &rev1,const CString &rev2,CTGitPathList &outputlist)
1038 {
1039         CString cmd;
1040
1041         if(rev1 == GIT_REV_ZERO || rev2 == GIT_REV_ZERO)
1042         {
1043                 //rev1=+_T("");
1044                 if(rev1 == GIT_REV_ZERO)
1045                         cmd.Format(_T("git.exe diff -r --raw -C -M --numstat -z %s"),rev2);
1046                 else
1047                         cmd.Format(_T("git.exe diff -r -R --raw -C -M --numstat -z %s"),rev1);
1048         }
1049         else
1050         {
1051                 cmd.Format(_T("git.exe diff-tree -r --raw -C -M --numstat -z %s %s"),rev2,rev1);
1052         }
1053
1054         BYTE_VECTOR out;
1055         if (g_Git.Run(cmd, &out))
1056                 return -1;
1057
1058         outputlist.ParserFromLog(out);
1059
1060         return 0;
1061 }
1062
1063 int addto_list_each_ref_fn(const char *refname, const unsigned char * /*sha1*/, int /*flags*/, void *cb_data)
1064 {
1065         STRING_VECTOR *list = (STRING_VECTOR*)cb_data;
1066         CString str;
1067         g_Git.StringAppend(&str, (BYTE*)refname, CP_UTF8);
1068         list->push_back(str);
1069         return 0;
1070 }
1071
1072 int CGit::GetTagList(STRING_VECTOR &list)
1073 {
1074         int ret;
1075
1076         if(this->m_IsUseGitDLL)
1077         {
1078                 CAutoLocker lock(g_Git.m_critGitDllSec);
1079                 return git_for_each_ref_in("refs/tags/",addto_list_each_ref_fn, &list);
1080
1081         }
1082         else
1083         {
1084                 CString cmd, output;
1085                 cmd=_T("git.exe tag -l");
1086                 int i=0;
1087                 ret = g_Git.Run(cmd, &output, NULL, CP_UTF8);
1088                 if(!ret)
1089                 {
1090                         int pos=0;
1091                         CString one;
1092                         while( pos>=0 )
1093                         {
1094                                 i++;
1095                                 one=output.Tokenize(_T("\n"),pos);
1096                                 list.push_back(one);
1097                         }
1098                 }
1099         }
1100         return ret;
1101 }
1102
1103 CString CGit::FixBranchName_Mod(CString& branchName)
1104 {
1105         if(branchName == "FETCH_HEAD")
1106                 branchName = DerefFetchHead();
1107         return branchName;
1108 }
1109
1110 CString CGit::FixBranchName(const CString& branchName)
1111 {
1112         CString tempBranchName = branchName;
1113         FixBranchName_Mod(tempBranchName);
1114         return tempBranchName;
1115 }
1116
1117
1118 CString CGit::DerefFetchHead()
1119 {
1120         using namespace std;
1121         CString dotGitPath;
1122         g_GitAdminDir.GetAdminDirPath(m_CurrentDir, dotGitPath);
1123         ifstream fetchHeadFile((dotGitPath + L"FETCH_HEAD").GetString(), ios::in | ios::binary);
1124         int forMergeLineCount = 0;
1125         string line;
1126         string hashToReturn;
1127         while(getline(fetchHeadFile, line))
1128         {
1129                 //Tokenize this line
1130                 string::size_type prevPos = 0;
1131                 string::size_type pos = line.find('\t');
1132                 if(pos == string::npos) continue; //invalid line
1133
1134                 string hash = line.substr(0, pos);
1135                 ++pos; prevPos = pos; pos = line.find('\t', pos); if(pos == string::npos) continue;
1136
1137                 bool forMerge = pos == prevPos;
1138                 ++pos; prevPos = pos; pos = line.size(); if(pos == string::npos) continue;
1139
1140                 string remoteBranch = line.substr(prevPos, pos - prevPos);
1141
1142                 //Process this line
1143                 if(forMerge)
1144                 {
1145                         hashToReturn = hash;
1146                         ++forMergeLineCount;
1147                         if(forMergeLineCount > 1)
1148                                 return L""; //More then 1 branch to merge found. Octopus merge needed. Cannot pick single ref from FETCH_HEAD
1149                 }
1150         }
1151
1152         return CUnicodeUtils::GetUnicode(hashToReturn.c_str());
1153 }
1154
1155 int CGit::GetBranchList(STRING_VECTOR &list,int *current,BRANCH_TYPE type)
1156 {
1157         int ret;
1158         CString cmd, output;
1159         cmd = _T("git.exe branch --no-color");
1160
1161         if((type&BRANCH_ALL) == BRANCH_ALL)
1162                 cmd += _T(" -a");
1163         else if(type&BRANCH_REMOTE)
1164                 cmd += _T(" -r");
1165
1166         int i=0;
1167         ret = g_Git.Run(cmd, &output, NULL, CP_UTF8);
1168         if(!ret)
1169         {
1170                 int pos=0;
1171                 CString one;
1172                 while( pos>=0 )
1173                 {
1174                         one=output.Tokenize(_T("\n"),pos);
1175                         one.Trim(L" \r\n\t");
1176                         if(one.Find(L" -> ") >= 0 || one.IsEmpty())
1177                                 continue; // skip something like: refs/origin/HEAD -> refs/origin/master
1178                         if(one[0] == _T('*'))
1179                         {
1180                                 if(current)
1181                                         *current=i;
1182                                 one = one.Mid(2);
1183                         }
1184                         if (one != _T("(no branch)"))
1185                                 list.push_back(one);
1186                         i++;
1187                 }
1188         }
1189
1190         if(type & BRANCH_FETCH_HEAD && !DerefFetchHead().IsEmpty())
1191                 list.push_back(L"FETCH_HEAD");
1192
1193         return ret;
1194 }
1195
1196 int CGit::GetRemoteList(STRING_VECTOR &list)
1197 {
1198         int ret;
1199         CString cmd, output;
1200         cmd=_T("git.exe remote");
1201         ret = g_Git.Run(cmd, &output, NULL, CP_UTF8);
1202         if(!ret)
1203         {
1204                 int pos=0;
1205                 CString one;
1206                 while( pos>=0 )
1207                 {
1208                         one=output.Tokenize(_T("\n"),pos);
1209                         list.push_back(one);
1210                 }
1211         }
1212         return ret;
1213 }
1214
1215 int CGit::GetRefList(STRING_VECTOR &list)
1216 {
1217         int ret;
1218         if(this->m_IsUseGitDLL)
1219         {
1220                 CAutoLocker lock(g_Git.m_critGitDllSec);
1221                 return git_for_each_ref_in("",addto_list_each_ref_fn, &list);
1222
1223         }
1224         else
1225         {
1226                 CString cmd, output;
1227                 cmd=_T("git.exe show-ref -d");
1228                 ret = g_Git.Run(cmd, &output, NULL, CP_UTF8);
1229                 if(!ret)
1230                 {
1231                         int pos=0;
1232                         CString one;
1233                         while( pos>=0 )
1234                         {
1235                                 one=output.Tokenize(_T("\n"),pos);
1236                                 int start=one.Find(_T(" "),0);
1237                                 if(start>0)
1238                                 {
1239                                         CString name;
1240                                         name=one.Right(one.GetLength()-start-1);
1241                                         list.push_back(name);
1242                                 }
1243                         }
1244                 }
1245         }
1246         return ret;
1247 }
1248
1249 int addto_map_each_ref_fn(const char *refname, const unsigned char *sha1, int /*flags*/, void *cb_data)
1250 {
1251         MAP_HASH_NAME *map = (MAP_HASH_NAME*)cb_data;
1252         CString str;
1253         g_Git.StringAppend(&str, (BYTE*)refname, CP_UTF8);
1254         CGitHash hash((char*)sha1);
1255
1256         (*map)[hash].push_back(str);
1257
1258         if(strncmp(refname, "refs/tags", 9) == 0)
1259         {
1260                 GIT_HASH refhash;
1261                 if(!git_deref_tag(sha1, refhash))
1262                 {
1263                         (*map)[(char*)refhash].push_back(str+_T("^{}"));
1264                 }
1265         }
1266         return 0;
1267 }
1268
1269 int CGit::GetMapHashToFriendName(MAP_HASH_NAME &map)
1270 {
1271         int ret;
1272         if(this->m_IsUseGitDLL)
1273         {
1274                 CAutoLocker lock(g_Git.m_critGitDllSec);
1275                 return git_for_each_ref_in("",addto_map_each_ref_fn, &map);
1276
1277         }
1278         else
1279         {
1280                 CString cmd, output;
1281                 cmd=_T("git.exe show-ref -d");
1282                 ret = g_Git.Run(cmd, &output, NULL, CP_UTF8);
1283                 if(!ret)
1284                 {
1285                         int pos=0;
1286                         CString one;
1287                         while( pos>=0 )
1288                         {
1289                                 one=output.Tokenize(_T("\n"),pos);
1290                                 int start=one.Find(_T(" "),0);
1291                                 if(start>0)
1292                                 {
1293                                         CString name;
1294                                         name=one.Right(one.GetLength()-start-1);
1295
1296                                         CString hash;
1297                                         hash=one.Left(start);
1298
1299                                         map[CGitHash(hash)].push_back(name);
1300                                 }
1301                         }
1302                 }
1303         }
1304         return ret;
1305 }
1306
1307 BOOL CGit::CheckMsysGitDir()
1308 {
1309         if (m_bInitialized)
1310         {
1311                 return TRUE;
1312         }
1313
1314         this->m_Environment.clear();
1315         m_Environment.CopyProcessEnvironment();
1316
1317         TCHAR *oldpath;
1318         size_t homesize,size;
1319
1320         // set HOME if not set already
1321         _tgetenv_s(&homesize, NULL, 0, _T("HOME"));
1322         if (!homesize)
1323         {
1324                 CString home = g_Git.GetHomeDirectory();
1325                 m_Environment.SetEnv(_T("HOME"), home.GetBuffer());
1326                 home.ReleaseBuffer();
1327         }
1328         CString str;
1329
1330         //setup ssh client
1331         CString sshclient=CRegString(_T("Software\\TortoiseGit\\SSH"));
1332
1333         if(!sshclient.IsEmpty())
1334         {
1335                 m_Environment.SetEnv(_T("GIT_SSH"), sshclient.GetBuffer());
1336                 m_Environment.SetEnv(_T("SVN_SSH"), sshclient.GetBuffer());
1337         }
1338         else
1339         {
1340                 TCHAR sPlink[MAX_PATH];
1341                 GetModuleFileName(NULL, sPlink, _countof(sPlink));
1342                 LPTSTR ptr = _tcsrchr(sPlink, _T('\\'));
1343                 if (ptr) {
1344                         _tcscpy(ptr + 1, _T("TortoisePlink.exe"));
1345                         m_Environment.SetEnv(_T("GIT_SSH"), sPlink);
1346                         m_Environment.SetEnv(_T("SVN_SSH"), sPlink);
1347                 }
1348         }
1349
1350         {
1351                 TCHAR sAskPass[MAX_PATH];
1352                 GetModuleFileName(NULL, sAskPass, _countof(sAskPass));
1353                 LPTSTR ptr = _tcsrchr(sAskPass, _T('\\'));
1354                 if (ptr)
1355                 {
1356                         _tcscpy(ptr + 1, _T("SshAskPass.exe"));
1357                         m_Environment.SetEnv(_T("DISPLAY"),_T(":9999"));
1358                         m_Environment.SetEnv(_T("SSH_ASKPASS"),sAskPass);
1359                         m_Environment.SetEnv(_T("GIT_ASKPASS"),sAskPass);
1360                 }
1361         }
1362
1363         // add git/bin path to PATH
1364
1365         CRegString msysdir=CRegString(REG_MSYSGIT_PATH,_T(""),FALSE);
1366         str=msysdir;
1367         if(str.IsEmpty() || !FileExists(str + _T("\\git.exe")))
1368         {
1369                 CRegString msysinstalldir=CRegString(REG_MSYSGIT_INSTALL,_T(""),FALSE,HKEY_LOCAL_MACHINE);
1370                 str=msysinstalldir;
1371                 if ( !str.IsEmpty() )
1372                 {
1373                         str += (str[str.GetLength()-1] != '\\') ? "\\bin" : "bin";
1374                         msysdir=str;
1375                         CGit::ms_LastMsysGitDir = str;
1376                         msysdir.write();
1377                 }
1378                 else
1379                 {
1380                         // search PATH if git/bin directory is already present
1381                         if ( FindGitPath() )
1382                         {
1383                                 m_bInitialized = TRUE;
1384                                 msysdir = CGit::ms_LastMsysGitDir;
1385                                 msysdir.write();
1386                                 return TRUE;
1387                         }
1388
1389                         return FALSE;
1390                 }
1391         }
1392         else
1393         {
1394                 CGit::ms_LastMsysGitDir = str;
1395         }
1396
1397         // check for git.exe existance (maybe it was deinstalled in the meantime)
1398         if (!FileExists(CGit::ms_LastMsysGitDir + _T("\\git.exe")))
1399                 return FALSE;
1400
1401         //set path
1402         _tdupenv_s(&oldpath,&size,_T("PATH"));
1403
1404         CString path;
1405         path.Format(_T("%s;%s"),oldpath,str + _T(";")+ (CString)CRegString(REG_MSYSGIT_EXTRA_PATH,_T(""),FALSE));
1406
1407         m_Environment.SetEnv(_T("PATH"),path.GetBuffer());
1408
1409         CString str1 = m_Environment.GetEnv(_T("PATH"));
1410
1411         CString sOldPath = oldpath;
1412         free(oldpath);
1413
1414         m_bInitialized = TRUE;
1415         return true;
1416 }
1417
1418 CString CGit::GetHomeDirectory()
1419 {
1420         return CString(get_windows_home_directory());
1421 }
1422
1423 BOOL CGit::CheckCleanWorkTree()
1424 {
1425         CString out;
1426         CString cmd;
1427         cmd=_T("git.exe rev-parse --verify HEAD");
1428
1429         if(g_Git.Run(cmd,&out,CP_UTF8))
1430                 return FALSE;
1431
1432         cmd=_T("git.exe update-index --ignore-submodules --refresh");
1433         if(g_Git.Run(cmd,&out,CP_UTF8))
1434                 return FALSE;
1435
1436         cmd=_T("git.exe diff-files --quiet --ignore-submodules");
1437         if(g_Git.Run(cmd,&out,CP_UTF8))
1438                 return FALSE;
1439
1440         cmd=_T("git diff-index --cached --quiet HEAD --ignore-submodules");
1441         if(g_Git.Run(cmd,&out,CP_UTF8))
1442                 return FALSE;
1443
1444         return TRUE;
1445 }
1446 int CGit::Revert(CString commit, CTGitPathList &list, bool)
1447 {
1448         int ret;
1449         for(int i=0;i<list.GetCount();i++)
1450         {
1451                 ret = Revert(commit, (CTGitPath&)list[i]);
1452                 if(ret)
1453                         return ret;
1454         }
1455         return 0;
1456 }
1457 int CGit::Revert(CString commit, CTGitPath &path)
1458 {
1459         CString cmd, out;
1460
1461         if(path.m_Action & CTGitPath::LOGACTIONS_REPLACED && !path.GetGitOldPathString().IsEmpty())
1462         {
1463                 cmd.Format(_T("git.exe mv -- \"%s\" \"%s\""),path.GetGitPathString(),path.GetGitOldPathString());
1464                 if (g_Git.Run(cmd, &out, CP_UTF8))
1465                 {
1466                         ::MessageBox(NULL, out, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
1467                         return -1;
1468                 }
1469
1470                 cmd.Format(_T("git.exe checkout %s -f -- \"%s\""), commit, path.GetGitOldPathString());
1471                 if (g_Git.Run(cmd, &out, CP_UTF8))
1472                 {
1473                         ::MessageBox(NULL, out, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
1474                         return -1;
1475                 }
1476
1477         }
1478         else if(path.m_Action & CTGitPath::LOGACTIONS_ADDED)
1479         {       //To init git repository, there are not HEAD, so we can use git reset command
1480                 cmd.Format(_T("git.exe rm -f --cached -- \"%s\""),path.GetGitPathString());
1481
1482                 if (g_Git.Run(cmd, &out, CP_UTF8))
1483                 {
1484                         ::MessageBox(NULL, out, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
1485                         return -1;
1486                 }
1487         }
1488         else
1489         {
1490                 cmd.Format(_T("git.exe checkout %s -f -- \"%s\""), commit, path.GetGitPathString());
1491                 if (g_Git.Run(cmd, &out, CP_UTF8))
1492                 {
1493                         ::MessageBox(NULL, out, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
1494                         return -1;
1495                 }
1496         }
1497
1498         if (path.m_Action & CTGitPath::LOGACTIONS_DELETED)
1499         {
1500                 cmd.Format(_T("git.exe add -f -- \"%s\""), path.GetGitPathString());
1501                 if (g_Git.Run(cmd, &out, CP_UTF8))
1502                 {
1503                         ::MessageBox(NULL, out, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
1504                         return -1;
1505                 }
1506         }
1507
1508         return 0;
1509 }
1510
1511 int CGit::ListConflictFile(CTGitPathList &list,CTGitPath *path)
1512 {
1513         BYTE_VECTOR vector;
1514
1515         CString cmd;
1516         if(path)
1517                 cmd.Format(_T("git.exe ls-files -u -t -z -- \"%s\""),path->GetGitPathString());
1518         else
1519                 cmd=_T("git.exe ls-files -u -t -z");
1520
1521         if (g_Git.Run(cmd, &vector))
1522         {
1523                 return -1;
1524         }
1525
1526         list.ParserFromLsFile(vector);
1527
1528         return 0;
1529 }
1530
1531 bool CGit::IsFastForward(const CString &from, const CString &to)
1532 {
1533         CString base;
1534         CGitHash basehash,hash;
1535         CString cmd, err;
1536         cmd.Format(_T("git.exe merge-base %s %s"), FixBranchName(to), FixBranchName(from));
1537
1538         if (g_Git.Run(cmd, &base, &err, CP_UTF8))
1539         {
1540                 //CMessageBox::Show(NULL, base + _T("\n") + err, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
1541                 return false;
1542         }
1543         basehash = base;
1544
1545         hash=g_Git.GetHash(from);
1546
1547         return hash == basehash;
1548 }
1549
1550 unsigned int CGit::Hash2int(CGitHash &hash)
1551 {
1552         int ret=0;
1553         for(int i=0;i<4;i++)
1554         {
1555                 ret = ret << 8;
1556                 ret |= hash.m_hash[i];
1557         }
1558         return ret;
1559 }
1560
1561 int CGit::RefreshGitIndex()
1562 {
1563         if(g_Git.m_IsUseGitDLL)
1564         {
1565                 try
1566                 {
1567                         CAutoLocker lock(g_Git.m_critGitDllSec);
1568                         return git_run_cmd("update-index","update-index -q --refresh");
1569
1570                 }catch(...)
1571                 {
1572                         return -1;
1573                 }
1574
1575         }
1576         else
1577         {
1578                 CString cmd,output;
1579                 cmd=_T("git.exe update-index --refresh");
1580                 return Run(cmd, &output, CP_UTF8);
1581         }
1582 }
1583
1584 int CGit::GetOneFile(CString Refname, CTGitPath &path, const CString &outputfile)
1585 {
1586         if(g_Git.m_IsUseGitDLL)
1587         {
1588                 try
1589                 {
1590                         CAutoLocker lock(g_Git.m_critGitDllSec);
1591                         g_Git.CheckAndInitDll();
1592                         CStringA ref, patha, outa;
1593                         ref = CUnicodeUtils::GetMulti(Refname, CP_UTF8);
1594                         patha = CUnicodeUtils::GetMulti(path.GetGitPathString(), CP_UTF8);
1595                         outa = CUnicodeUtils::GetMulti(outputfile, CP_UTF8);
1596                         ::DeleteFile(outputfile);
1597                         return git_checkout_file((const char*)ref.GetBuffer(),(const char*)patha.GetBuffer(),(const char*)outa.GetBuffer());
1598
1599                 }catch(...)
1600                 {
1601                         return -1;
1602                 }
1603         }
1604         else
1605         {
1606                 CString cmd;
1607                 cmd.Format(_T("git.exe cat-file -p %s:\"%s\""), Refname, path.GetGitPathString());
1608                 return g_Git.RunLogFile(cmd,outputfile);
1609         }
1610 }
1611 void CEnvironment::CopyProcessEnvironment()
1612 {
1613         TCHAR *p = GetEnvironmentStrings();
1614         while(*p !=0 || *(p+1) !=0)
1615                 this->push_back(*p++);
1616
1617         push_back(_T('\0'));
1618         push_back(_T('\0'));
1619 }
1620
1621 CString CEnvironment::GetEnv(TCHAR *name)
1622 {
1623         CString str;
1624         for(int i=0;i<size();i++)
1625         {
1626                 str = &(*this)[i];
1627                 int start =0;
1628                 CString sname = str.Tokenize(_T("="),start);
1629                 if(sname.CompareNoCase(name) == 0)
1630                 {
1631                         return &(*this)[i+start];
1632                 }
1633                 i+=str.GetLength();
1634         }
1635         return _T("");
1636 }
1637
1638 void CEnvironment::SetEnv(TCHAR *name, TCHAR* value)
1639 {
1640         unsigned int i;
1641         for( i=0;i<size();i++)
1642         {
1643                 CString str = &(*this)[i];
1644                 int start =0;
1645                 CString sname = str.Tokenize(_T("="),start);
1646                 if(sname.CompareNoCase(name) == 0)
1647                 {
1648                         break;
1649                 }
1650                 i+=str.GetLength();
1651         }
1652
1653         if(i == size())
1654         {
1655                 i -= 1; // roll back terminate \0\0
1656                 this->push_back(_T('\0'));
1657         }
1658
1659         CEnvironment::iterator it;
1660         it=this->begin();
1661         it += i;
1662
1663         while(*it && i<size())
1664         {
1665                 this->erase(it);
1666                 it=this->begin();
1667                 it += i;
1668         }
1669
1670         while(*name)
1671         {
1672                 this->insert(it,*name++);
1673                 i++;
1674                 it= begin()+i;
1675         }
1676
1677         this->insert(it, _T('='));
1678         i++;
1679         it= begin()+i;
1680
1681         while(*value)
1682         {
1683                 this->insert(it,*value++);
1684                 i++;
1685                 it= begin()+i;
1686         }
1687
1688 }
1689
1690 int CGit::GetGitEncode(TCHAR* configkey)
1691 {
1692         CString str=GetConfigValue(configkey);
1693
1694         if(str.IsEmpty())
1695                 return CP_UTF8;
1696
1697         return CUnicodeUtils::GetCPCode(str);
1698 }
1699
1700
1701 int CGit::GetDiffPath(CTGitPathList *PathList, CGitHash *hash1, CGitHash *hash2, char *arg)
1702 {
1703         GIT_FILE file=0;
1704         int ret=0;
1705         GIT_DIFF diff=0;
1706
1707         CAutoLocker lock(g_Git.m_critGitDllSec);
1708
1709         if(arg == NULL)
1710                 diff = GetGitDiff();
1711         else
1712                 git_open_diff(&diff, arg);
1713
1714         if(diff ==NULL)
1715                 return -1;
1716
1717         bool isStat = 0;
1718         if(arg == NULL)
1719                 isStat = true;
1720         else
1721                 isStat = !!strstr(arg, "stat");
1722
1723         int count=0;
1724
1725         if(hash2 == NULL)
1726                 ret = git_root_diff(diff, hash1->m_hash, &file, &count,isStat);
1727         else
1728                 ret = git_diff(diff,hash2->m_hash,hash1->m_hash,&file,&count,isStat);
1729
1730         if(ret)
1731                 return -1;
1732
1733         CTGitPath path;
1734         CString strnewname;
1735         CString stroldname;
1736
1737         for(int j=0;j<count;j++)
1738         {
1739                 path.Reset();
1740                 char *newname;
1741                 char *oldname;
1742
1743                 strnewname.Empty();
1744                 stroldname.Empty();
1745
1746                 int mode=0,IsBin=0,inc=0,dec=0;
1747                 git_get_diff_file(diff,file,j,&newname,&oldname,
1748                                         &mode,&IsBin,&inc,&dec);
1749
1750                 StringAppend(&strnewname, (BYTE*)newname, CP_UTF8);
1751                 StringAppend(&stroldname, (BYTE*)oldname, CP_UTF8);
1752
1753                 path.SetFromGit(strnewname,&stroldname);
1754                 path.ParserAction((BYTE)mode);
1755
1756                 if(IsBin)
1757                 {
1758                         path.m_StatAdd=_T("-");
1759                         path.m_StatDel=_T("-");
1760                 }
1761                 else
1762                 {
1763                         path.m_StatAdd.Format(_T("%d"),inc);
1764                         path.m_StatDel.Format(_T("%d"),dec);
1765                 }
1766                 PathList->AddPath(path);
1767         }
1768         git_diff_flush(diff);
1769
1770         if(arg)
1771                 git_close_diff(diff);
1772
1773         return 0;
1774 }
1775
1776 int CGit::GetShortHASHLength()
1777 {
1778         return 7;
1779 }