src/Git/Git.cpp

   1 #include "StdAfx.h"
   2 #include "Git.h"
   3 #include "atlconv.h"
   4 #include "GitRev.h"
   5 #include "registry.h"
   6 #include "GitConfig.h"
   7
   8 #define MAX_DIRBUFFER 1000
   9 CGit g_Git;
  10 CGit::CGit(void)
  11 {
  12         GetCurrentDirectory(MAX_DIRBUFFER,m_CurrentDir.GetBuffer(MAX_DIRBUFFER));
  13 }
  14
  15 CGit::~CGit(void)
  16 {
  17 }
  18
  19 static char g_Buffer[4096];
  20
  21 int CGit::RunAsync(CString cmd,PROCESS_INFORMATION *piOut,HANDLE *hReadOut,CString *StdioFile)
  22 {
  23         SECURITY_ATTRIBUTES sa;
  24         HANDLE hRead, hWrite;
  25         HANDLE hStdioFile;
  26
  27         sa.nLength = sizeof(SECURITY_ATTRIBUTES);
  28         sa.lpSecurityDescriptor=NULL;
  29         sa.bInheritHandle=TRUE;
  30         if(!CreatePipe(&hRead,&hWrite,&sa,0))
  31         {
  32                 return GIT_ERROR_OPEN_PIP;
  33         }
  34
  35         if(StdioFile)
  36         {
  37                 hStdioFile=CreateFile(*StdioFile,GENERIC_WRITE,FILE_SHARE_READ   |   FILE_SHARE_WRITE,
  38                         &sa,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
  39         }
  40
  41         STARTUPINFO si;
  42         PROCESS_INFORMATION pi;
  43         si.cb=sizeof(STARTUPINFO);
  44         GetStartupInfo(&si);
  45
  46         si.hStdError=hWrite;
  47         if(StdioFile)
  48                 si.hStdOutput=hStdioFile;
  49         else
  50                 si.hStdOutput=hWrite;
  51
  52         si.wShowWindow=SW_HIDE;
  53         si.dwFlags=STARTF_USESTDHANDLES|STARTF_USESHOWWINDOW;
  54
  55         if(!CreateProcess(NULL,(LPWSTR)cmd.GetString(), NULL,NULL,TRUE,NULL,NULL,(LPWSTR)m_CurrentDir.GetString(),&si,&pi))
  56         {
  57                 LPVOID lpMsgBuf;
  58                 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,
  59                         NULL,GetLastError(),MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
  60                         (LPTSTR)&lpMsgBuf,
  61                         0,NULL);
  62                 return GIT_ERROR_CREATE_PROCESS;
  63         }
  64
  65         CloseHandle(hWrite);
  66         if(piOut)
  67                 *piOut=pi;
  68         if(hReadOut)
  69                 *hReadOut=hRead;
  70
  71         return 0;
  72
  73 }
  74 //Must use sperate function to convert ANSI str to union code string
  75 //Becuase A2W use stack as internal convert buffer.
  76 void CGit::StringAppend(CString *str,BYTE *p,int code)
  77 {
  78        USES_CONVERSION;
  79        str->Append(A2W_CP((LPCSTR)p,code));
  80
  81 }
  82 BOOL CGit::IsInitRepos()
  83 {
  84         CString cmdout;
  85         cmdout.Empty();
  86         if(g_Git.Run(_T("git.exe rev-parse --revs-only HEAD"),&cmdout,CP_UTF8))
  87         {
  88         //      CMessageBox::Show(NULL,cmdout,_T("TortoiseGit"),MB_OK);
  89                 return TRUE;
  90         }
  91         if(cmdout.IsEmpty())
  92                 return TRUE;
  93
  94         return FALSE;
  95 }
  96 int CGit::Run(CString cmd,BYTE_VECTOR *vector)
  97 {
  98         PROCESS_INFORMATION pi;
  99         HANDLE hRead;
 100         if(RunAsync(cmd,&pi,&hRead))
 101                 return GIT_ERROR_CREATE_PROCESS;
 102
 103         DWORD readnumber;
 104         BYTE data;
 105         while(ReadFile(hRead,&data,1,&readnumber,NULL))
 106         {
 107                 //g_Buffer[readnumber]=0;
 108                 vector->push_back(data);
 109 //              StringAppend(output,g_Buffer,codes);
 110         }
 111
 112
 113         CloseHandle(pi.hThread);
 114
 115         WaitForSingleObject(pi.hProcess, INFINITE);
 116         DWORD exitcode =0;
 117
 118         if(!GetExitCodeProcess(pi.hProcess,&exitcode))
 119         {
 120                 return GIT_ERROR_GET_EXIT_CODE;
 121         }
 122
 123         CloseHandle(pi.hProcess);
 124
 125         CloseHandle(hRead);
 126         return exitcode;
 127
 128 }
 129 int CGit::Run(CString cmd, CString* output,int code)
 130 {
 131         BYTE_VECTOR vector;
 132         int ret;
 133         ret=Run(cmd,&vector);
 134
 135         if(ret)
 136                 return ret;
 137
 138         vector.push_back(0);
 139         StringAppend(output,&(vector[0]),code);
 140         return 0;
 141 }
 142
 143 CString CGit::GetUserName(void)
 144 {
 145         CString UserName;
 146         Run(_T("git.exe config user.name"),&UserName,CP_UTF8);
 147         return UserName;
 148 }
 149 CString CGit::GetUserEmail(void)
 150 {
 151         CString UserName;
 152         Run(_T("git.exe config user.email"),&UserName,CP_UTF8);
 153         return UserName;
 154 }
 155
 156 CString CGit::GetCurrentBranch(void)
 157 {
 158         CString output;
 159         //Run(_T("git.exe branch"),&branch);
 160
 161         int ret=g_Git.Run(_T("git.exe branch"),&output,CP_UTF8);
 162         if(!ret)
 163         {
 164                 int pos=0;
 165                 CString one;
 166                 while( pos>=0 )
 167                 {
 168                         //i++;
 169                         one=output.Tokenize(_T("\n"),pos);
 170                         //list.push_back(one.Right(one.GetLength()-2));
 171                         if(one[0] == _T('*'))
 172                                 return one.Right(one.GetLength()-2);
 173                 }
 174         }
 175         return CString("");
 176 }
 177
 178 int CGit::BuildOutputFormat(CString &format,bool IsFull)
 179 {
 180         CString log;
 181         log.Format(_T("#<%c>%%x00"),LOG_REV_ITEM_BEGIN);
 182         format += log;
 183         if(IsFull)
 184         {
 185                 log.Format(_T("#<%c>%%an%%x00"),LOG_REV_AUTHOR_NAME);
 186                 format += log;
 187                 log.Format(_T("#<%c>%%ae%%x00"),LOG_REV_AUTHOR_EMAIL);
 188                 format += log;
 189                 log.Format(_T("#<%c>%%ai%%x00"),LOG_REV_AUTHOR_DATE);
 190                 format += log;
 191                 log.Format(_T("#<%c>%%cn%%x00"),LOG_REV_COMMIT_NAME);
 192                 format += log;
 193                 log.Format(_T("#<%c>%%ce%%x00"),LOG_REV_COMMIT_EMAIL);
 194                 format += log;
 195                 log.Format(_T("#<%c>%%ci%%x00"),LOG_REV_COMMIT_DATE);
 196                 format += log;
 197                 log.Format(_T("#<%c>%%s%%x00"),LOG_REV_COMMIT_SUBJECT);
 198                 format += log;
 199                 log.Format(_T("#<%c>%%b%%x00"),LOG_REV_COMMIT_BODY);
 200                 format += log;
 201         }
 202         log.Format(_T("#<%c>%%m%%H%%x00"),LOG_REV_COMMIT_HASH);
 203         format += log;
 204         log.Format(_T("#<%c>%%P%%x00"),LOG_REV_COMMIT_PARENT);
 205         format += log;
 206
 207         if(IsFull)
 208         {
 209                 log.Format(_T("#<%c>%%x00"),LOG_REV_COMMIT_FILE);
 210                 format += log;
 211         }
 212         return 0;
 213 }
 214
 215 int CGit::GetLog(BYTE_VECTOR& logOut, CString &hash,  CTGitPath *path ,int count,int mask)
 216 {
 217
 218         CString cmd;
 219         CString log;
 220         CString num;
 221         CString since;
 222
 223         CString file;
 224
 225         if(path)
 226                 file.Format(_T(" -- \"%s\""),path->GetGitPathString());
 227
 228         if(count>0)
 229                 num.Format(_T("-n%d"),count);
 230
 231         CString param;
 232
 233         if(mask& LOG_INFO_STAT )
 234                 param += _T(" --numstat ");
 235         if(mask& LOG_INFO_FILESTATE)
 236                 param += _T(" --raw ");
 237
 238         if(mask& LOG_INFO_FULLHISTORY)
 239                 param += _T(" --full-history ");
 240
 241         if(mask& LOG_INFO_BOUNDARY)
 242                 param += _T(" --left-right --boundary ");
 243
 244         if(mask& CGit::LOG_INFO_ALL_BRANCH)
 245                 param += _T(" --all ");
 246
 247         if(mask& CGit::LOG_INFO_DETECT_COPYRENAME)
 248                 param += _T(" -C ");
 249
 250         if(mask& CGit::LOG_INFO_DETECT_RENAME )
 251                 param += _T(" -M ");
 252
 253         param+=hash;
 254
 255         cmd.Format(_T("git.exe log %s -z --topo-order --parents %s --pretty=format:\""),
 256                                 num,param);
 257
 258         BuildOutputFormat(log,!(mask&CGit::LOG_INFO_ONLY_HASH));
 259
 260         cmd += log;
 261         cmd += CString(_T("\"  "))+hash+file;
 262
 263         return Run(cmd,&logOut);
 264 }
 265
 266 #if 0
 267 int CGit::GetShortLog(CString &logOut,CTGitPath * path, int count)
 268 {
 269         CString cmd;
 270         CString log;
 271         int n;
 272         if(count<0)
 273                 n=100;
 274         else
 275                 n=count;
 276         cmd.Format(_T("git.exe log --left-right --boundary --topo-order -n%d --pretty=format:\""),n);
 277         BuildOutputFormat(log,false);
 278         cmd += log+_T("\"");
 279         if (path)
 280                 cmd+= _T("  -- \"")+path->GetGitPathString()+_T("\"");
 281         //cmd += CString(_T("\" HEAD~40..HEAD"));
 282         return Run(cmd,&logOut);
 283 }
 284 #endif
 285
 286 #define BUFSIZE 512
 287 void GetTempPath(CString &path)
 288 {
 289         TCHAR lpPathBuffer[BUFSIZE];
 290         DWORD dwRetVal;
 291         DWORD dwBufSize=BUFSIZE;
 292         dwRetVal = GetTempPath(dwBufSize,     // length of the buffer
 293                            lpPathBuffer); // buffer for path
 294     if (dwRetVal > dwBufSize || (dwRetVal == 0))
 295     {
 296         path=_T("");
 297     }
 298         path.Format(_T("%s"),lpPathBuffer);
 299 }
 300 CString GetTempFile()
 301 {
 302         TCHAR lpPathBuffer[BUFSIZE];
 303         DWORD dwRetVal;
 304     DWORD dwBufSize=BUFSIZE;
 305         TCHAR szTempName[BUFSIZE];
 306         UINT uRetVal;
 307
 308         dwRetVal = GetTempPath(dwBufSize,     // length of the buffer
 309                            lpPathBuffer); // buffer for path
 310     if (dwRetVal > dwBufSize || (dwRetVal == 0))
 311     {
 312         return _T("");
 313     }
 314          // Create a temporary file.
 315     uRetVal = GetTempFileName(lpPathBuffer, // directory for tmp files
 316                               TEXT("Patch"),  // temp file name prefix
 317                               0,            // create unique name
 318                               szTempName);  // buffer for name
 319
 320
 321     if (uRetVal == 0)
 322     {
 323         return _T("");
 324     }
 325
 326         return CString(szTempName);
 327
 328 }
 329
 330 int CGit::RunLogFile(CString cmd,CString &filename)
 331 {
 332         HANDLE hRead, hWrite;
 333
 334         STARTUPINFO si;
 335         PROCESS_INFORMATION pi;
 336         si.cb=sizeof(STARTUPINFO);
 337         GetStartupInfo(&si);
 338
 339         SECURITY_ATTRIBUTES   psa={sizeof(psa),NULL,TRUE};;
 340         psa.bInheritHandle=TRUE;
 341
 342         HANDLE   houtfile=CreateFile(filename,GENERIC_WRITE,FILE_SHARE_READ   |   FILE_SHARE_WRITE,
 343                         &psa,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
 344
 345
 346         si.wShowWindow=SW_HIDE;
 347         si.dwFlags=STARTF_USESTDHANDLES|STARTF_USESHOWWINDOW;
 348         si.hStdOutput   =   houtfile;
 349
 350         if(!CreateProcess(NULL,(LPWSTR)cmd.GetString(), NULL,NULL,TRUE,NULL,NULL,(LPWSTR)m_CurrentDir.GetString(),&si,&pi))
 351         {
 352                 LPVOID lpMsgBuf;
 353                 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,
 354                         NULL,GetLastError(),MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
 355                         (LPTSTR)&lpMsgBuf,
 356                         0,NULL);
 357                 return GIT_ERROR_CREATE_PROCESS;
 358         }
 359
 360         WaitForSingleObject(pi.hProcess,INFINITE);
 361
 362         CloseHandle(pi.hThread);
 363         CloseHandle(pi.hProcess);
 364         CloseHandle(houtfile);
 365         return GIT_SUCCESS;
 366         return 0;
 367 }
 368
 369 git_revnum_t CGit::GetHash(CString &friendname)
 370 {
 371         CString cmd;
 372         CString out;
 373         cmd.Format(_T("git.exe rev-parse %s" ),friendname);
 374         Run(cmd,&out,CP_UTF8);
 375         int pos=out.ReverseFind(_T('\n'));
 376         if(pos>0)
 377                 return out.Left(pos);
 378         return out;
 379 }
 380
 381 int CGit::GetTagList(STRING_VECTOR &list)
 382 {
 383         int ret;
 384         CString cmd,output;
 385         cmd=_T("git.exe tag -l");
 386         int i=0;
 387         ret=g_Git.Run(cmd,&output,CP_UTF8);
 388         if(!ret)
 389         {
 390                 int pos=0;
 391                 CString one;
 392                 while( pos>=0 )
 393                 {
 394                         i++;
 395                         one=output.Tokenize(_T("\n"),pos);
 396                         list.push_back(one);
 397                 }
 398         }
 399         return ret;
 400 }
 401
 402 int CGit::GetBranchList(STRING_VECTOR &list,int *current,BRANCH_TYPE type)
 403 {
 404         int ret;
 405         CString cmd,output;
 406         cmd=_T("git.exe branch");
 407
 408         if(type==(BRANCH_LOCAL|BRANCH_REMOTE))
 409                 cmd+=_T(" -a");
 410         else if(type==BRANCH_REMOTE)
 411                 cmd+=_T(" -r");
 412
 413         int i=0;
 414         ret=g_Git.Run(cmd,&output,CP_UTF8);
 415         if(!ret)
 416         {
 417                 int pos=0;
 418                 CString one;
 419                 while( pos>=0 )
 420                 {
 421                         i++;
 422                         one=output.Tokenize(_T("\n"),pos);
 423                         list.push_back(one.Right(one.GetLength()-2));
 424                         if(one[0] == _T('*'))
 425                                 if(current)
 426                                         *current=i;
 427                 }
 428         }
 429         return ret;
 430 }
 431
 432 int CGit::GetRemoteList(STRING_VECTOR &list)
 433 {
 434         int ret;
 435         CString cmd,output;
 436         cmd=_T("git.exe config  --get-regexp remote.*.url");
 437         ret=g_Git.Run(cmd,&output,CP_UTF8);
 438         if(!ret)
 439         {
 440                 int pos=0;
 441                 CString one;
 442                 while( pos>=0 )
 443                 {
 444                         one=output.Tokenize(_T("\n"),pos);
 445                         int start=one.Find(_T("."),0);
 446                         if(start>0)
 447                         {
 448                                 CString url;
 449                                 url=one.Right(one.GetLength()-start-1);
 450                                 one=url;
 451                                 one=one.Left(one.Find(_T("."),0));
 452                                 list.push_back(one);
 453                         }
 454                 }
 455         }
 456         return ret;
 457 }
 458
 459 int CGit::GetMapHashToFriendName(MAP_HASH_NAME &map)
 460 {
 461         int ret;
 462         CString cmd,output;
 463         cmd=_T("git show-ref -d");
 464         ret=g_Git.Run(cmd,&output,CP_UTF8);
 465         if(!ret)
 466         {
 467                 int pos=0;
 468                 CString one;
 469                 while( pos>=0 )
 470                 {
 471                         one=output.Tokenize(_T("\n"),pos);
 472                         int start=one.Find(_T(" "),0);
 473                         if(start>0)
 474                         {
 475                                 CString name;
 476                                 name=one.Right(one.GetLength()-start-1);
 477
 478                                 CString hash;
 479                                 hash=one.Left(start);
 480
 481                                 map[hash].push_back(name);
 482                         }
 483                 }
 484         }
 485         return ret;
 486 }
 487
 488 BOOL CGit::CheckMsysGitDir()
 489 {
 490         CRegString msysdir=CRegString(REG_MSYSGIT_PATH,_T(""),FALSE,HKEY_LOCAL_MACHINE);
 491         CString str=msysdir;
 492         if(str.IsEmpty())
 493         {
 494                 CRegString msysinstalldir=CRegString(REG_MSYSGIT_INSTALL,_T(""),FALSE,HKEY_LOCAL_MACHINE);
 495                 str=msysinstalldir;
 496                 str+="\\bin";
 497                 msysdir=str;
 498                 msysdir.write();
 499
 500         }
 501         //CGit::m_MsysGitPath=str;
 502
 503         TCHAR *oldpath,*home;
 504         size_t size;
 505
 506         _tdupenv_s(&home,&size,_T("HOME"));
 507
 508         if(home == NULL)
 509         {
 510                 _tdupenv_s(&home,&size,_T("USERPROFILE"));
 511                 _tputenv_s(_T("HOME"),home);
 512                 free(home);
 513         }
 514         //set path
 515         _tdupenv_s(&oldpath,&size,_T("PATH"));
 516
 517         CString path;
 518         path.Format(_T("%s;"),str);
 519         path+=oldpath;
 520
 521         _tputenv_s(_T("PATH"),path);
 522
 523         free(oldpath);
 524
 525         CString cmd,out;
 526         cmd=_T("git.exe --version");
 527         if(g_Git.Run(cmd,&out,CP_UTF8))
 528         {
 529                 return false;
 530         }
 531         else
 532                 return true;
 533
 534 }