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