src/Git/Git.cpp

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