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