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                         return TRUE;\r
 103                 }\r
 104         }\r
 105 \r
 106         return FALSE;\r
 107 }\r
 108 \r
 109 \r
 110 #define MAX_DIRBUFFER 1000\r
 111 #define CALL_OUTPUT_READ_CHUNK_SIZE 1024\r
 112 \r
 113 CString CGit::ms_LastMsysGitDir;\r
 114 CGit g_Git;\r
 115 BOOL g_IsWingitDllload = TRUE;\r
 116 \r
 117 LPBYTE wgGetRevisionID_safe(const char *pszProjectPath, const char *pszName)\r
 118 {\r
 119         //if(g_IsWingitDllload)\r
 120         //      return wgGetRevisionID(pszProjectPath,pszName);\r
 121         //else\r
 122         return NULL;\r
 123 }\r
 124 \r
 125 BOOL wgEnumFiles_safe(const char *pszProjectPath, const char *pszSubPath, unsigned int nFlags, WGENUMFILECB *pEnumCb, void *pUserData)\r
 126 {\r
 127         //if(g_IsWingitDllload)\r
 128         //      return wgEnumFiles(pszProjectPath,pszSubPath,nFlags,pEnumCb,pUserData);\r
 129         //else\r
 130         //      return g_Git.EnumFiles(pszProjectPath,pszSubPath,nFlags,pEnumCb,pUserData);\r
 131         return FALSE;\r
 132 }\r
 133 \r
 134 BOOL CGit::IsVista()\r
 135 {\r
 136 \r
 137         if( CRegStdWORD(_T("Software\\TortoiseGit\\CacheType") ) == 0)\r
 138         {\r
 139                 g_IsWingitDllload=FALSE;\r
 140                 return TRUE;\r
 141         }\r
 142 \r
 143         OSVERSIONINFO osvi;\r
 144     BOOL bIsWindowsXPorLater;\r
 145 \r
 146     ZeroMemory(&osvi, sizeof(OSVERSIONINFO));\r
 147     osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);\r
 148 \r
 149     GetVersionEx(&osvi);\r
 150         \r
 151         if(osvi.dwMajorVersion >= 6)\r
 152                 return TRUE;\r
 153         else\r
 154                 return FALSE;\r
 155 }\r
 156 \r
 157 static void InitWinGitDll()\r
 158 {\r
 159         __try\r
 160         {\r
 161 \r
 162                 if( CGit::IsVista () )\r
 163                 {\r
 164                         g_IsWingitDllload=FALSE;\r
 165                         return;\r
 166                 }\r
 167                 if ( !wgInit() )\r
 168                 {\r
 169                                 // TODO\r
 170                 }\r
 171         }\r
 172         __except(1)\r
 173         {\r
 174                 g_IsWingitDllload=FALSE;\r
 175                 return;\r
 176         }\r
 177 \r
 178 }\r
 179 CGit::CGit(void)\r
 180 {\r
 181 #if 0\r
 182         GetCurrentDirectory(MAX_DIRBUFFER,m_CurrentDir.GetBuffer(MAX_DIRBUFFER));\r
 183         m_CurrentDir.ReleaseBuffer();\r
 184         // make sure git/bin is in PATH before wingit.dll gets (delay) loaded by wgInit()\r
 185         if ( !CheckMsysGitDir() )\r
 186         {\r
 187                 // TODO\r
 188         }\r
 189         InitWinGitDll();\r
 190 #endif\r
 191 }\r
 192 \r
 193 CGit::~CGit(void)\r
 194 {\r
 195 }\r
 196 \r
 197 static char g_Buffer[4096];\r
 198 \r
 199 int CGit::RunAsync(CString cmd,PROCESS_INFORMATION *piOut,HANDLE *hReadOut,CString *StdioFile)\r
 200 {\r
 201         SECURITY_ATTRIBUTES sa;\r
 202         HANDLE hRead, hWrite;\r
 203         HANDLE hStdioFile = NULL;\r
 204 \r
 205         sa.nLength = sizeof(SECURITY_ATTRIBUTES);\r
 206         sa.lpSecurityDescriptor=NULL;\r
 207         sa.bInheritHandle=TRUE;\r
 208         if(!CreatePipe(&hRead,&hWrite,&sa,0))\r
 209         {\r
 210                 return GIT_ERROR_OPEN_PIP;\r
 211         }\r
 212         \r
 213         if(StdioFile)\r
 214         {\r
 215                 hStdioFile=CreateFile(*StdioFile,GENERIC_WRITE,FILE_SHARE_READ   |   FILE_SHARE_WRITE,   \r
 216                         &sa,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);  \r
 217         }\r
 218 \r
 219         STARTUPINFO si;\r
 220         PROCESS_INFORMATION pi;\r
 221         si.cb=sizeof(STARTUPINFO);\r
 222         GetStartupInfo(&si);\r
 223 \r
 224         si.hStdError=hWrite;\r
 225         if(StdioFile)\r
 226                 si.hStdOutput=hStdioFile;\r
 227         else\r
 228                 si.hStdOutput=hWrite;\r
 229 \r
 230         si.wShowWindow=SW_HIDE;\r
 231         si.dwFlags=STARTF_USESTDHANDLES|STARTF_USESHOWWINDOW;\r
 232 \r
 233         if(!CreateProcess(NULL,(LPWSTR)cmd.GetString(), NULL,NULL,TRUE,NULL,NULL,(LPWSTR)m_CurrentDir.GetString(),&si,&pi))\r
 234         {\r
 235                 LPVOID lpMsgBuf;\r
 236                 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,\r
 237                         NULL,GetLastError(),MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),\r
 238                         (LPTSTR)&lpMsgBuf,\r
 239                         0,NULL);\r
 240                 return GIT_ERROR_CREATE_PROCESS;\r
 241         }\r
 242         \r
 243         CloseHandle(hWrite);\r
 244         if(piOut)\r
 245                 *piOut=pi;\r
 246         if(hReadOut)\r
 247                 *hReadOut=hRead;\r
 248         \r
 249         return 0;\r
 250 \r
 251 }\r
 252 //Must use sperate function to convert ANSI str to union code string\r
 253 //Becuase A2W use stack as internal convert buffer. \r
 254 void CGit::StringAppend(CString *str,BYTE *p,int code,int length)\r
 255 {\r
 256      //USES_CONVERSION;\r
 257          //str->Append(A2W_CP((LPCSTR)p,code));\r
 258         WCHAR * buf;\r
 259 \r
 260         int len ;\r
 261         if(length<0)\r
 262                 len= strlen((const char*)p);\r
 263         else\r
 264                 len=length;\r
 265         //if (len==0)\r
 266         //      return ;\r
 267         //buf = new WCHAR[len*4 + 1];\r
 268         buf = str->GetBuffer(len*4+1+str->GetLength())+str->GetLength();\r
 269         SecureZeroMemory(buf, (len*4 + 1)*sizeof(WCHAR));\r
 270         MultiByteToWideChar(code, 0, (LPCSTR)p, len, buf, len*4);\r
 271         str->ReleaseBuffer();\r
 272         //str->Append(buf);\r
 273         //delete buf;\r
 274 }       \r
 275 BOOL CGit::IsInitRepos()\r
 276 {\r
 277         CString cmdout;\r
 278         cmdout.Empty();\r
 279         if(g_Git.Run(_T("git.exe rev-parse --revs-only HEAD"),&cmdout,CP_UTF8))\r
 280         {\r
 281         //      CMessageBox::Show(NULL,cmdout,_T("TortoiseGit"),MB_OK);\r
 282                 return TRUE;\r
 283         }\r
 284         if(cmdout.IsEmpty())\r
 285                 return TRUE;\r
 286 \r
 287         return FALSE;\r
 288 }\r
 289 int CGit::Run(CGitCall* pcall)\r
 290 {\r
 291         PROCESS_INFORMATION pi;\r
 292         HANDLE hRead;\r
 293         if(RunAsync(pcall->GetCmd(),&pi,&hRead))\r
 294                 return GIT_ERROR_CREATE_PROCESS;\r
 295 \r
 296         DWORD readnumber;\r
 297         BYTE data[CALL_OUTPUT_READ_CHUNK_SIZE];\r
 298         bool bAborted=false;\r
 299         while(ReadFile(hRead,data,CALL_OUTPUT_READ_CHUNK_SIZE,&readnumber,NULL))\r
 300         {\r
 301                 //Todo: when OnOutputData() returns 'true', abort git-command. Send CTRL-C signal?\r
 302                 if(!bAborted)//For now, flush output when command aborted.\r
 303                         if(pcall->OnOutputData(data,readnumber))\r
 304                                 bAborted=true;\r
 305         }\r
 306         if(!bAborted)\r
 307                 pcall->OnEnd();\r
 308 \r
 309         \r
 310         CloseHandle(pi.hThread);\r
 311 \r
 312         WaitForSingleObject(pi.hProcess, INFINITE);\r
 313         DWORD exitcode =0;\r
 314 \r
 315         if(!GetExitCodeProcess(pi.hProcess,&exitcode))\r
 316         {\r
 317                 return GIT_ERROR_GET_EXIT_CODE;\r
 318         }\r
 319 \r
 320         CloseHandle(pi.hProcess);\r
 321 \r
 322         CloseHandle(hRead);\r
 323         return exitcode;\r
 324 }\r
 325 class CGitCall_ByteVector : public CGitCall\r
 326 {\r
 327 public:\r
 328         CGitCall_ByteVector(CString cmd,BYTE_VECTOR* pvector):CGitCall(cmd),m_pvector(pvector){}\r
 329         virtual bool OnOutputData(const BYTE* data, size_t size)\r
 330         {\r
 331                 size_t oldsize=m_pvector->size();\r
 332                 m_pvector->resize(m_pvector->size()+size);\r
 333                 memcpy(&*(m_pvector->begin()+oldsize),data,size);\r
 334                 return false;\r
 335         }\r
 336         BYTE_VECTOR* m_pvector;\r
 337 \r
 338 };\r
 339 int CGit::Run(CString cmd,BYTE_VECTOR *vector)\r
 340 {\r
 341         CGitCall_ByteVector call(cmd,vector);\r
 342         return Run(&call);\r
 343 }\r
 344 int CGit::Run(CString cmd, CString* output,int code)\r
 345 {\r
 346         BYTE_VECTOR vector;\r
 347         int ret;\r
 348         ret=Run(cmd,&vector);\r
 349 \r
 350         vector.push_back(0);\r
 351         \r
 352         StringAppend(output,&(vector[0]),code);\r
 353         return ret;\r
 354 }\r
 355 \r
 356 CString CGit::GetUserName(void)\r
 357 {\r
 358         CString UserName;\r
 359         Run(_T("git.exe config user.name"),&UserName,CP_UTF8);\r
 360         return UserName;\r
 361 }\r
 362 CString CGit::GetUserEmail(void)\r
 363 {\r
 364         CString UserName;\r
 365         Run(_T("git.exe config user.email"),&UserName,CP_UTF8);\r
 366         return UserName;\r
 367 }\r
 368 \r
 369 CString CGit::GetCurrentBranch(void)\r
 370 {\r
 371         CString output;\r
 372         //Run(_T("git.exe branch"),&branch);\r
 373 \r
 374         int ret=g_Git.Run(_T("git.exe branch"),&output,CP_UTF8);\r
 375         if(!ret)\r
 376         {               \r
 377                 int pos=0;\r
 378                 CString one;\r
 379                 while( pos>=0 )\r
 380                 {\r
 381                         //i++;\r
 382                         one=output.Tokenize(_T("\n"),pos);\r
 383                         //list.push_back(one.Right(one.GetLength()-2));\r
 384                         if(one[0] == _T('*'))\r
 385                                 return one.Right(one.GetLength()-2);\r
 386                 }\r
 387         }\r
 388         return CString("");\r
 389 }\r
 390 \r
 391 int CGit::BuildOutputFormat(CString &format,bool IsFull)\r
 392 {\r
 393         CString log;\r
 394         log.Format(_T("#<%c>%%x00"),LOG_REV_ITEM_BEGIN);\r
 395         format += log;\r
 396         if(IsFull)\r
 397         {\r
 398                 log.Format(_T("#<%c>%%an%%x00"),LOG_REV_AUTHOR_NAME);\r
 399                 format += log;\r
 400                 log.Format(_T("#<%c>%%ae%%x00"),LOG_REV_AUTHOR_EMAIL);\r
 401                 format += log;\r
 402                 log.Format(_T("#<%c>%%ai%%x00"),LOG_REV_AUTHOR_DATE);\r
 403                 format += log;\r
 404                 log.Format(_T("#<%c>%%cn%%x00"),LOG_REV_COMMIT_NAME);\r
 405                 format += log;\r
 406                 log.Format(_T("#<%c>%%ce%%x00"),LOG_REV_COMMIT_EMAIL);\r
 407                 format += log;\r
 408                 log.Format(_T("#<%c>%%ci%%x00"),LOG_REV_COMMIT_DATE);\r
 409                 format += log;\r
 410                 log.Format(_T("#<%c>%%s%%x00"),LOG_REV_COMMIT_SUBJECT);\r
 411                 format += log;\r
 412                 log.Format(_T("#<%c>%%b%%x00"),LOG_REV_COMMIT_BODY);\r
 413                 format += log;\r
 414         }\r
 415         log.Format(_T("#<%c>%%m%%H%%x00"),LOG_REV_COMMIT_HASH);\r
 416         format += log;\r
 417         log.Format(_T("#<%c>%%P%%x00"),LOG_REV_COMMIT_PARENT);\r
 418         format += log;\r
 419 \r
 420         if(IsFull)\r
 421         {\r
 422                 log.Format(_T("#<%c>%%x00"),LOG_REV_COMMIT_FILE);\r
 423                 format += log;\r
 424         }\r
 425         return 0;\r
 426 }\r
 427 \r
 428 int CGit::GetLog(BYTE_VECTOR& logOut, CString &hash,  CTGitPath *path ,int count,int mask)\r
 429 {\r
 430         CGitCall_ByteVector gitCall(CString(),&logOut);\r
 431         return GetLog(&gitCall,hash,path,count,mask);\r
 432 }\r
 433 \r
 434 //int CGit::GetLog(CGitCall* pgitCall, CString &hash,  CTGitPath *path ,int count,int mask)\r
 435 int CGit::GetLog(CGitCall* pgitCall, CString &hash, CTGitPath *path, int count, int mask)\r
 436 {\r
 437 \r
 438         CString cmd;\r
 439         CString log;\r
 440         CString num;\r
 441         CString since;\r
 442 \r
 443         CString file;\r
 444 \r
 445         if(path)\r
 446                 file.Format(_T(" -- \"%s\""),path->GetGitPathString());\r
 447         \r
 448         if(count>0)\r
 449                 num.Format(_T("-n%d"),count);\r
 450 \r
 451         CString param;\r
 452 \r
 453         if(mask& LOG_INFO_STAT )\r
 454                 param += _T(" --numstat ");\r
 455         if(mask& LOG_INFO_FILESTATE)\r
 456                 param += _T(" --raw ");\r
 457 \r
 458         if(mask& LOG_INFO_FULLHISTORY)\r
 459                 param += _T(" --full-history ");\r
 460 \r
 461         if(mask& LOG_INFO_BOUNDARY)\r
 462                 param += _T(" --left-right --boundary ");\r
 463 \r
 464         if(mask& CGit::LOG_INFO_ALL_BRANCH)\r
 465                 param += _T(" --all ");\r
 466 \r
 467         if(mask& CGit::LOG_INFO_DETECT_COPYRENAME)\r
 468                 param += _T(" -C ");\r
 469         \r
 470         if(mask& CGit::LOG_INFO_DETECT_RENAME )\r
 471                 param += _T(" -M ");\r
 472 \r
 473         if(mask& CGit::LOG_INFO_FIRST_PARENT )\r
 474                 param += _T(" --first-parent ");\r
 475         \r
 476         if(mask& CGit::LOG_INFO_NO_MERGE )\r
 477                 param += _T(" --no-merges ");\r
 478 \r
 479         if(mask& CGit::LOG_INFO_FOLLOW)\r
 480                 param += _T(" --follow ");\r
 481 \r
 482         param+=hash;\r
 483 \r
 484         cmd.Format(_T("git.exe log %s -z --topo-order %s --parents --pretty=format:\""),\r
 485                                 num,param);\r
 486 \r
 487         BuildOutputFormat(log,!(mask&CGit::LOG_INFO_ONLY_HASH));\r
 488 \r
 489         cmd += log;\r
 490         cmd += CString(_T("\"  "))+hash+file;\r
 491 \r
 492         pgitCall->SetCmd(cmd);\r
 493 \r
 494         return Run(pgitCall);\r
 495 //      return Run(cmd,&logOut);\r
 496 }\r
 497 \r
 498 #if 0\r
 499 int CGit::GetShortLog(CString &logOut,CTGitPath * path, int count)\r
 500 {\r
 501         CString cmd;\r
 502         CString log;\r
 503         int n;\r
 504         if(count<0)\r
 505                 n=100;\r
 506         else\r
 507                 n=count;\r
 508         cmd.Format(_T("git.exe log --left-right --boundary --topo-order -n%d --pretty=format:\""),n);\r
 509         BuildOutputFormat(log,false);\r
 510         cmd += log+_T("\"");\r
 511         if (path)\r
 512                 cmd+= _T("  -- \"")+path->GetGitPathString()+_T("\"");\r
 513         //cmd += CString(_T("\" HEAD~40..HEAD"));\r
 514         return Run(cmd,&logOut);\r
 515 }\r
 516 #endif\r
 517 \r
 518 #define BUFSIZE 512\r
 519 void GetTempPath(CString &path)\r
 520 {\r
 521         TCHAR lpPathBuffer[BUFSIZE];\r
 522         DWORD dwRetVal;\r
 523         DWORD dwBufSize=BUFSIZE;\r
 524         dwRetVal = GetTempPath(dwBufSize,     // length of the buffer\r
 525                            lpPathBuffer); // buffer for path \r
 526     if (dwRetVal > dwBufSize || (dwRetVal == 0))\r
 527     {\r
 528         path=_T("");\r
 529     }\r
 530         path.Format(_T("%s"),lpPathBuffer);\r
 531 }\r
 532 CString GetTempFile()\r
 533 {\r
 534         TCHAR lpPathBuffer[BUFSIZE];\r
 535         DWORD dwRetVal;\r
 536     DWORD dwBufSize=BUFSIZE;\r
 537         TCHAR szTempName[BUFSIZE];  \r
 538         UINT uRetVal;\r
 539 \r
 540         dwRetVal = GetTempPath(dwBufSize,     // length of the buffer\r
 541                            lpPathBuffer); // buffer for path \r
 542     if (dwRetVal > dwBufSize || (dwRetVal == 0))\r
 543     {\r
 544         return _T("");\r
 545     }\r
 546          // Create a temporary file. \r
 547     uRetVal = GetTempFileName(lpPathBuffer, // directory for tmp files\r
 548                               TEXT("Patch"),  // temp file name prefix \r
 549                               0,            // create unique name \r
 550                               szTempName);  // buffer for name \r
 551 \r
 552 \r
 553     if (uRetVal == 0)\r
 554     {\r
 555         return _T("");\r
 556     }\r
 557 \r
 558         return CString(szTempName);\r
 559 \r
 560 }\r
 561 \r
 562 int CGit::RunLogFile(CString cmd,CString &filename)\r
 563 {\r
 564         STARTUPINFO si;\r
 565         PROCESS_INFORMATION pi;\r
 566         si.cb=sizeof(STARTUPINFO);\r
 567         GetStartupInfo(&si);\r
 568 \r
 569         SECURITY_ATTRIBUTES   psa={sizeof(psa),NULL,TRUE};;   \r
 570         psa.bInheritHandle=TRUE;   \r
 571     \r
 572         HANDLE   houtfile=CreateFile(filename,GENERIC_WRITE,FILE_SHARE_READ   |   FILE_SHARE_WRITE,   \r
 573                         &psa,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);   \r
 574 \r
 575 \r
 576         si.wShowWindow=SW_HIDE;\r
 577         si.dwFlags=STARTF_USESTDHANDLES|STARTF_USESHOWWINDOW;\r
 578         si.hStdOutput   =   houtfile; \r
 579         \r
 580         if(!CreateProcess(NULL,(LPWSTR)cmd.GetString(), NULL,NULL,TRUE,NULL,NULL,(LPWSTR)m_CurrentDir.GetString(),&si,&pi))\r
 581         {\r
 582                 LPVOID lpMsgBuf;\r
 583                 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,\r
 584                         NULL,GetLastError(),MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),\r
 585                         (LPTSTR)&lpMsgBuf,\r
 586                         0,NULL);\r
 587                 return GIT_ERROR_CREATE_PROCESS;\r
 588         }\r
 589         \r
 590         WaitForSingleObject(pi.hProcess,INFINITE);   \r
 591         \r
 592         CloseHandle(pi.hThread);\r
 593         CloseHandle(pi.hProcess);\r
 594         CloseHandle(houtfile);\r
 595         return GIT_SUCCESS;\r
 596 //      return 0;\r
 597 }\r
 598 \r
 599 git_revnum_t CGit::GetHash(CString &friendname)\r
 600 {\r
 601         // NOTE: could replace this with wgGetRevisionID call\r
 602 \r
 603         CString cmd;\r
 604         CString out;\r
 605         cmd.Format(_T("git.exe rev-parse %s" ),friendname);\r
 606         Run(cmd,&out,CP_UTF8);\r
 607         int pos=out.ReverseFind(_T('\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::GetMapHashToFriendName(MAP_HASH_NAME &map)\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 \r
 710                                 CString hash;\r
 711                                 hash=one.Left(start);\r
 712 \r
 713                                 map[hash].push_back(name);\r
 714                         }\r
 715                 }\r
 716         }\r
 717         return ret;\r
 718 }\r
 719 \r
 720 BOOL CGit::CheckMsysGitDir()\r
 721 {\r
 722         static BOOL bInitialized = FALSE;\r
 723 \r
 724         if (bInitialized)\r
 725         {\r
 726                 return TRUE;\r
 727         }\r
 728 \r
 729         TCHAR *oldpath,*home;\r
 730         size_t size;\r
 731 \r
 732         // set HOME if not set already\r
 733         _tgetenv_s(&size, NULL, 0, _T("HOME"));\r
 734         if (!size)\r
 735         {\r
 736                 _tdupenv_s(&home,&size,_T("USERPROFILE")); \r
 737                 _tputenv_s(_T("HOME"),home);\r
 738                 free(home);\r
 739         }\r
 740 \r
 741         //setup ssh client\r
 742         CRegString sshclient=CRegString(_T("Software\\TortoiseGit\\SSH"));\r
 743         CString ssh=sshclient;\r
 744 \r
 745         if(!ssh.IsEmpty())\r
 746         {\r
 747                 _tputenv_s(_T("GIT_SSH"),ssh);\r
 748         }else\r
 749         {\r
 750                 _tputenv_s(_T("GIT_SSH"),_T(""));\r
 751         }\r
 752 \r
 753         // search PATH if git/bin directory is alredy present\r
 754         if ( FindGitPath() )\r
 755         {\r
 756                 bInitialized = TRUE;\r
 757                 return TRUE;\r
 758         }\r
 759 \r
 760         // add git/bin path to PATH\r
 761 \r
 762         CRegString msysdir=CRegString(REG_MSYSGIT_PATH,_T(""),FALSE,HKEY_LOCAL_MACHINE);\r
 763         CString str=msysdir;\r
 764         if(str.IsEmpty())\r
 765         {\r
 766                 CRegString msysinstalldir=CRegString(REG_MSYSGIT_INSTALL,_T(""),FALSE,HKEY_LOCAL_MACHINE);\r
 767                 str=msysinstalldir;\r
 768                 if ( !str.IsEmpty() )\r
 769                 {\r
 770                         str += (str[str.GetLength()-1] != '\\') ? "\\bin" : "bin";\r
 771                         msysdir=str;\r
 772                         msysdir.write();\r
 773                 }\r
 774                 else\r
 775                 {\r
 776                         return false;\r
 777                 }\r
 778         }\r
 779         //CGit::m_MsysGitPath=str;\r
 780 \r
 781         //set path\r
 782 \r
 783         _tdupenv_s(&oldpath,&size,_T("PATH")); \r
 784 \r
 785         CString path;\r
 786         path.Format(_T("%s;%s"),oldpath,str);\r
 787 \r
 788         _tputenv_s(_T("PATH"),path);\r
 789 \r
 790         free(oldpath);\r
 791 \r
 792 \r
 793     if( !FindGitPath() )\r
 794         {\r
 795                 return false;\r
 796         }\r
 797         else\r
 798         {\r
 799                 bInitialized = TRUE;\r
 800                 return true;\r
 801         }\r
 802 }\r
 803 \r
 804 \r
 805 class CGitCall_EnumFiles : public CGitCall\r
 806 {\r
 807 public:\r
 808         CGitCall_EnumFiles(const char *pszProjectPath, const char *pszSubPath, unsigned int nFlags, WGENUMFILECB *pEnumCb, void *pUserData)\r
 809         :       m_pszProjectPath(pszProjectPath),\r
 810                 m_pszSubPath(pszSubPath),\r
 811                 m_nFlags(nFlags),\r
 812                 m_pEnumCb(pEnumCb),\r
 813                 m_pUserData(pUserData)\r
 814         {\r
 815         }\r
 816 \r
 817         typedef std::map<CStringA,char> TStrCharMap;\r
 818 \r
 819         const char *    m_pszProjectPath;\r
 820         const char *    m_pszSubPath;\r
 821         unsigned int    m_nFlags;\r
 822         WGENUMFILECB *  m_pEnumCb;\r
 823         void *                  m_pUserData;\r
 824 \r
 825         BYTE_VECTOR             m_DataCollector;\r
 826         TStrCharMap             m_FileStatus;\r
 827 \r
 828         virtual bool    OnOutputData(const BYTE* data, size_t size)\r
 829         {\r
 830                 m_DataCollector.append(data,size);\r
 831                 while(true)\r
 832                 {\r
 833                         int found=m_DataCollector.findData((const BYTE*)"\n",1);\r
 834                         if(found<0)\r
 835                                 return false;\r
 836                         CStringA line;\r
 837                         char* pline=line.GetBuffer(found+1);\r
 838                         memcpy(pline,&*m_DataCollector.begin(),found);\r
 839                         pline[found]='\0';\r
 840                         line.ReleaseBuffer();\r
 841                         OnSingleLine(line);\r
 842                         m_DataCollector.erase(m_DataCollector.begin(),m_DataCollector.begin()+found+1);\r
 843                 }\r
 844                 return false;//Should never reach this\r
 845         }\r
 846         virtual void    OnEnd()\r
 847         {\r
 848                 for(TStrCharMap::iterator itFileStatus=m_FileStatus.begin();itFileStatus!=m_FileStatus.end();++itFileStatus)\r
 849                 {\r
 850                         wgFile_s fileStatus;\r
 851                         fileStatus.sFileName=itFileStatus->first;\r
 852                         switch(itFileStatus->second)\r
 853                         {\r
 854                         case 'C':       fileStatus.nStatus=WGFS_Modified;break;\r
 855                         case 'H':       fileStatus.nStatus=WGFS_Normal;break;\r
 856                         case 'R':       fileStatus.nStatus=WGFS_Deleted;break;\r
 857                         case '?':       fileStatus.nStatus=WGFS_Empty;break;//Other?\r
 858                         case 'K'://Todo: Killed?\r
 859                         case 'M'://Todo: What to do with this state? WGFS_Conflicted?\r
 860                         default://Unexpected status. Show as normal.\r
 861                                 fileStatus.nStatus=WGFS_Normal;\r
 862                         }\r
 863                         fileStatus.sha1=NULL;//Unknown with this call\r
 864                         fileStatus.nFlags=0;//Never a directory with this call. Git doesnt track directories as such.\r
 865                         (*m_pEnumCb)(&fileStatus,m_pUserData);\r
 866                 }\r
 867         }\r
 868         bool OnSingleLine(CStringA line)\r
 869         {\r
 870                 //Parse single line\r
 871                 int space=line.Find(' ');\r
 872                 if(space<0)\r
 873                         return false;\r
 874                 char status=line[0];\r
 875                 CStringA path=line;\r
 876                 path=path.Mid(space+1);\r
 877                 m_FileStatus[path]=status;\r
 878                 return true;\r
 879         }\r
 880 \r
 881 \r
 882 \r
 883 \r
 884 };\r
 885 \r
 886 BOOL CGit::EnumFiles(const char *pszProjectPath, const char *pszSubPath, unsigned int nFlags, WGENUMFILECB *pEnumCb, void *pUserData)\r
 887 {\r
 888         if(*pszProjectPath=='\0')\r
 889                 return FALSE;\r
 890         CGitCall_EnumFiles W_GitCall(pszProjectPath,pszSubPath,nFlags,pEnumCb,pUserData);\r
 891         CString cmd;\r
 892 \r
 893 /*      char W_szToDir[MAX_PATH];\r
 894         strncpy(W_szToDir,pszProjectPath,sizeof(W_szToDir)-1);\r
 895         if(W_szToDir[strlen(W_szToDir)-1]!='\\')\r
 896                 strncat(W_szToDir,"\\",sizeof(W_szToDir)-1);\r
 897 \r
 898         SetCurrentDirectoryA(W_szToDir);\r
 899         GetCurrentDirectoryA(sizeof(W_szToDir)-1,W_szToDir);\r
 900 */\r
 901         SetCurrentDir(CUnicodeUtils::GetUnicode(pszProjectPath));\r
 902         cmd.Format(_T("git.exe ls-files -t -c -d -m"));// -- %s"),CUnicodeUtils::GetUnicode(pszProjectPath));\r
 903         W_GitCall.SetCmd(cmd);\r
 904         Run(&W_GitCall);\r
 905         return TRUE;\r
 906 }\r