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