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