src/Git/Git.cpp

   1 #include "StdAfx.h"
   2 #include "Git.h"
   3 #include "atlconv.h"
   4 #include "GitRev.h"
   5 #include "registry.h"
   6 #include "GitConfig.h"
   7 #include <map>
   8 #include "UnicodeUtils.h"
   9 #include "gitdll.h"
  10
  11 int CGit::m_LogEncode=CP_UTF8;
  12
  13
  14 static LPTSTR nextpath(LPCTSTR src, LPTSTR dst, UINT maxlen)
  15 {
  16         LPCTSTR orgsrc;
  17
  18         while (*src == _T(';'))
  19                 src++;
  20
  21         orgsrc = src;
  22
  23         if (!--maxlen)
  24                 goto nullterm;
  25
  26         while (*src && *src != _T(';'))
  27         {
  28                 if (*src != _T('"'))
  29                 {
  30                         *dst++ = *src++;
  31                         if (!--maxlen)
  32                         {
  33                                 orgsrc = src;
  34                                 goto nullterm;
  35                         }
  36                 }
  37                 else
  38                 {
  39                         src++;
  40                         while (*src && *src != _T('"'))
  41                         {
  42                                 *dst++ = *src++;
  43                                 if (!--maxlen)
  44                                 {
  45                                         orgsrc = src;
  46                                         goto nullterm;
  47                                 }
  48                         }
  49
  50                         if (*src)
  51                                 src++;
  52                 }
  53         }
  54
  55         while (*src == _T(';'))
  56                 src++;
  57
  58 nullterm:
  59
  60         *dst = 0;
  61
  62         return (orgsrc != src) ? (LPTSTR)src : NULL;
  63 }
  64
  65 static inline BOOL FileExists(LPCTSTR lpszFileName)
  66 {
  67         struct _stat st;
  68         return _tstat(lpszFileName, &st) == 0;
  69 }
  70
  71 static BOOL FindGitPath()
  72 {
  73         size_t size;
  74         _tgetenv_s(&size, NULL, 0, _T("PATH"));
  75
  76         if (!size)
  77         {
  78                 return FALSE;
  79         }
  80
  81         TCHAR *env = (TCHAR*)alloca(size * sizeof(TCHAR));
  82         _tgetenv_s(&size, env, size, _T("PATH"));
  83
  84         TCHAR buf[_MAX_PATH];
  85
  86         // search in all paths defined in PATH
  87         while ((env = nextpath(env, buf, _MAX_PATH-1)) && *buf)
  88         {
  89                 TCHAR *pfin = buf + _tcslen(buf)-1;
  90
  91                 // ensure trailing slash
  92                 if (*pfin != _T('/') && *pfin != _T('\\'))
  93                         _tcscpy(++pfin, _T("\\"));
  94
  95                 const int len = _tcslen(buf);
  96
  97                 if ((len + 7) < _MAX_PATH)
  98                         _tcscpy(pfin+1, _T("git.exe"));
  99                 else
 100                         break;
 101
 102                 if ( FileExists(buf) )
 103                 {
 104                         // dir found
 105                         pfin[1] = 0;
 106                         CGit::ms_LastMsysGitDir = buf;
 107                         return TRUE;
 108                 }
 109         }
 110
 111         return FALSE;
 112 }
 113
 114
 115 #define MAX_DIRBUFFER 1000
 116 #define CALL_OUTPUT_READ_CHUNK_SIZE 1024
 117
 118 CString CGit::ms_LastMsysGitDir;
 119 CGit g_Git;
 120
 121 // contains system environment that should be used by child processes (RunAsync)
 122 // initialized by CheckMsysGitDir
 123 static LPTSTR l_processEnv = NULL;
 124
 125
 126
 127 CGit::CGit(void)
 128 {
 129         GetCurrentDirectory(MAX_DIRBUFFER,m_CurrentDir.GetBuffer(MAX_DIRBUFFER));
 130         m_CurrentDir.ReleaseBuffer();
 131         m_IsGitDllInited = false;
 132         m_GitDiff=0;
 133         CheckMsysGitDir();
 134         m_critGitDllSec.Init();
 135 }
 136
 137 CGit::~CGit(void)
 138 {
 139         if(this->m_GitDiff)
 140         {
 141                 git_close_diff(m_GitDiff);
 142                 m_GitDiff=0;
 143         }
 144 }
 145
 146 static char g_Buffer[4096];
 147
 148 int CGit::RunAsync(CString cmd,PROCESS_INFORMATION *piOut,HANDLE *hReadOut,CString *StdioFile)
 149 {
 150         SECURITY_ATTRIBUTES sa;
 151         HANDLE hRead, hWrite;
 152         HANDLE hStdioFile = NULL;
 153
 154         sa.nLength = sizeof(SECURITY_ATTRIBUTES);
 155         sa.lpSecurityDescriptor=NULL;
 156         sa.bInheritHandle=TRUE;
 157         if(!CreatePipe(&hRead,&hWrite,&sa,0))
 158         {
 159                 return GIT_ERROR_OPEN_PIP;
 160         }
 161
 162         if(StdioFile)
 163         {
 164                 hStdioFile=CreateFile(*StdioFile,GENERIC_WRITE,FILE_SHARE_READ   |   FILE_SHARE_WRITE,
 165                         &sa,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
 166         }
 167
 168         STARTUPINFO si;
 169         PROCESS_INFORMATION pi;
 170         si.cb=sizeof(STARTUPINFO);
 171         GetStartupInfo(&si);
 172
 173         si.hStdError=hWrite;
 174         if(StdioFile)
 175                 si.hStdOutput=hStdioFile;
 176         else
 177                 si.hStdOutput=hWrite;
 178
 179         si.wShowWindow=SW_HIDE;
 180         si.dwFlags=STARTF_USESTDHANDLES|STARTF_USESHOWWINDOW;
 181
 182         LPTSTR pEnv = l_processEnv;
 183         DWORD dwFlags = pEnv ? CREATE_UNICODE_ENVIRONMENT : 0;
 184
 185         //DETACHED_PROCESS make ssh recognize that it has no console to launch askpass to input password.
 186         dwFlags |= DETACHED_PROCESS | CREATE_NEW_PROCESS_GROUP;
 187
 188         memset(&this->m_CurrentGitPi,0,sizeof(PROCESS_INFORMATION));
 189
 190         if(!CreateProcess(NULL,(LPWSTR)cmd.GetString(), NULL,NULL,TRUE,dwFlags,pEnv,(LPWSTR)m_CurrentDir.GetString(),&si,&pi))
 191         {
 192                 LPVOID lpMsgBuf;
 193                 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,
 194                         NULL,GetLastError(),MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
 195                         (LPTSTR)&lpMsgBuf,
 196                         0,NULL);
 197                 return GIT_ERROR_CREATE_PROCESS;
 198         }
 199
 200         m_CurrentGitPi = pi;
 201
 202         CloseHandle(hWrite);
 203         if(piOut)
 204                 *piOut=pi;
 205         if(hReadOut)
 206                 *hReadOut=hRead;
 207
 208         return 0;
 209
 210 }
 211 //Must use sperate function to convert ANSI str to union code string
 212 //Becuase A2W use stack as internal convert buffer.
 213 void CGit::StringAppend(CString *str,BYTE *p,int code,int length)
 214 {
 215      //USES_CONVERSION;
 216          //str->Append(A2W_CP((LPCSTR)p,code));
 217         if(str == NULL)
 218                 return ;
 219
 220         WCHAR * buf;
 221
 222         int len ;
 223         if(length<0)
 224                 len= strlen((const char*)p);
 225         else
 226                 len=length;
 227         //if (len==0)
 228         //      return ;
 229         //buf = new WCHAR[len*4 + 1];
 230         buf = str->GetBuffer(len*4+1+str->GetLength())+str->GetLength();
 231         SecureZeroMemory(buf, (len*4 + 1)*sizeof(WCHAR));
 232         MultiByteToWideChar(code, 0, (LPCSTR)p, len, buf, len*4);
 233         str->ReleaseBuffer();
 234         //str->Append(buf);
 235         //delete buf;
 236 }
 237 BOOL CGit::IsInitRepos()
 238 {
 239         CString cmdout;
 240         cmdout.Empty();
 241         if(g_Git.Run(_T("git.exe rev-parse --revs-only HEAD"),&cmdout,CP_UTF8))
 242         {
 243         //      CMessageBox::Show(NULL,cmdout,_T("TortoiseGit"),MB_OK);
 244                 return TRUE;
 245         }
 246         if(cmdout.IsEmpty())
 247                 return TRUE;
 248
 249         return FALSE;
 250 }
 251 int CGit::Run(CGitCall* pcall)
 252 {
 253         PROCESS_INFORMATION pi;
 254         HANDLE hRead;
 255         if(RunAsync(pcall->GetCmd(),&pi,&hRead))
 256                 return GIT_ERROR_CREATE_PROCESS;
 257
 258         DWORD readnumber;
 259         BYTE data[CALL_OUTPUT_READ_CHUNK_SIZE];
 260         bool bAborted=false;
 261         while(ReadFile(hRead,data,CALL_OUTPUT_READ_CHUNK_SIZE,&readnumber,NULL))
 262         {
 263                 //Todo: when OnOutputData() returns 'true', abort git-command. Send CTRL-C signal?
 264                 if(!bAborted)//For now, flush output when command aborted.
 265                         if(pcall->OnOutputData(data,readnumber))
 266                                 bAborted=true;
 267         }
 268         if(!bAborted)
 269                 pcall->OnEnd();
 270
 271
 272         CloseHandle(pi.hThread);
 273
 274         WaitForSingleObject(pi.hProcess, INFINITE);
 275         DWORD exitcode =0;
 276
 277         if(!GetExitCodeProcess(pi.hProcess,&exitcode))
 278         {
 279                 return GIT_ERROR_GET_EXIT_CODE;
 280         }
 281
 282         CloseHandle(pi.hProcess);
 283
 284         CloseHandle(hRead);
 285         return exitcode;
 286 }
 287 class CGitCall_ByteVector : public CGitCall
 288 {
 289 public:
 290         CGitCall_ByteVector(CString cmd,BYTE_VECTOR* pvector):CGitCall(cmd),m_pvector(pvector){}
 291         virtual bool OnOutputData(const BYTE* data, size_t size)
 292         {
 293                 size_t oldsize=m_pvector->size();
 294                 m_pvector->resize(m_pvector->size()+size);
 295                 memcpy(&*(m_pvector->begin()+oldsize),data,size);
 296                 return false;
 297         }
 298         BYTE_VECTOR* m_pvector;
 299
 300 };
 301 int CGit::Run(CString cmd,BYTE_VECTOR *vector)
 302 {
 303         CGitCall_ByteVector call(cmd,vector);
 304         return Run(&call);
 305 }
 306 int CGit::Run(CString cmd, CString* output,int code)
 307 {
 308         BYTE_VECTOR vector;
 309         int ret;
 310         ret=Run(cmd,&vector);
 311
 312         vector.push_back(0);
 313
 314         StringAppend(output,&(vector[0]),code);
 315         return ret;
 316 }
 317
 318 CString CGit::GetUserName(void)
 319 {
 320         return GetConfigValue(L"user.name");
 321 }
 322 CString CGit::GetUserEmail(void)
 323 {
 324         return GetConfigValue(L"user.email");
 325 }
 326
 327 CString CGit::GetConfigValue(CString name)
 328 {
 329         CString configValue;
 330         CString cmd;
 331         cmd.Format(L"git.exe config %s", name);
 332         Run(cmd,&configValue,CP_UTF8);
 333         int start = 0;
 334         return configValue.Tokenize(_T("\n"),start);
 335 }
 336
 337
 338 CString CGit::GetCurrentBranch(void)
 339 {
 340         CString output;
 341         //Run(_T("git.exe branch"),&branch);
 342
 343         int ret=g_Git.Run(_T("git.exe branch --no-color"),&output,CP_UTF8);
 344         if(!ret)
 345         {
 346                 int pos=0;
 347                 CString one;
 348                 while( pos>=0 )
 349                 {
 350                         //i++;
 351                         one=output.Tokenize(_T("\n"),pos);
 352                         //list.push_back(one.Right(one.GetLength()-2));
 353                         if(one[0] == _T('*'))
 354                                 return one.Right(one.GetLength()-2);
 355                 }
 356         }
 357         return CString("");
 358 }
 359
 360 CString CGit::GetSymbolicRef(const wchar_t* symbolicRefName, bool bStripRefsHeads)
 361 {
 362         CString refName;
 363         CString cmd;
 364         cmd.Format(L"git symbolic-ref %s", symbolicRefName);
 365         if(Run(cmd, &refName, CP_UTF8) != 0)
 366                 return CString();//Error
 367         int iStart = 0;
 368         refName = refName.Tokenize(L"\n", iStart);
 369         if(bStripRefsHeads)
 370                 refName = StripRefName(refName);
 371         return refName;
 372 }
 373
 374 CString CGit::GetFullRefName(CString shortRefName)
 375 {
 376         CString refName;
 377         CString cmd;
 378         cmd.Format(L"git rev-parse --symbolic-full-name %s", shortRefName);
 379         if(Run(cmd, &refName, CP_UTF8) != 0)
 380                 return CString();//Error
 381         int iStart = 0;
 382         return refName.Tokenize(L"\n", iStart);
 383 }
 384
 385 CString CGit::StripRefName(CString refName)
 386 {
 387         if(wcsncmp(refName, L"refs/heads/", 11) == 0)
 388                 refName = refName.Mid(11);
 389         else if(wcsncmp(refName, L"refs/", 5) == 0)
 390                 refName = refName.Mid(5);
 391         return refName;
 392 }
 393
 394 int CGit::GetCurrentBranchFromFile(const CString &sProjectRoot, CString &sBranchOut)
 395 {
 396         // read current branch name like git-gui does, by parsing the .git/HEAD file directly
 397
 398         if ( sProjectRoot.IsEmpty() )
 399                 return -1;
 400
 401         CString sHeadFile = sProjectRoot + _T("\\") + g_GitAdminDir.GetAdminDirName() + _T("\\HEAD");
 402
 403         FILE *pFile;
 404         _tfopen_s(&pFile, sHeadFile.GetString(), _T("r"));
 405
 406         if (!pFile)
 407         {
 408                 return -1;
 409         }
 410
 411         char s[256] = {0};
 412     fgets(s, sizeof(s), pFile);
 413
 414         fclose(pFile);
 415
 416         const char *pfx = "ref: refs/heads/";
 417         const int len = 16;//strlen(pfx)
 418
 419         if ( !strncmp(s, pfx, len) )
 420         {
 421                 //# We're on a branch.  It might not exist.  But
 422                 //# HEAD looks good enough to be a branch.
 423                 sBranchOut = s + len;
 424                 sBranchOut.TrimRight(_T(" \r\n\t"));
 425
 426                 if ( sBranchOut.IsEmpty() )
 427                         return -1;
 428         }
 429         else
 430         {
 431                 //# Assume this is a detached head.
 432                 sBranchOut = "HEAD";
 433
 434                 return 1;
 435         }
 436
 437         return 0;
 438 }
 439
 440 int CGit::BuildOutputFormat(CString &format,bool IsFull)
 441 {
 442         CString log;
 443         log.Format(_T("#<%c>%%x00"),LOG_REV_ITEM_BEGIN);
 444         format += log;
 445         if(IsFull)
 446         {
 447                 log.Format(_T("#<%c>%%an%%x00"),LOG_REV_AUTHOR_NAME);
 448                 format += log;
 449                 log.Format(_T("#<%c>%%ae%%x00"),LOG_REV_AUTHOR_EMAIL);
 450                 format += log;
 451                 log.Format(_T("#<%c>%%ai%%x00"),LOG_REV_AUTHOR_DATE);
 452                 format += log;
 453                 log.Format(_T("#<%c>%%cn%%x00"),LOG_REV_COMMIT_NAME);
 454                 format += log;
 455                 log.Format(_T("#<%c>%%ce%%x00"),LOG_REV_COMMIT_EMAIL);
 456                 format += log;
 457                 log.Format(_T("#<%c>%%ci%%x00"),LOG_REV_COMMIT_DATE);
 458                 format += log;
 459                 log.Format(_T("#<%c>%%b%%x00"),LOG_REV_COMMIT_BODY);
 460                 format += log;
 461         }
 462
 463         log.Format(_T("#<%c>%%m%%H%%x00"),LOG_REV_COMMIT_HASH);
 464         format += log;
 465         log.Format(_T("#<%c>%%P%%x00"),LOG_REV_COMMIT_PARENT);
 466         format += log;
 467         log.Format(_T("#<%c>%%s%%x00"),LOG_REV_COMMIT_SUBJECT);
 468         format += log;
 469
 470         if(IsFull)
 471         {
 472                 log.Format(_T("#<%c>%%x00"),LOG_REV_COMMIT_FILE);
 473                 format += log;
 474         }
 475         return 0;
 476 }
 477
 478 int CGit::GetLog(BYTE_VECTOR& logOut, CString &hash,  CTGitPath *path ,int count,int mask,CString *from,CString *to)
 479 {
 480         CGitCall_ByteVector gitCall(CString(),&logOut);
 481         return GetLog(&gitCall,hash,path,count,mask,from,to);
 482 }
 483
 484 CString CGit::GetLogCmd( CString &hash, CTGitPath *path, int count, int mask,CString *from,CString *to,bool paramonly)
 485 {
 486         CString cmd;
 487         CString log;
 488         CString num;
 489         CString since;
 490
 491         CString file;
 492
 493         if(path)
 494                 file.Format(_T(" -- \"%s\""),path->GetGitPathString());
 495
 496         if(count>0)
 497                 num.Format(_T("-n%d"),count);
 498
 499         CString param;
 500
 501         if(mask& LOG_INFO_STAT )
 502                 param += _T(" --numstat ");
 503         if(mask& LOG_INFO_FILESTATE)
 504                 param += _T(" --raw ");
 505
 506         if(mask& LOG_INFO_FULLHISTORY)
 507                 param += _T(" --full-history ");
 508
 509         if(mask& LOG_INFO_BOUNDARY)
 510                 param += _T(" --left-right --boundary ");
 511
 512         if(mask& CGit::LOG_INFO_ALL_BRANCH)
 513                 param += _T(" --all ");
 514
 515         if(mask& CGit::LOG_INFO_DETECT_COPYRENAME)
 516                 param += _T(" -C ");
 517
 518         if(mask& CGit::LOG_INFO_DETECT_RENAME )
 519                 param += _T(" -M ");
 520
 521         if(mask& CGit::LOG_INFO_FIRST_PARENT )
 522                 param += _T(" --first-parent ");
 523
 524         if(mask& CGit::LOG_INFO_NO_MERGE )
 525                 param += _T(" --no-merges ");
 526
 527         if(mask& CGit::LOG_INFO_FOLLOW)
 528                 param += _T(" --follow ");
 529
 530         if(mask& CGit::LOG_INFO_SHOW_MERGEDFILE)
 531                 param += _T(" -c ");
 532
 533         if(mask& CGit::LOG_INFO_FULL_DIFF)
 534                 param += _T(" --full-diff ");
 535
 536         if(from != NULL && to != NULL)
 537         {
 538                 CString range;
 539                 range.Format(_T(" %s..%s "),*from,*to);
 540                 param += range;
 541         }
 542         param+=hash;
 543
 544         if(paramonly)
 545                 cmd.Format(_T("%s -z --topo-order %s --parents "),
 546                                 num,param);
 547         else
 548                 cmd.Format(_T("git.exe log %s -z --topo-order %s --parents --pretty=format:\""),
 549                                 num,param);
 550
 551         BuildOutputFormat(log,!(mask&CGit::LOG_INFO_ONLY_HASH));
 552
 553         if(paramonly)
 554         {
 555                 cmd += _T("-- ")+file;
 556         }else
 557         {
 558                 cmd += log;
 559                 cmd += CString(_T("\"  -- "))+file;
 560         }
 561
 562         return cmd;
 563 }
 564 //int CGit::GetLog(CGitCall* pgitCall, CString &hash,  CTGitPath *path ,int count,int mask)
 565 int CGit::GetLog(CGitCall* pgitCall, CString &hash, CTGitPath *path, int count, int mask,CString *from,CString *to)
 566 {
 567         pgitCall->SetCmd( GetLogCmd(hash,path,count,mask,from,to) );
 568
 569         return Run(pgitCall);
 570 //      return Run(cmd,&logOut);
 571 }
 572
 573 #define BUFSIZE 512
 574 void GetTempPath(CString &path)
 575 {
 576         TCHAR lpPathBuffer[BUFSIZE];
 577         DWORD dwRetVal;
 578         DWORD dwBufSize=BUFSIZE;
 579         dwRetVal = GetTempPath(dwBufSize,     // length of the buffer
 580                            lpPathBuffer); // buffer for path
 581     if (dwRetVal > dwBufSize || (dwRetVal == 0))
 582     {
 583         path=_T("");
 584     }
 585         path.Format(_T("%s"),lpPathBuffer);
 586 }
 587 CString GetTempFile()
 588 {
 589         TCHAR lpPathBuffer[BUFSIZE];
 590         DWORD dwRetVal;
 591     DWORD dwBufSize=BUFSIZE;
 592         TCHAR szTempName[BUFSIZE];
 593         UINT uRetVal;
 594
 595         dwRetVal = GetTempPath(dwBufSize,     // length of the buffer
 596                            lpPathBuffer); // buffer for path
 597     if (dwRetVal > dwBufSize || (dwRetVal == 0))
 598     {
 599         return _T("");
 600     }
 601          // Create a temporary file.
 602     uRetVal = GetTempFileName(lpPathBuffer, // directory for tmp files
 603                               TEXT("Patch"),  // temp file name prefix
 604                               0,            // create unique name
 605                               szTempName);  // buffer for name
 606
 607
 608     if (uRetVal == 0)
 609     {
 610         return _T("");
 611     }
 612
 613         return CString(szTempName);
 614
 615 }
 616
 617 int CGit::RunLogFile(CString cmd,CString &filename)
 618 {
 619         STARTUPINFO si;
 620         PROCESS_INFORMATION pi;
 621         si.cb=sizeof(STARTUPINFO);
 622         GetStartupInfo(&si);
 623
 624         SECURITY_ATTRIBUTES   psa={sizeof(psa),NULL,TRUE};;
 625         psa.bInheritHandle=TRUE;
 626
 627         HANDLE   houtfile=CreateFile(filename,GENERIC_WRITE,FILE_SHARE_READ   |   FILE_SHARE_WRITE,
 628                         &psa,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
 629
 630
 631         si.wShowWindow=SW_HIDE;
 632         si.dwFlags=STARTF_USESTDHANDLES|STARTF_USESHOWWINDOW;
 633         si.hStdOutput   =   houtfile;
 634
 635         if(!CreateProcess(NULL,(LPWSTR)cmd.GetString(), NULL,NULL,TRUE,NULL,NULL,(LPWSTR)m_CurrentDir.GetString(),&si,&pi))
 636         {
 637                 LPVOID lpMsgBuf;
 638                 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,
 639                         NULL,GetLastError(),MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
 640                         (LPTSTR)&lpMsgBuf,
 641                         0,NULL);
 642                 return GIT_ERROR_CREATE_PROCESS;
 643         }
 644
 645         WaitForSingleObject(pi.hProcess,INFINITE);
 646
 647         CloseHandle(pi.hThread);
 648         CloseHandle(pi.hProcess);
 649         CloseHandle(houtfile);
 650         return GIT_SUCCESS;
 651 //      return 0;
 652 }
 653
 654 git_revnum_t CGit::GetHash(const CString &friendname)
 655 {
 656         CString cmd;
 657         CString out;
 658         cmd.Format(_T("git.exe rev-parse %s" ),friendname);
 659         Run(cmd,&out,CP_UTF8);
 660 //      int pos=out.ReverseFind(_T('\n'));
 661         int pos=out.FindOneOf(_T("\r\n"));
 662         if(pos>0)
 663                 return out.Left(pos);
 664         return out;
 665 }
 666
 667 int CGit::GetInitAddList(CTGitPathList &outputlist)
 668 {
 669         CString cmd;
 670         BYTE_VECTOR cmdout;
 671
 672         cmd=_T("git.exe ls-files -s -t -z");
 673         outputlist.Clear();
 674         if(g_Git.Run(cmd,&cmdout))
 675                 return -1;
 676
 677         outputlist.ParserFromLsFile(cmdout);
 678         for(int i=0;i<outputlist.GetCount();i++)
 679                 ((int)outputlist[i].m_Action) = CTGitPath::LOGACTIONS_ADDED;
 680
 681         return 0;
 682 }
 683 int CGit::GetCommitDiffList(CString &rev1,CString &rev2,CTGitPathList &outputlist)
 684 {
 685         CString cmd;
 686
 687         if(rev1 == GIT_REV_ZERO || rev2 == GIT_REV_ZERO)
 688         {
 689                 //rev1=+_T("");
 690                 if(rev1 == GIT_REV_ZERO)
 691                         cmd.Format(_T("git.exe diff -r --raw -C -M --numstat -z %s"),rev2);
 692                 else
 693                         cmd.Format(_T("git.exe diff -r -R --raw -C -M --numstat -z %s"),rev1);
 694         }else
 695         {
 696                 cmd.Format(_T("git.exe diff-tree -r --raw -C -M --numstat -z %s %s"),rev2,rev1);
 697         }
 698
 699         BYTE_VECTOR out;
 700         if(g_Git.Run(cmd,&out))
 701                 return -1;
 702
 703         outputlist.ParserFromLog(out);
 704
 705 }
 706
 707 int CGit::GetTagList(STRING_VECTOR &list)
 708 {
 709         int ret;
 710         CString cmd,output;
 711         cmd=_T("git.exe tag -l");
 712         int i=0;
 713         ret=g_Git.Run(cmd,&output,CP_UTF8);
 714         if(!ret)
 715         {
 716                 int pos=0;
 717                 CString one;
 718                 while( pos>=0 )
 719                 {
 720                         i++;
 721                         one=output.Tokenize(_T("\n"),pos);
 722                         list.push_back(one);
 723                 }
 724         }
 725         return ret;
 726 }
 727
 728 int CGit::GetBranchList(STRING_VECTOR &list,int *current,BRANCH_TYPE type)
 729 {
 730         int ret;
 731         CString cmd,output;
 732         cmd=_T("git.exe branch --no-color");
 733
 734         if(type==(BRANCH_LOCAL|BRANCH_REMOTE))
 735                 cmd+=_T(" -a");
 736         else if(type==BRANCH_REMOTE)
 737                 cmd+=_T(" -r");
 738
 739         int i=0;
 740         ret=g_Git.Run(cmd,&output,CP_UTF8);
 741         if(!ret)
 742         {
 743                 int pos=0;
 744                 CString one;
 745                 while( pos>=0 )
 746                 {
 747                         one=output.Tokenize(_T("\n"),pos);
 748                         one.Trim(L" \r\n\t");
 749                         if(one.Find(L" -> ") >= 0 || one.IsEmpty())
 750                                 continue; // skip something like: refs/origin/HEAD -> refs/origin/master
 751                         if(one[0] == _T('*'))
 752                         {
 753                                 if(current)
 754                                         *current=i;
 755                                 one = one.Mid(2);
 756                         }
 757                         list.push_back(one);
 758                         i++;
 759                 }
 760         }
 761         return ret;
 762 }
 763
 764 int CGit::GetRemoteList(STRING_VECTOR &list)
 765 {
 766         int ret;
 767         CString cmd,output;
 768         cmd=_T("git.exe config  --get-regexp \"^^remote[.].*[.]url\"");
 769         ret=g_Git.Run(cmd,&output,CP_UTF8);
 770         if(!ret)
 771         {
 772                 int pos=0;
 773                 CString one;
 774                 while( pos>=0 )
 775                 {
 776                         one=output.Tokenize(_T("\n"),pos);
 777                         int start=one.Find(_T("."),0);
 778                         if(start>0)
 779                         {
 780                                 CString url;
 781                                 url=one.Right(one.GetLength()-start-1);
 782                                 one=url;
 783                                 one=one.Left(one.Find(_T("."),0));
 784                                 list.push_back(one);
 785                         }
 786                 }
 787         }
 788         return ret;
 789 }
 790
 791 int CGit::GetRefList(STRING_VECTOR &list)
 792 {
 793         int ret;
 794         CString cmd,output;
 795         cmd=_T("git show-ref -d");
 796         ret=g_Git.Run(cmd,&output,CP_UTF8);
 797         if(!ret)
 798         {
 799                 int pos=0;
 800                 CString one;
 801                 while( pos>=0 )
 802                 {
 803                         one=output.Tokenize(_T("\n"),pos);
 804                         int start=one.Find(_T(" "),0);
 805                         if(start>0)
 806                         {
 807                                 CString name;
 808                                 name=one.Right(one.GetLength()-start-1);
 809                                 list.push_back(name);
 810                         }
 811                 }
 812         }
 813         return ret;
 814 }
 815 int CGit::GetMapHashToFriendName(MAP_HASH_NAME &map)
 816 {
 817         int ret;
 818         CString cmd,output;
 819         cmd=_T("git show-ref -d");
 820         ret=g_Git.Run(cmd,&output,CP_UTF8);
 821         if(!ret)
 822         {
 823                 int pos=0;
 824                 CString one;
 825                 while( pos>=0 )
 826                 {
 827                         one=output.Tokenize(_T("\n"),pos);
 828                         int start=one.Find(_T(" "),0);
 829                         if(start>0)
 830                         {
 831                                 CString name;
 832                                 name=one.Right(one.GetLength()-start-1);
 833
 834                                 CString hash;
 835                                 hash=one.Left(start);
 836
 837                                 map[hash].push_back(name);
 838                         }
 839                 }
 840         }
 841         return ret;
 842 }
 843
 844 BOOL CGit::CheckMsysGitDir()
 845 {
 846         static BOOL bInitialized = FALSE;
 847
 848         if (bInitialized)
 849         {
 850                 return TRUE;
 851         }
 852
 853         TCHAR *oldpath,*home;
 854         size_t homesize,size,httpsize;
 855
 856         // set HOME if not set already
 857         _tgetenv_s(&homesize, NULL, 0, _T("HOME"));
 858         if (!homesize)
 859         {
 860                 _tdupenv_s(&home,&size,_T("USERPROFILE"));
 861                 _tputenv_s(_T("HOME"),home);
 862                 free(home);
 863         }
 864         CString str;
 865
 866 #ifndef _TORTOISESHELL
 867         //set http_proxy
 868         _tgetenv_s(&httpsize, NULL, 0, _T("http_proxy"));
 869         if (!httpsize)
 870         {
 871                 CString regServeraddress_copy = CRegString(_T("Software\\TortoiseGit\\Servers\\global\\http-proxy-host"), _T(""));
 872                 CString regServerport_copy = CRegString(_T("Software\\TortoiseGit\\Servers\\global\\http-proxy-port"), _T(""));
 873                 CString regUsername_copy = CRegString(_T("Software\\TortoiseGit\\Servers\\global\\http-proxy-username"), _T(""));
 874                 CString regPassword_copy = CRegString(_T("Software\\TortoiseGit\\Servers\\global\\http-proxy-password"), _T(""));
 875                 CString regTimeout_copy = CRegString(_T("Software\\TortoiseGit\\Servers\\global\\http-proxy-timeout"), _T(""));
 876                 CString regExceptions_copy = CRegString(_T("Software\\TortoiseGit\\Servers\\global\\http-proxy-exceptions"), _T(""));
 877
 878                 CString http_proxy;
 879                 if(!regServeraddress_copy.IsEmpty())
 880                 {
 881                         if(regServeraddress_copy.Left(4) != _T("http"))
 882                                 http_proxy=_T("http://");
 883
 884                         if(!regUsername_copy.IsEmpty())
 885                         {
 886                                 http_proxy += regUsername_copy;
 887                                 http_proxy += _T(":")+regPassword_copy;
 888                                 http_proxy += _T("@");
 889                         }
 890                         http_proxy+=regServeraddress_copy;
 891                         if(!regServerport_copy.IsEmpty())
 892                         {
 893                                 http_proxy +=_T(":")+regServerport_copy;
 894                         }
 895                         _tputenv_s(_T("http_proxy"),http_proxy);
 896                 }
 897         }
 898         //setup ssh client
 899         CString sshclient=CRegString(_T("Software\\TortoiseGit\\SSH"));
 900
 901         if(!sshclient.IsEmpty())
 902         {
 903                 _tputenv_s(_T("GIT_SSH"),sshclient);
 904
 905                 //Setup SVN_SSH
 906                 CString ssh=sshclient;
 907                 ssh.Replace(_T("/"),_T("\\"));
 908                 ssh.Replace(_T("\\"),_T("\\\\"));
 909                 ssh=CString(_T("\""))+ssh+_T('\"');
 910                 _tputenv_s(_T("SVN_SSH"),ssh);
 911
 912         }else
 913         {
 914                 TCHAR sPlink[MAX_PATH];
 915                 GetModuleFileName(NULL, sPlink, _countof(sPlink));
 916                 LPTSTR ptr = _tcsrchr(sPlink, _T('\\'));
 917                 if (ptr) {
 918                         _tcscpy(ptr + 1, _T("TortoisePlink.exe"));
 919                         _tputenv_s(_T("GIT_SSH"), sPlink);
 920
 921                         //Setup SVN_SSH
 922                         CString ssh=sPlink;
 923                         ssh.Replace(_T("/"),_T("\\"));
 924                         ssh.Replace(_T("\\"),_T("\\\\"));
 925                         ssh=CString(_T("\""))+ssh+_T('\"');
 926                         _tputenv_s(_T("SVN_SSH"),ssh);
 927                 }
 928         }
 929
 930         {
 931                 TCHAR sAskPass[MAX_PATH];
 932                 GetModuleFileName(NULL, sAskPass, _countof(sAskPass));
 933                 LPTSTR ptr = _tcsrchr(sAskPass, _T('\\'));
 934                 if (ptr)
 935                 {
 936                         _tcscpy(ptr + 1, _T("SshAskPass.exe"));
 937                         _tputenv_s(_T("DISPLAY"),_T(":9999"));
 938                         _tputenv_s(_T("SSH_ASKPASS"),sAskPass);
 939                 }
 940         }
 941         // search PATH if git/bin directory is alredy present
 942         if ( FindGitPath() )
 943         {
 944                 bInitialized = TRUE;
 945                 return TRUE;
 946         }
 947
 948         // add git/bin path to PATH
 949
 950         CRegString msysdir=CRegString(REG_MSYSGIT_PATH,_T(""),FALSE);
 951         str=msysdir;
 952         if(str.IsEmpty())
 953         {
 954                 CRegString msysinstalldir=CRegString(REG_MSYSGIT_INSTALL,_T(""),FALSE,HKEY_LOCAL_MACHINE);
 955                 str=msysinstalldir;
 956                 if ( !str.IsEmpty() )
 957                 {
 958                         str += (str[str.GetLength()-1] != '\\') ? "\\bin" : "bin";
 959                         msysdir=str;
 960                         msysdir.write();
 961                 }
 962                 else
 963                 {
 964                         return false;
 965                 }
 966         }
 967 #endif
 968         //CGit::m_MsysGitPath=str;
 969
 970         //set path
 971
 972         _tdupenv_s(&oldpath,&size,_T("PATH"));
 973
 974         CString path;
 975         path.Format(_T("%s;%s"),oldpath,str);
 976
 977         _tputenv_s(_T("PATH"),path);
 978
 979         CString sOldPath = oldpath;
 980         free(oldpath);
 981
 982
 983     if( !FindGitPath() )
 984         {
 985                 if(!homesize)
 986                 {
 987                         _tputenv_s(_T("HOME"),_T(""));
 988                 }
 989                 return false;
 990         }
 991         else
 992         {
 993 #ifdef _TORTOISESHELL
 994                 l_processEnv = GetEnvironmentStrings();
 995                 // updated environment is now duplicated for use in CreateProcess, restore original PATH for current process
 996                 _tputenv_s(_T("PATH"),sOldPath);
 997                 if(!homesize)
 998                 {
 999                         _tputenv_s(_T("HOME"),_T(""));
1000                 }
1001 #endif
1002
1003                 bInitialized = TRUE;
1004                 return true;
1005         }
1006 }
1007
1008
1009 class CGitCall_EnumFiles : public CGitCall
1010 {
1011 public:
1012         CGitCall_EnumFiles(const TCHAR *pszProjectPath, const TCHAR *pszSubPath, unsigned int nFlags, WGENUMFILECB *pEnumCb, void *pUserData)
1013         :       m_pszProjectPath(pszProjectPath),
1014                 m_pszSubPath(pszSubPath),
1015                 m_nFlags(nFlags),
1016                 m_pEnumCb(pEnumCb),
1017                 m_pUserData(pUserData)
1018         {
1019         }
1020
1021         typedef std::map<CStringA,char> TStrCharMap;
1022
1023         const TCHAR *   m_pszProjectPath;
1024         const TCHAR *   m_pszSubPath;
1025         unsigned int    m_nFlags;
1026         WGENUMFILECB *  m_pEnumCb;
1027         void *                  m_pUserData;
1028
1029         BYTE_VECTOR             m_DataCollector;
1030
1031         virtual bool    OnOutputData(const BYTE* data, size_t size)
1032         {
1033                 m_DataCollector.append(data,size);
1034                 while(true)
1035                 {
1036                         // lines from igit.exe are 0 terminated
1037                         int found=m_DataCollector.findData((const BYTE*)"",1);
1038                         if(found<0)
1039                                 return false;
1040                         OnSingleLine( (LPCSTR)&*m_DataCollector.begin() );
1041                         m_DataCollector.erase(m_DataCollector.begin(), m_DataCollector.begin()+found+1);
1042                 }
1043                 return false;//Should never reach this
1044         }
1045         virtual void    OnEnd()
1046         {
1047         }
1048
1049         BYTE HexChar(char ch)
1050         {
1051                 if (ch >= '0' && ch <= '9')
1052                         return (UINT)(ch - '0');
1053                 else if (ch >= 'A' && ch <= 'F')
1054                         return (UINT)(ch - 'A') + 10;
1055                 else if (ch >= 'a' && ch <= 'f')
1056                         return (UINT)(ch - 'a') + 10;
1057                 else
1058                         return 0;
1059         }
1060
1061         bool OnSingleLine(LPCSTR line)
1062         {
1063                 //Parse single line
1064
1065                 wgFile_s fileStatus;
1066
1067                 // file/dir type
1068
1069                 fileStatus.nFlags = 0;
1070                 if (*line == 'D')
1071                         fileStatus.nFlags |= WGFF_Directory;
1072                 else if (*line != 'F')
1073                         // parse error
1074                         return false;
1075                 line += 2;
1076
1077                 // status
1078
1079                 fileStatus.nStatus = WGFS_Unknown;
1080                 switch (*line)
1081                 {
1082                 case 'N': fileStatus.nStatus = WGFS_Normal; break;
1083                 case 'M': fileStatus.nStatus = WGFS_Modified; break;
1084                 case 'S': fileStatus.nStatus = WGFS_Staged; break;
1085                 case 'A': fileStatus.nStatus = WGFS_Added; break;
1086                 case 'C': fileStatus.nStatus = WGFS_Conflicted; break;
1087                 case 'D': fileStatus.nStatus = WGFS_Deleted; break;
1088                 case 'I': fileStatus.nStatus = WGFS_Ignored; break;
1089                 case 'U': fileStatus.nStatus = WGFS_Unversioned; break;
1090                 case 'E': fileStatus.nStatus = WGFS_Empty; break;
1091                 case '?': fileStatus.nStatus = WGFS_Unknown; break;
1092                 default:
1093                         // parse error
1094                         return false;
1095                 }
1096                 line += 2;
1097
1098                 // file sha1
1099
1100                 BYTE sha1[20];
1101                 fileStatus.sha1 = NULL;
1102                 if ( !(fileStatus.nFlags & WGFF_Directory) )
1103                 {
1104                         for (int i=0; i<20; i++)
1105                         {
1106                                 sha1[i]  = (HexChar(line[0])<<4)&0xF0;
1107                                 sha1[i] |= HexChar(line[1])&0xF;
1108
1109                                 line += 2;
1110                         }
1111
1112                         line++;
1113                 }
1114
1115                 // filename
1116                 int len = strlen(line);
1117                 if (len && len < 2048)
1118                 {
1119                         WCHAR *buf = (WCHAR*)alloca((len*4+2)*sizeof(WCHAR));
1120                         *buf = 0;
1121                         MultiByteToWideChar(CP_ACP, 0, line, len+1, buf, len*4+1);
1122                         fileStatus.sFileName = buf;
1123
1124                         if (*buf && (*m_pEnumCb)(&fileStatus,m_pUserData))
1125                                 return false;
1126                 }
1127
1128                 return true;
1129         }
1130 };
1131
1132 BOOL CGit::EnumFiles(const TCHAR *pszProjectPath, const TCHAR *pszSubPath, unsigned int nFlags, WGENUMFILECB *pEnumCb, void *pUserData)
1133 {
1134         if(!pszProjectPath || *pszProjectPath=='\0')
1135                 return FALSE;
1136
1137         CGitCall_EnumFiles W_GitCall(pszProjectPath,pszSubPath,nFlags,pEnumCb,pUserData);
1138         CString cmd;
1139
1140 /*      char W_szToDir[MAX_PATH];
1141         strncpy(W_szToDir,pszProjectPath,sizeof(W_szToDir)-1);
1142         if(W_szToDir[strlen(W_szToDir)-1]!='\\')
1143                 strncat(W_szToDir,"\\",sizeof(W_szToDir)-1);
1144
1145         SetCurrentDirectoryA(W_szToDir);
1146         GetCurrentDirectoryA(sizeof(W_szToDir)-1,W_szToDir);
1147 */
1148         SetCurrentDir(pszProjectPath);
1149
1150         CString sMode;
1151         if (nFlags)
1152         {
1153                 if (nFlags & WGEFF_NoRecurse) sMode += _T("r");
1154                 if (nFlags & WGEFF_FullPath) sMode += _T("f");
1155                 if (nFlags & WGEFF_DirStatusDelta) sMode += _T("d");
1156                 if (nFlags & WGEFF_DirStatusAll) sMode += _T("D");
1157                 if (nFlags & WGEFF_EmptyAsNormal) sMode += _T("e");
1158                 if (nFlags & WGEFF_SingleFile) sMode += _T("s");
1159         }
1160         else
1161         {
1162                 sMode = _T("-");
1163         }
1164
1165         // NOTE: there seems to be some issue with msys based app receiving backslash on commandline, at least
1166         // if followed by " like for example 'igit "C:\"', the commandline igit receives is 'igit.exe C:" status' with
1167         // the 'C:" status' part as a single arg, Maybe it uses unix style processing. In order to avoid this just
1168         // use forward slashes for supplied project and sub paths
1169
1170         CString sProjectPath = pszProjectPath;
1171         sProjectPath.Replace(_T('\\'), _T('/'));
1172
1173         if (pszSubPath)
1174         {
1175                 CString sSubPath = pszSubPath;
1176                 sSubPath.Replace(_T('\\'), _T('/'));
1177
1178                 cmd.Format(_T("tgit.exe statusex \"%s\" status %s \"%s\""), sProjectPath, sMode, sSubPath);
1179         }
1180         else
1181         {
1182                 cmd.Format(_T("tgit.exe statusex \"%s\" status %s"), sProjectPath, sMode);
1183         }
1184
1185         //OutputDebugStringA("---");OutputDebugStringW(cmd);OutputDebugStringA("\r\n");
1186
1187         W_GitCall.SetCmd(cmd);
1188         // NOTE: should igit get added as a part of msysgit then use below line instead of the above one
1189         //W_GitCall.SetCmd(CGit::ms_LastMsysGitDir + cmd);
1190
1191         if ( Run(&W_GitCall) )
1192                 return FALSE;
1193
1194         return TRUE;
1195 }
1196
1197 BOOL CGit::CheckCleanWorkTree()
1198 {
1199         CString out;
1200         CString cmd;
1201         cmd=_T("git.exe rev-parse --verify HEAD");
1202
1203         if(g_Git.Run(cmd,&out,CP_UTF8))
1204                 return FALSE;
1205
1206         cmd=_T("git.exe update-index --ignore-submodules --refresh");
1207         if(g_Git.Run(cmd,&out,CP_UTF8))
1208                 return FALSE;
1209
1210         cmd=_T("git.exe diff-files --quiet --ignore-submodules");
1211         if(g_Git.Run(cmd,&out,CP_UTF8))
1212                 return FALSE;
1213
1214         cmd=_T("git diff-index --cached --quiet HEAD --ignore-submodules");
1215         if(g_Git.Run(cmd,&out,CP_UTF8))
1216                 return FALSE;
1217
1218         return TRUE;
1219 }
1220 int CGit::Revert(CTGitPathList &list,bool keep)
1221 {
1222         int ret;
1223         for(int i=0;i<list.GetCount();i++)
1224         {
1225                 ret = Revert((CTGitPath&)list[i],keep);
1226                 if(ret)
1227                         return ret;
1228         }
1229         return 0;
1230 }
1231 int CGit::Revert(CTGitPath &path,bool keep)
1232 {
1233         CString cmd, out;
1234         if(path.m_Action & CTGitPath::LOGACTIONS_ADDED)
1235         {       //To init git repository, there are not HEAD, so we can use git reset command
1236                 cmd.Format(_T("git.exe rm --cached -- \"%s\""),path.GetGitPathString());
1237
1238                 if(g_Git.Run(cmd,&out,CP_ACP))
1239                         return -1;
1240         }
1241         else if(path.m_Action & CTGitPath::LOGACTIONS_REPLACED )
1242         {
1243                 cmd.Format(_T("git.exe mv -- \"%s\" \"%s\""),path.GetGitPathString(),path.GetGitOldPathString());
1244                 if(g_Git.Run(cmd,&out,CP_ACP))
1245                         return -1;
1246
1247                 cmd.Format(_T("git.exe checkout HEAD -f -- \"%s\""),path.GetGitOldPathString());
1248                 if(g_Git.Run(cmd,&out,CP_ACP))
1249                         return -1;
1250         }
1251         else
1252         {
1253                 cmd.Format(_T("git.exe checkout HEAD -f -- \"%s\""),path.GetGitPathString());
1254                 if(g_Git.Run(cmd,&out,CP_ACP))
1255                         return -1;
1256         }
1257         return 0;
1258 }
1259
1260 int CGit::ListConflictFile(CTGitPathList &list,CTGitPath *path)
1261 {
1262         BYTE_VECTOR vector;
1263
1264         CString cmd;
1265         if(path)
1266                 cmd.Format(_T("git.exe ls-files -u -t -z -- \"%s\""),path->GetGitPathString());
1267         else
1268                 cmd=_T("git.exe ls-files -u -t -z");
1269
1270         if(g_Git.Run(cmd,&vector))
1271         {
1272                 return -1;
1273         }
1274
1275         list.ParserFromLsFile(vector);
1276
1277         return 0;
1278 }
1279
1280 bool CGit::IsFastForward(CString &from, CString &to)
1281 {
1282         CString base,hash;
1283         CString cmd;
1284         cmd.Format(_T("git.exe merge-base %s %s"), to,from);
1285
1286         if(g_Git.Run(cmd,&base,CP_ACP))
1287         {
1288                 //CMessageBox::Show(NULL,base,_T("TortoiseGit"),MB_OK|MB_ICONERROR);
1289                 return false;
1290         }
1291         base=base.Left(40);
1292
1293         hash=g_Git.GetHash(from);
1294
1295         hash=hash.Left(40);
1296
1297         return hash == base;
1298 }
1299
1300 unsigned int CGit::Hash2int(CString &hash)
1301 {
1302         int ret=0;
1303         for(int i=0;i<8;i++)
1304         {
1305                 ret =ret <<4;
1306                 if(hash[i]>=_T('a'))
1307                         ret |= (hash[i]-_T('a')+10)&0xFF;
1308                 else if(hash[i]>=_T('A'))
1309                         ret |= (hash[i]-_T('A')+10)&0xFF;
1310                 else
1311                         ret |= (hash[i]-_T('0'))&0xFF;
1312
1313         }
1314         return ret;
1315 }
1316
1317 int CGit::RefreshGitIndex()
1318 {
1319         CString cmd,output;
1320         cmd=_T("git.exe update-index --refresh");
1321         return Run(cmd,&output,CP_ACP);
1322 }
1323