src/Git/Git.cpp

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