src/Git/Git.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2008-2012 - TortoiseGit
   4
   5 // This program is free software; you can redistribute it and/or
   6 // modify it under the terms of the GNU General Public License
   7 // as published by the Free Software Foundation; either version 2
   8 // of the License, or (at your option) any later version.
   9
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14
  15 // You should have received a copy of the GNU General Public License
  16 // along with this program; if not, write to the Free Software Foundation,
  17 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 //
  19
  20 #include "StdAfx.h"
  21 #include "Git.h"
  22 #include "atlconv.h"
  23 #include "GitRev.h"
  24 #include "registry.h"
  25 #include "GitConfig.h"
  26 #include <map>
  27 #include "UnicodeUtils.h"
  28 #include "gitdll.h"
  29 #include <fstream>
  30 #include "git2.h"
  31
  32 int CGit::m_LogEncode=CP_UTF8;
  33 typedef CComCritSecLock<CComCriticalSection> CAutoLocker;
  34
  35 static LPTSTR nextpath(wchar_t *path, wchar_t *buf, size_t buflen)
  36 {
  37         wchar_t term, *base = path;
  38
  39         if (path == NULL || buf == NULL || buflen == 0)
  40                 return NULL;
  41
  42         term = (*path == L'"') ? *path++ : L';';
  43
  44         for (buflen--; *path && *path != term && buflen; buflen--)
  45                 *buf++ = *path++;
  46
  47         *buf = L'\0'; /* reserved a byte via initial subtract */
  48
  49         while (*path == term || *path == L';')
  50                 path++;
  51
  52         return (path != base) ? path : NULL;
  53 }
  54
  55 static inline BOOL FileExists(LPCTSTR lpszFileName)
  56 {
  57         struct _stat st;
  58         return _tstat(lpszFileName, &st) == 0;
  59 }
  60
  61 static BOOL FindGitPath()
  62 {
  63         size_t size;
  64         _tgetenv_s(&size, NULL, 0, _T("PATH"));
  65
  66         if (!size)
  67         {
  68                 return FALSE;
  69         }
  70
  71         TCHAR *env = (TCHAR*)alloca(size * sizeof(TCHAR));
  72         _tgetenv_s(&size, env, size, _T("PATH"));
  73
  74         TCHAR buf[MAX_PATH];
  75
  76         // search in all paths defined in PATH
  77         while ((env = nextpath(env, buf, MAX_PATH - 1)) != NULL && *buf)
  78         {
  79                 TCHAR *pfin = buf + _tcslen(buf)-1;
  80
  81                 // ensure trailing slash
  82                 if (*pfin != _T('/') && *pfin != _T('\\'))
  83                         _tcscpy_s(++pfin, 2, _T("\\")); // we have enough space left, MAX_PATH-1 is used in nextpath above
  84
  85                 const size_t len = _tcslen(buf);
  86
  87                 if ((len + 7) < MAX_PATH)
  88                         _tcscpy_s(pfin + 1, MAX_PATH - len, _T("git.exe"));
  89                 else
  90                         break;
  91
  92                 if ( FileExists(buf) )
  93                 {
  94                         // dir found
  95                         pfin[1] = 0;
  96                         CGit::ms_LastMsysGitDir = buf;
  97                         CGit::ms_LastMsysGitDir.TrimRight(_T("\\"));
  98                         return TRUE;
  99                 }
 100         }
 101
 102         return FALSE;
 103 }
 104
 105 static bool g_bSortLogical;
 106
 107 static void GetSortLogicalEnabled()
 108 {
 109         g_bSortLogical = !CRegDWORD(L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer\\NoStrCmpLogical", 0, false, HKEY_CURRENT_USER);
 110         if (g_bSortLogical)
 111                 g_bSortLogical = !CRegDWORD(L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer\\NoStrCmpLogical", 0, false, HKEY_LOCAL_MACHINE);
 112 }
 113
 114 static int LogicalComparePredicate(CString &left, CString &right)
 115 {
 116         if (g_bSortLogical)
 117                 return StrCmpLogicalW(left, right) < 0;
 118         return StrCmpI(left, right) < 0;
 119 }
 120
 121 #define MAX_DIRBUFFER 1000
 122 #define CALL_OUTPUT_READ_CHUNK_SIZE 1024
 123
 124 CString CGit::ms_LastMsysGitDir;
 125 CGit g_Git;
 126
 127
 128 CGit::CGit(void)
 129 {
 130         GetCurrentDirectory(MAX_DIRBUFFER,m_CurrentDir.GetBuffer(MAX_DIRBUFFER));
 131         m_CurrentDir.ReleaseBuffer();
 132         m_IsGitDllInited = false;
 133         m_GitDiff=0;
 134         m_GitSimpleListDiff=0;
 135         m_IsUseGitDLL = !!CRegDWORD(_T("Software\\TortoiseGit\\UsingGitDLL"),1);
 136         m_IsUseLibGit2 = !!CRegDWORD(_T("Software\\TortoiseGit\\UseLibgit2"), TRUE);
 137         GetSortLogicalEnabled();
 138         this->m_bInitialized =false;
 139         CheckMsysGitDir();
 140         m_critGitDllSec.Init();
 141 }
 142
 143 CGit::~CGit(void)
 144 {
 145         if(this->m_GitDiff)
 146         {
 147                 git_close_diff(m_GitDiff);
 148                 m_GitDiff=0;
 149         }
 150         if(this->m_GitSimpleListDiff)
 151         {
 152                 git_close_diff(m_GitSimpleListDiff);
 153                 m_GitSimpleListDiff=0;
 154         }
 155 }
 156
 157 bool CGit::IsBranchNameValid(CString branchname)
 158 {
 159         if (branchname.IsEmpty())
 160                 return false;
 161
 162         for(int i=0; i < branchname.GetLength(); i++)
 163         {
 164                 TCHAR c = branchname.GetAt(i);
 165                 if (c <= ' ' || c == '~' || c == '^' || c == ':' || c == '\\' || c == '?' || c == '[')
 166                         return false;
 167         }
 168
 169         if (branchname.Find(L".") == 0 || branchname.Find(L"/.") >= 0 || branchname.Find(L"..") >= 0 || branchname.Find(L"@{") >= 0 || branchname.ReverseFind('*') >= 0)
 170                 return false;
 171
 172         CString reverseBranchname = branchname.MakeReverse();
 173         if (branchname.Find(L'.') == 0 || branchname.Find(L'/') == 0 || reverseBranchname.Find(L"kcol.") >= 0)
 174                 return false;
 175
 176         return true;
 177 }
 178
 179 static char g_Buffer[4096];
 180
 181 int CGit::RunAsync(CString cmd, PROCESS_INFORMATION *piOut, HANDLE *hReadOut, HANDLE *hErrReadOut, CString *StdioFile)
 182 {
 183         SECURITY_ATTRIBUTES sa;
 184         HANDLE hRead, hWrite, hReadErr = NULL, hWriteErr = NULL;
 185         HANDLE hStdioFile = NULL;
 186
 187         sa.nLength = sizeof(SECURITY_ATTRIBUTES);
 188         sa.lpSecurityDescriptor=NULL;
 189         sa.bInheritHandle=TRUE;
 190         if(!CreatePipe(&hRead,&hWrite,&sa,0))
 191         {
 192                 return TGIT_GIT_ERROR_OPEN_PIP;
 193         }
 194         if (hErrReadOut && !CreatePipe(&hReadErr, &hWriteErr, &sa, 0))
 195                 return TGIT_GIT_ERROR_OPEN_PIP;
 196
 197         if(StdioFile)
 198         {
 199                 hStdioFile=CreateFile(*StdioFile,GENERIC_WRITE,FILE_SHARE_READ | FILE_SHARE_WRITE,
 200                                                                 &sa,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
 201         }
 202
 203         STARTUPINFO si;
 204         PROCESS_INFORMATION pi;
 205         si.cb=sizeof(STARTUPINFO);
 206         GetStartupInfo(&si);
 207
 208         if (hErrReadOut)
 209                 si.hStdError = hWriteErr;
 210         else
 211                 si.hStdError = hWrite;
 212         if(StdioFile)
 213                 si.hStdOutput=hStdioFile;
 214         else
 215                 si.hStdOutput=hWrite;
 216
 217         si.wShowWindow=SW_HIDE;
 218         si.dwFlags=STARTF_USESTDHANDLES|STARTF_USESHOWWINDOW;
 219
 220         LPTSTR pEnv = (!m_Environment.empty()) ? &m_Environment[0]: NULL;
 221         DWORD dwFlags = pEnv ? CREATE_UNICODE_ENVIRONMENT : 0;
 222
 223         //DETACHED_PROCESS make ssh recognize that it has no console to launch askpass to input password.
 224         dwFlags |= DETACHED_PROCESS | CREATE_NEW_PROCESS_GROUP;
 225
 226         memset(&this->m_CurrentGitPi,0,sizeof(PROCESS_INFORMATION));
 227         memset(&pi, 0, sizeof(PROCESS_INFORMATION));
 228
 229         if(cmd.Find(_T("git")) == 0)
 230         {
 231                 int firstSpace = cmd.Find(_T(" "));
 232                 if (firstSpace > 0)
 233                         cmd = _T('"')+CGit::ms_LastMsysGitDir+_T("\\")+ cmd.Left(firstSpace) + _T('"')+ cmd.Mid(firstSpace);
 234                 else
 235                         cmd=_T('"')+CGit::ms_LastMsysGitDir+_T("\\")+cmd+_T('"');
 236         }
 237
 238         if(!CreateProcess(NULL,(LPWSTR)cmd.GetString(), NULL,NULL,TRUE,dwFlags,pEnv,(LPWSTR)m_CurrentDir.GetString(),&si,&pi))
 239         {
 240                 LPVOID lpMsgBuf;
 241                 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
 242                                                 NULL,GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
 243                                                 (LPTSTR)&lpMsgBuf,
 244                                                 0,NULL);
 245                 return TGIT_GIT_ERROR_CREATE_PROCESS;
 246         }
 247
 248         m_CurrentGitPi = pi;
 249
 250         CloseHandle(hWrite);
 251         if (hErrReadOut)
 252                 CloseHandle(hWriteErr);
 253         if(piOut)
 254                 *piOut=pi;
 255         if(hReadOut)
 256                 *hReadOut=hRead;
 257         if(hErrReadOut)
 258                 *hErrReadOut = hReadErr;
 259         return 0;
 260
 261 }
 262 //Must use sperate function to convert ANSI str to union code string
 263 //Becuase A2W use stack as internal convert buffer.
 264 void CGit::StringAppend(CString *str,BYTE *p,int code,int length)
 265 {
 266         //USES_CONVERSION;
 267         //str->Append(A2W_CP((LPCSTR)p,code));
 268         if(str == NULL)
 269                 return ;
 270
 271         WCHAR * buf;
 272
 273         int len ;
 274         if(length<0)
 275                 len = (int)strlen((const char*)p);
 276         else
 277                 len=length;
 278         //if (len==0)
 279         //      return ;
 280         //buf = new WCHAR[len*4 + 1];
 281         buf = str->GetBuffer(len*4+1+str->GetLength())+str->GetLength();
 282         SecureZeroMemory(buf, (len*4 + 1)*sizeof(WCHAR));
 283         MultiByteToWideChar(code, 0, (LPCSTR)p, len, buf, len*4);
 284         str->ReleaseBuffer();
 285         //str->Append(buf);
 286         //delete buf;
 287 }
 288
 289 BOOL CGit::IsOrphanBranch(CString ref)
 290 {
 291         if (ref.IsEmpty())
 292                 ref = _T("HEAD");
 293
 294         CString cmdout;
 295         if (Run(_T("git.exe rev-parse --revs-only ") + ref, &cmdout, CP_UTF8))
 296         {
 297                 return TRUE;
 298         }
 299         if(cmdout.IsEmpty())
 300                 return TRUE;
 301
 302         return FALSE;
 303 }
 304
 305 BOOL CGit::IsInitRepos()
 306 {
 307         return IsOrphanBranch(_T("HEAD"));
 308 }
 309
 310 DWORD WINAPI CGit::AsyncReadStdErrThread(LPVOID lpParam)
 311 {
 312         PASYNCREADSTDERRTHREADARGS pDataArray;
 313         pDataArray = (PASYNCREADSTDERRTHREADARGS)lpParam;
 314
 315         DWORD readnumber;
 316         BYTE data[CALL_OUTPUT_READ_CHUNK_SIZE];
 317         while (ReadFile(pDataArray->fileHandle, data, CALL_OUTPUT_READ_CHUNK_SIZE, &readnumber, NULL))
 318         {
 319                 if (pDataArray->pcall->OnOutputErrData(data,readnumber))
 320                         break;
 321         }
 322
 323         return 0;
 324 }
 325
 326 int CGit::Run(CGitCall* pcall)
 327 {
 328         PROCESS_INFORMATION pi;
 329         HANDLE hRead, hReadErr;
 330         if(RunAsync(pcall->GetCmd(),&pi,&hRead, &hReadErr))
 331                 return TGIT_GIT_ERROR_CREATE_PROCESS;
 332
 333         HANDLE thread;
 334         ASYNCREADSTDERRTHREADARGS threadArguments;
 335         threadArguments.fileHandle = hReadErr;
 336         threadArguments.pcall = pcall;
 337         thread = CreateThread(NULL, 0, AsyncReadStdErrThread, &threadArguments, 0, NULL);
 338
 339         DWORD readnumber;
 340         BYTE data[CALL_OUTPUT_READ_CHUNK_SIZE];
 341         bool bAborted=false;
 342         while(ReadFile(hRead,data,CALL_OUTPUT_READ_CHUNK_SIZE,&readnumber,NULL))
 343         {
 344                 // TODO: when OnOutputData() returns 'true', abort git-command. Send CTRL-C signal?
 345                 if(!bAborted)//For now, flush output when command aborted.
 346                         if(pcall->OnOutputData(data,readnumber))
 347                                 bAborted=true;
 348         }
 349         if(!bAborted)
 350                 pcall->OnEnd();
 351
 352         if (thread)
 353                 WaitForSingleObject(thread, INFINITE);
 354
 355         CloseHandle(pi.hThread);
 356
 357         WaitForSingleObject(pi.hProcess, INFINITE);
 358         DWORD exitcode =0;
 359
 360         if(!GetExitCodeProcess(pi.hProcess,&exitcode))
 361         {
 362                 return TGIT_GIT_ERROR_GET_EXIT_CODE;
 363         }
 364
 365         CloseHandle(pi.hProcess);
 366
 367         CloseHandle(hRead);
 368         CloseHandle(hReadErr);
 369         return exitcode;
 370 }
 371 class CGitCall_ByteVector : public CGitCall
 372 {
 373 public:
 374         CGitCall_ByteVector(CString cmd,BYTE_VECTOR* pvector, BYTE_VECTOR* pvectorErr = NULL):CGitCall(cmd),m_pvector(pvector),m_pvectorErr(pvectorErr){}
 375         virtual bool OnOutputData(const BYTE* data, size_t size)
 376         {
 377                 if (size == 0)
 378                         return false;
 379                 size_t oldsize=m_pvector->size();
 380                 m_pvector->resize(m_pvector->size()+size);
 381                 memcpy(&*(m_pvector->begin()+oldsize),data,size);
 382                 return false;
 383         }
 384         virtual bool OnOutputErrData(const BYTE* data, size_t size)
 385         {
 386                 if (!m_pvectorErr || size == 0)
 387                         return false;
 388                 size_t oldsize = m_pvectorErr->size();
 389                 m_pvectorErr->resize(m_pvectorErr->size() + size);
 390                 memcpy(&*(m_pvectorErr->begin() + oldsize), data, size);
 391                 return false;
 392         }
 393         BYTE_VECTOR* m_pvector;
 394         BYTE_VECTOR* m_pvectorErr;
 395
 396 };
 397 int CGit::Run(CString cmd,BYTE_VECTOR *vector, BYTE_VECTOR *vectorErr)
 398 {
 399         CGitCall_ByteVector call(cmd, vector, vectorErr);
 400         return Run(&call);
 401 }
 402 int CGit::Run(CString cmd, CString* output, int code)
 403 {
 404         CString err;
 405         int ret;
 406         ret = Run(cmd, output, &err, code);
 407
 408         if (output && !err.IsEmpty())
 409         {
 410                 if (!output->IsEmpty())
 411                         *output += _T("\n");
 412                 *output += err;
 413         }
 414
 415         return ret;
 416 }
 417 int CGit::Run(CString cmd, CString* output, CString* outputErr, int code)
 418 {
 419         BYTE_VECTOR vector, vectorErr;
 420         int ret;
 421         if (outputErr)
 422                 ret = Run(cmd, &vector, &vectorErr);
 423         else
 424                 ret = Run(cmd, &vector);
 425
 426         vector.push_back(0);
 427         StringAppend(output, &(vector[0]), code);
 428
 429         if (outputErr)
 430         {
 431                 vectorErr.push_back(0);
 432                 StringAppend(outputErr, &(vectorErr[0]), code);
 433         }
 434
 435         return ret;
 436 }
 437
 438 CString CGit::GetUserName(void)
 439 {
 440         CEnvironment env;
 441         env.CopyProcessEnvironment();
 442         CString envname = env.GetEnv(_T("GIT_AUTHOR_NAME"));
 443         if (!envname.IsEmpty())
 444                 return envname;
 445         return GetConfigValue(L"user.name", this->GetGitEncode(L"i18n.commitencoding"));
 446 }
 447 CString CGit::GetUserEmail(void)
 448 {
 449         CEnvironment env;
 450         env.CopyProcessEnvironment();
 451         CString envmail = env.GetEnv(_T("GIT_AUTHOR_EMAIL"));
 452         if (!envmail.IsEmpty())
 453                 return envmail;
 454
 455         return GetConfigValue(L"user.email");
 456 }
 457
 458 CString CGit::GetConfigValue(CString name,int encoding, CString *GitPath, BOOL RemoveCR)
 459 {
 460         CString configValue;
 461         int start = 0;
 462         if(this->m_IsUseGitDLL)
 463         {
 464                 CString *git_path=NULL;
 465
 466                 CAutoLocker lock(g_Git.m_critGitDllSec);
 467
 468                 try
 469                 {
 470                         CTGitPath path;
 471
 472                         CheckAndInitDll();
 473                         git_path = GitPath;
 474
 475                 }catch(...)
 476                 {
 477                 }
 478                 CStringA key, value;
 479                 key =  CUnicodeUtils::GetMulti(name, encoding);
 480                 CStringA p;
 481                 if(git_path)
 482                         p = CUnicodeUtils::GetMulti(*GitPath, CP_UTF8);
 483
 484                 if(git_get_config(key.GetBuffer(), value.GetBufferSetLength(4096), 4096, p.GetBuffer()))
 485                         return CString();
 486                 else
 487                 {
 488                         StringAppend(&configValue,(BYTE*)value.GetBuffer(),encoding);
 489                         if(RemoveCR)
 490                                 return configValue.Tokenize(_T("\n"),start);
 491                         return configValue;
 492                 }
 493
 494         }
 495         else
 496         {
 497                 CString cmd;
 498                 cmd.Format(L"git.exe config %s", name);
 499                 Run(cmd, &configValue, NULL, encoding);
 500                 if(RemoveCR)
 501                         return configValue.Tokenize(_T("\n"),start);
 502                 return configValue;
 503         }
 504 }
 505
 506 int CGit::SetConfigValue(CString key, CString value, CONFIG_TYPE type, int encoding, CString *GitPath)
 507 {
 508         if(this->m_IsUseGitDLL)
 509         {
 510                 CAutoLocker lock(g_Git.m_critGitDllSec);
 511
 512                 try
 513                 {
 514                         CheckAndInitDll();
 515
 516                 }catch(...)
 517                 {
 518                 }
 519                 CStringA keya, valuea;
 520                 keya = CUnicodeUtils::GetMulti(key, CP_UTF8);
 521                 valuea = CUnicodeUtils::GetMulti(value, encoding);
 522                 CStringA p;
 523                 if(GitPath)
 524                         p = CUnicodeUtils::GetMulti(*GitPath, CP_UTF8);
 525
 526                 return get_set_config(keya.GetBuffer(), valuea.GetBuffer(), type, p.GetBuffer());
 527
 528         }
 529         else
 530         {
 531                 CString cmd;
 532                 CString option;
 533                 switch(type)
 534                 {
 535                 case CONFIG_GLOBAL:
 536                         option = _T("--global");
 537                         break;
 538                 case CONFIG_SYSTEM:
 539                         option = _T("--system");
 540                         break;
 541                 default:
 542                         break;
 543                 }
 544                 cmd.Format(_T("git.exe config %s %s \"%s\""), option, key, value);
 545                 CString out;
 546                 if (Run(cmd, &out, NULL, encoding))
 547                 {
 548                         return -1;
 549                 }
 550         }
 551         return 0;
 552 }
 553
 554 int CGit::UnsetConfigValue(CString key, CONFIG_TYPE type, int encoding, CString *GitPath)
 555 {
 556         if(this->m_IsUseGitDLL)
 557         {
 558                 CAutoLocker lock(g_Git.m_critGitDllSec);
 559
 560                 try
 561                 {
 562                         CheckAndInitDll();
 563                 }catch(...)
 564                 {
 565                 }
 566                 CStringA keya;
 567                 keya = CUnicodeUtils::GetMulti(key, CP_UTF8);
 568                 CStringA p;
 569                 if(GitPath)
 570                         p=CUnicodeUtils::GetMulti(*GitPath,CP_ACP);
 571
 572                 return get_set_config(keya.GetBuffer(), NULL, type, p.GetBuffer());
 573         }
 574         else
 575         {
 576                 CString cmd;
 577                 CString option;
 578                 switch(type)
 579                 {
 580                 case CONFIG_GLOBAL:
 581                         option = _T("--global");
 582                         break;
 583                 case CONFIG_SYSTEM:
 584                         option = _T("--system");
 585                         break;
 586                 default:
 587                         break;
 588                 }
 589                 cmd.Format(_T("git.exe config %s --unset %s"), option, key);
 590                 CString out;
 591                 if (Run(cmd, &out, NULL, encoding))
 592                 {
 593                         return -1;
 594                 }
 595         }
 596         return 0;
 597 }
 598
 599 CString CGit::GetCurrentBranch(void)
 600 {
 601         CString output;
 602         //Run(_T("git.exe branch"),&branch);
 603
 604         if(this->GetCurrentBranchFromFile(this->m_CurrentDir,output))
 605         {
 606                 return _T("(no branch)");
 607         }
 608         else
 609                 return output;
 610
 611 }
 612
 613 CString CGit::GetSymbolicRef(const wchar_t* symbolicRefName, bool bStripRefsHeads)
 614 {
 615         CString refName;
 616         if(this->m_IsUseGitDLL)
 617         {
 618                 unsigned char sha1[20];
 619                 int flag;
 620
 621                 CAutoLocker lock(g_Git.m_critGitDllSec);
 622                 const char *refs_heads_master = git_resolve_ref(CUnicodeUtils::GetUTF8(CString(symbolicRefName)), sha1, 0, &flag);
 623                 if(refs_heads_master && (flag&REF_ISSYMREF))
 624                 {
 625                         StringAppend(&refName,(BYTE*)refs_heads_master);
 626                         if(bStripRefsHeads)
 627                                 refName = StripRefName(refName);
 628                 }
 629
 630         }
 631         else
 632         {
 633                 CString cmd;
 634                 cmd.Format(L"git symbolic-ref %s", symbolicRefName);
 635                 if (Run(cmd, &refName, NULL, CP_UTF8) != 0)
 636                         return CString();//Error
 637                 int iStart = 0;
 638                 refName = refName.Tokenize(L"\n", iStart);
 639                 if(bStripRefsHeads)
 640                         refName = StripRefName(refName);
 641         }
 642         return refName;
 643 }
 644
 645 CString CGit::GetFullRefName(CString shortRefName)
 646 {
 647         CString refName;
 648         CString cmd;
 649         cmd.Format(L"git rev-parse --symbolic-full-name %s", shortRefName);
 650         if (Run(cmd, &refName, NULL, CP_UTF8) != 0)
 651                 return CString();//Error
 652         int iStart = 0;
 653         return refName.Tokenize(L"\n", iStart);
 654 }
 655
 656 CString CGit::StripRefName(CString refName)
 657 {
 658         if(wcsncmp(refName, L"refs/heads/", 11) == 0)
 659                 refName = refName.Mid(11);
 660         else if(wcsncmp(refName, L"refs/", 5) == 0)
 661                 refName = refName.Mid(5);
 662         int start =0;
 663         return refName.Tokenize(_T("\n"),start);
 664 }
 665
 666 int CGit::GetCurrentBranchFromFile(const CString &sProjectRoot, CString &sBranchOut)
 667 {
 668         // read current branch name like git-gui does, by parsing the .git/HEAD file directly
 669
 670         if ( sProjectRoot.IsEmpty() )
 671                 return -1;
 672
 673         CString sDotGitPath;
 674         if (!g_GitAdminDir.GetAdminDirPath(sProjectRoot, sDotGitPath))
 675                 return -1;
 676
 677         CString sHeadFile = sDotGitPath + _T("HEAD");
 678
 679         FILE *pFile;
 680         _tfopen_s(&pFile, sHeadFile.GetString(), _T("r"));
 681
 682         if (!pFile)
 683         {
 684                 return -1;
 685         }
 686
 687         char s[256] = {0};
 688         fgets(s, sizeof(s), pFile);
 689
 690         fclose(pFile);
 691
 692         const char *pfx = "ref: refs/heads/";
 693         const int len = 16;//strlen(pfx)
 694
 695         if ( !strncmp(s, pfx, len) )
 696         {
 697                 //# We're on a branch.  It might not exist.  But
 698                 //# HEAD looks good enough to be a branch.
 699                 CStringA utf8Branch(s + len);
 700                 sBranchOut = CUnicodeUtils::GetUnicode(utf8Branch);
 701                 sBranchOut.TrimRight(_T(" \r\n\t"));
 702
 703                 if ( sBranchOut.IsEmpty() )
 704                         return -1;
 705         }
 706         else
 707         {
 708                 //# Assume this is a detached head.
 709                 sBranchOut = "HEAD";
 710
 711                 return 1;
 712         }
 713
 714         return 0;
 715 }
 716
 717 int CGit::BuildOutputFormat(CString &format,bool IsFull)
 718 {
 719         CString log;
 720         log.Format(_T("#<%c>%%x00"),LOG_REV_ITEM_BEGIN);
 721         format += log;
 722         if(IsFull)
 723         {
 724                 log.Format(_T("#<%c>%%an%%x00"),LOG_REV_AUTHOR_NAME);
 725                 format += log;
 726                 log.Format(_T("#<%c>%%ae%%x00"),LOG_REV_AUTHOR_EMAIL);
 727                 format += log;
 728                 log.Format(_T("#<%c>%%ai%%x00"),LOG_REV_AUTHOR_DATE);
 729                 format += log;
 730                 log.Format(_T("#<%c>%%cn%%x00"),LOG_REV_COMMIT_NAME);
 731                 format += log;
 732                 log.Format(_T("#<%c>%%ce%%x00"),LOG_REV_COMMIT_EMAIL);
 733                 format += log;
 734                 log.Format(_T("#<%c>%%ci%%x00"),LOG_REV_COMMIT_DATE);
 735                 format += log;
 736                 log.Format(_T("#<%c>%%b%%x00"),LOG_REV_COMMIT_BODY);
 737                 format += log;
 738         }
 739
 740         log.Format(_T("#<%c>%%m%%H%%x00"),LOG_REV_COMMIT_HASH);
 741         format += log;
 742         log.Format(_T("#<%c>%%P%%x00"),LOG_REV_COMMIT_PARENT);
 743         format += log;
 744         log.Format(_T("#<%c>%%s%%x00"),LOG_REV_COMMIT_SUBJECT);
 745         format += log;
 746
 747         if(IsFull)
 748         {
 749                 log.Format(_T("#<%c>%%x00"),LOG_REV_COMMIT_FILE);
 750                 format += log;
 751         }
 752         return 0;
 753 }
 754
 755 int CGit::GetLog(BYTE_VECTOR& logOut, const CString &hash,  CTGitPath *path ,int count,int mask,CString *from,CString *to)
 756 {
 757         CGitCall_ByteVector gitCall(CString(), &logOut, NULL);
 758         return GetLog(&gitCall,hash,path,count,mask,from,to);
 759 }
 760
 761 CString CGit::GetLogCmd( const CString &hash, CTGitPath *path, int count, int mask,CString *from,CString *to,bool paramonly,
 762                                                 CFilterData *Filter)
 763 {
 764         CString cmd;
 765         CString num;
 766         CString since;
 767
 768         CString file;
 769
 770         if(path)
 771                 file.Format(_T(" -- \"%s\""),path->GetGitPathString());
 772
 773         if(count>0)
 774                 num.Format(_T("-n%d"),count);
 775
 776         CString param;
 777
 778         if(mask& LOG_INFO_STAT )
 779                 param += _T(" --numstat ");
 780         if(mask& LOG_INFO_FILESTATE)
 781                 param += _T(" --raw ");
 782
 783         if(mask& LOG_INFO_FULLHISTORY)
 784                 param += _T(" --full-history ");
 785
 786         if(mask& LOG_INFO_BOUNDARY)
 787                 param += _T(" --left-right --boundary ");
 788
 789         if(mask& CGit::LOG_INFO_ALL_BRANCH)
 790                 param += _T(" --all ");
 791
 792         if(mask& CGit::LOG_INFO_DETECT_COPYRENAME)
 793                 param += _T(" -C ");
 794
 795         if(mask& CGit::LOG_INFO_DETECT_RENAME )
 796                 param += _T(" -M ");
 797
 798         if(mask& CGit::LOG_INFO_FIRST_PARENT )
 799                 param += _T(" --first-parent ");
 800
 801         if(mask& CGit::LOG_INFO_NO_MERGE )
 802                 param += _T(" --no-merges ");
 803
 804         if(mask& CGit::LOG_INFO_FOLLOW)
 805                 param += _T(" --follow ");
 806
 807         if(mask& CGit::LOG_INFO_SHOW_MERGEDFILE)
 808                 param += _T(" -c ");
 809
 810         if(mask& CGit::LOG_INFO_FULL_DIFF)
 811                 param += _T(" --full-diff ");
 812
 813         if(mask& CGit::LOG_INFO_SIMPILFY_BY_DECORATION)
 814                 param += _T(" --simplify-by-decoration ");
 815
 816         if(from != NULL && to != NULL)
 817         {
 818                 CString range;
 819                 range.Format(_T(" %s..%s "),FixBranchName(*from),FixBranchName(*to));
 820                 param += range;
 821         }
 822         else if(to != NULL && hash.IsEmpty())
 823         {
 824                 CString range;
 825                 range.Format(_T(" %s "), FixBranchName(*to));
 826                 param += range;
 827         }
 828         param+=hash;
 829
 830         CString st1,st2;
 831
 832         if( Filter && (Filter->m_From != -1))
 833         {
 834                 st1.Format(_T(" --max-age=%I64u "), Filter->m_From);
 835                 param += st1;
 836         }
 837
 838         if( Filter && (Filter->m_To != -1))
 839         {
 840                 st2.Format(_T(" --min-age=%I64u "), Filter->m_To);
 841                 param += st2;
 842         }
 843
 844         bool isgrep = false;
 845         if( Filter && (!Filter->m_Author.IsEmpty()))
 846         {
 847                 st1.Format(_T(" --author=\"%s\"" ),Filter->m_Author);
 848                 param += st1;
 849                 isgrep = true;
 850         }
 851
 852         if( Filter && (!Filter->m_Committer.IsEmpty()))
 853         {
 854                 st1.Format(_T(" --committer=\"%s\"" ),Filter->m_Author);
 855                 param += st1;
 856                 isgrep = true;
 857         }
 858
 859         if( Filter && (!Filter->m_MessageFilter.IsEmpty()))
 860         {
 861                 st1.Format(_T(" --grep=\"%s\"" ),Filter->m_MessageFilter);
 862                 param += st1;
 863                 isgrep = true;
 864         }
 865
 866         if(Filter && isgrep)
 867         {
 868                 if(!Filter->m_IsRegex)
 869                         param += _T(" --fixed-strings ");
 870
 871                 param += _T(" --regexp-ignore-case --extended-regexp ");
 872         }
 873
 874         if (CRegDWORD(_T("Software\\TortoiseGit\\LogTopoOrder"), TRUE))
 875                 param += _T(" --topo-order");
 876
 877         if(paramonly) //tgit.dll.Git.cpp:setup_revisions() only looks at args[1] and greater.  To account for this, pass a dummy parameter in the 0th place
 878                 cmd.Format(_T("--ignore-this-parameter %s -z %s --parents "), num, param);
 879         else
 880         {
 881                 CString log;
 882                 BuildOutputFormat(log,!(mask&CGit::LOG_INFO_ONLY_HASH));
 883                 cmd.Format(_T("git.exe log %s -z %s --parents --pretty=format:\"%s\""),
 884                                 num,param,log);
 885         }
 886
 887         cmd += file;
 888
 889         return cmd;
 890 }
 891 //int CGit::GetLog(CGitCall* pgitCall, const CString &hash,  CTGitPath *path ,int count,int mask)
 892 int CGit::GetLog(CGitCall* pgitCall, const CString &hash, CTGitPath *path, int count, int mask,CString *from,CString *to)
 893 {
 894         pgitCall->SetCmd( GetLogCmd(hash,path,count,mask,from,to) );
 895
 896         return Run(pgitCall);
 897 //      return Run(cmd,&logOut);
 898 }
 899
 900 #define BUFSIZE 512
 901 void GetTempPath(CString &path)
 902 {
 903         TCHAR lpPathBuffer[BUFSIZE];
 904         DWORD dwRetVal;
 905         DWORD dwBufSize=BUFSIZE;
 906         dwRetVal = GetTortoiseGitTempPath(dwBufSize,            // length of the buffer
 907                                                         lpPathBuffer);  // buffer for path
 908         if (dwRetVal > dwBufSize || (dwRetVal == 0))
 909         {
 910                 path=_T("");
 911         }
 912         path.Format(_T("%s"),lpPathBuffer);
 913 }
 914 CString GetTempFile()
 915 {
 916         TCHAR lpPathBuffer[BUFSIZE];
 917         DWORD dwRetVal;
 918         DWORD dwBufSize=BUFSIZE;
 919         TCHAR szTempName[BUFSIZE];
 920         UINT uRetVal;
 921
 922         dwRetVal = GetTortoiseGitTempPath(dwBufSize,            // length of the buffer
 923                                                         lpPathBuffer);  // buffer for path
 924         if (dwRetVal > dwBufSize || (dwRetVal == 0))
 925         {
 926                 return _T("");
 927         }
 928          // Create a temporary file.
 929         uRetVal = GetTempFileName(lpPathBuffer,         // directory for tmp files
 930                                                                 TEXT("Patch"),  // temp file name prefix
 931                                                                 0,                              // create unique name
 932                                                                 szTempName);    // buffer for name
 933
 934
 935         if (uRetVal == 0)
 936         {
 937                 return _T("");
 938         }
 939
 940         return CString(szTempName);
 941
 942 }
 943
 944 DWORD GetTortoiseGitTempPath(DWORD nBufferLength, LPTSTR lpBuffer)
 945 {
 946         DWORD result = ::GetTempPath(nBufferLength, lpBuffer);
 947         if (result == 0) return 0;
 948         if (lpBuffer == NULL || (result + 13 > nBufferLength))
 949         {
 950                 if (lpBuffer)
 951                         lpBuffer[0] = '\0';
 952                 return result + 13;
 953         }
 954
 955         _tcscat(lpBuffer, _T("TortoiseGit\\"));
 956         CreateDirectory(lpBuffer, NULL);
 957
 958         return result + 13;
 959 }
 960
 961 int CGit::RunLogFile(CString cmd,const CString &filename)
 962 {
 963         STARTUPINFO si;
 964         PROCESS_INFORMATION pi;
 965         si.cb=sizeof(STARTUPINFO);
 966         GetStartupInfo(&si);
 967
 968         SECURITY_ATTRIBUTES   psa={sizeof(psa),NULL,TRUE};;
 969         psa.bInheritHandle=TRUE;
 970
 971         HANDLE houtfile=CreateFile(filename,GENERIC_WRITE,FILE_SHARE_READ | FILE_SHARE_WRITE,
 972                         &psa,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
 973
 974         si.wShowWindow = SW_HIDE;
 975         si.dwFlags = STARTF_USESTDHANDLES|STARTF_USESHOWWINDOW;
 976         si.hStdOutput = houtfile;
 977
 978         LPTSTR pEnv = (!m_Environment.empty()) ? &m_Environment[0]: NULL;
 979         DWORD dwFlags = pEnv ? CREATE_UNICODE_ENVIRONMENT : 0;
 980
 981         if(cmd.Find(_T("git")) == 0)
 982                 cmd=CGit::ms_LastMsysGitDir+_T("\\")+cmd;
 983
 984         if(!CreateProcess(NULL,(LPWSTR)cmd.GetString(), NULL,NULL,TRUE,dwFlags,pEnv,(LPWSTR)m_CurrentDir.GetString(),&si,&pi))
 985         {
 986                 LPVOID lpMsgBuf;
 987                 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,
 988                                                 NULL,GetLastError(),MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
 989                                                 (LPTSTR)&lpMsgBuf,
 990                                                 0,NULL);
 991                 return TGIT_GIT_ERROR_CREATE_PROCESS;
 992         }
 993
 994         WaitForSingleObject(pi.hProcess,INFINITE);
 995
 996         CloseHandle(pi.hThread);
 997         CloseHandle(pi.hProcess);
 998         CloseHandle(houtfile);
 999         return TGIT_GIT_SUCCESS;
1000 //      return 0;
1001 }
1002
1003 CGitHash CGit::GetHash(TCHAR* friendname)
1004 {
1005         // no need to parse a ref if it's already a 40-byte hash
1006         if (CGitHash::IsValidSHA1(friendname))
1007         {
1008                 CString sHash(friendname);
1009                 return CGitHash(sHash);
1010         }
1011
1012         if (m_IsUseLibGit2)
1013         {
1014                 git_repository *repo = NULL;
1015                 CStringA gitdirA = CUnicodeUtils::GetMulti(CTGitPath(m_CurrentDir).GetGitPathString(), CP_UTF8);
1016                 if (git_repository_open(&repo, gitdirA.GetBuffer()))
1017                 {
1018                         gitdirA.ReleaseBuffer();
1019                         return CGitHash();
1020                 }
1021                 gitdirA.ReleaseBuffer();
1022
1023                 CStringA refnameA = CUnicodeUtils::GetMulti(friendname, CP_UTF8);
1024
1025                 git_object * gitObject = NULL;
1026                 if (git_revparse_single(&gitObject, repo, refnameA.GetBuffer()))
1027                 {
1028                         refnameA.ReleaseBuffer();
1029                         git_repository_free(repo);
1030                         return CGitHash();
1031                 }
1032                 refnameA.ReleaseBuffer();
1033
1034                 const git_oid * oid = git_object_id(gitObject);
1035                 if (oid == NULL)
1036                 {
1037                         git_object_free(gitObject);
1038                         git_repository_free(repo);
1039                         return CGitHash();
1040                 }
1041
1042                 CGitHash hash((char *)oid->id);
1043
1044                 git_object_free(gitObject); // also frees oid
1045                 git_repository_free(repo);
1046
1047                 return hash;
1048         }
1049         else
1050         {
1051                 CString cmd;
1052                 CString out;
1053                 cmd.Format(_T("git.exe rev-parse %s" ),FixBranchName(friendname));
1054                 Run(cmd, &out, NULL, CP_UTF8);
1055                 return CGitHash(out.Trim());
1056         }
1057 }
1058
1059 int CGit::GetInitAddList(CTGitPathList &outputlist)
1060 {
1061         CString cmd;
1062         BYTE_VECTOR cmdout;
1063
1064         cmd=_T("git.exe ls-files -s -t -z");
1065         outputlist.Clear();
1066         if (Run(cmd, &cmdout))
1067                 return -1;
1068
1069         outputlist.ParserFromLsFile(cmdout);
1070         for(int i=0;i<outputlist.GetCount();i++)
1071                 const_cast<CTGitPath&>(outputlist[i]).m_Action = CTGitPath::LOGACTIONS_ADDED;
1072
1073         return 0;
1074 }
1075 int CGit::GetCommitDiffList(const CString &rev1,const CString &rev2,CTGitPathList &outputlist)
1076 {
1077         CString cmd;
1078
1079         if(rev1 == GIT_REV_ZERO || rev2 == GIT_REV_ZERO)
1080         {
1081                 //rev1=+_T("");
1082                 if(rev1 == GIT_REV_ZERO)
1083                         cmd.Format(_T("git.exe diff -r --raw -C -M --numstat -z %s"),rev2);
1084                 else
1085                         cmd.Format(_T("git.exe diff -r -R --raw -C -M --numstat -z %s"),rev1);
1086         }
1087         else
1088         {
1089                 cmd.Format(_T("git.exe diff-tree -r --raw -C -M --numstat -z %s %s"),rev2,rev1);
1090         }
1091
1092         BYTE_VECTOR out;
1093         if (Run(cmd, &out))
1094                 return -1;
1095
1096         outputlist.ParserFromLog(out);
1097
1098         return 0;
1099 }
1100
1101 int addto_list_each_ref_fn(const char *refname, const unsigned char * /*sha1*/, int /*flags*/, void *cb_data)
1102 {
1103         STRING_VECTOR *list = (STRING_VECTOR*)cb_data;
1104         CString str;
1105         g_Git.StringAppend(&str, (BYTE*)refname, CP_UTF8);
1106         list->push_back(str);
1107         return 0;
1108 }
1109
1110 int CGit::GetTagList(STRING_VECTOR &list)
1111 {
1112         if (this->m_IsUseLibGit2)
1113         {
1114                 git_repository *repo = NULL;
1115
1116                 CStringA gitdir = CUnicodeUtils::GetMulti(CTGitPath(m_CurrentDir).GetGitPathString(), CP_UTF8);
1117                 if (git_repository_open(&repo, gitdir.GetBuffer()))
1118                 {
1119                         gitdir.ReleaseBuffer();
1120                         return -1;
1121                 }
1122                 gitdir.ReleaseBuffer();
1123
1124                 git_strarray tag_names;
1125
1126                 if (git_tag_list(&tag_names, repo))
1127                 {
1128                         git_repository_free(repo);
1129                         return -1;
1130                 }
1131
1132                 for (size_t i = 0; i < tag_names.count; i++)
1133                 {
1134                         CStringA tagName(tag_names.strings[i]);
1135                         list.push_back(CUnicodeUtils::GetUnicode(tagName));
1136                 }
1137
1138                 git_strarray_free(&tag_names);
1139
1140                 git_repository_free(repo);
1141
1142                 std::sort(list.begin(), list.end(), LogicalComparePredicate);
1143
1144                 return 0;
1145         }
1146         else
1147         {
1148                 CString cmd, output;
1149                 cmd=_T("git.exe tag -l");
1150                 int ret = Run(cmd, &output, NULL, CP_UTF8);
1151                 if(!ret)
1152                 {
1153                         int pos=0;
1154                         CString one;
1155                         while( pos>=0 )
1156                         {
1157                                 one=output.Tokenize(_T("\n"),pos);
1158                                 if (!one.IsEmpty())
1159                                         list.push_back(one);
1160                         }
1161                         std::sort(list.begin(), list.end(), LogicalComparePredicate);
1162                 }
1163                 return ret;
1164         }
1165 }
1166
1167 CString CGit::FixBranchName_Mod(CString& branchName)
1168 {
1169         if(branchName == "FETCH_HEAD")
1170                 branchName = DerefFetchHead();
1171         return branchName;
1172 }
1173
1174 CString CGit::FixBranchName(const CString& branchName)
1175 {
1176         CString tempBranchName = branchName;
1177         FixBranchName_Mod(tempBranchName);
1178         return tempBranchName;
1179 }
1180
1181 bool CGit::IsBranchTagNameUnique(const CString& name)
1182 {
1183         CString output;
1184
1185         CString cmd;
1186         cmd.Format(_T("git show-ref --tags --heads refs/heads/%s refs/tags/%s"), name, name);
1187         int ret = Run(cmd, &output, NULL, CP_UTF8);
1188         if (!ret)
1189         {
1190                 int i = 0, pos = 0;
1191                 while (pos >= 0)
1192                 {
1193                         if (!output.Tokenize(_T("\n"), pos).IsEmpty())
1194                                 i++;
1195                 }
1196                 if (i >= 2)
1197                         return false;
1198         }
1199
1200         return true;
1201 }
1202
1203 /*
1204 Checks if a branch or tag with the given name exists
1205 isBranch is true -> branch, tag otherwise
1206 */
1207 bool CGit::BranchTagExists(const CString& name, bool isBranch /*= true*/)
1208 {
1209         CString cmd, output;
1210
1211         cmd = _T("git show-ref ");
1212         if (isBranch)
1213                 cmd += _T("--heads ");
1214         else
1215                 cmd += _T("--tags ");
1216
1217         cmd += _T("refs/heads/") + name;
1218         cmd += _T(" refs/tags/") + name;
1219
1220         int ret = Run(cmd, &output, NULL, CP_UTF8);
1221         if (!ret)
1222         {
1223                 if (!output.IsEmpty())
1224                         return true;
1225         }
1226
1227         return false;
1228 }
1229
1230 CString CGit::DerefFetchHead()
1231 {
1232         using namespace std;
1233         CString dotGitPath;
1234         g_GitAdminDir.GetAdminDirPath(m_CurrentDir, dotGitPath);
1235         ifstream fetchHeadFile((dotGitPath + L"FETCH_HEAD").GetString(), ios::in | ios::binary);
1236         int forMergeLineCount = 0;
1237         string line;
1238         string hashToReturn;
1239         while(getline(fetchHeadFile, line))
1240         {
1241                 //Tokenize this line
1242                 string::size_type prevPos = 0;
1243                 string::size_type pos = line.find('\t');
1244                 if(pos == string::npos) continue; //invalid line
1245
1246                 string hash = line.substr(0, pos);
1247                 ++pos; prevPos = pos; pos = line.find('\t', pos); if(pos == string::npos) continue;
1248
1249                 bool forMerge = pos == prevPos;
1250                 ++pos; prevPos = pos; pos = line.size(); if(pos == string::npos) continue;
1251
1252                 string remoteBranch = line.substr(prevPos, pos - prevPos);
1253
1254                 //Process this line
1255                 if(forMerge)
1256                 {
1257                         hashToReturn = hash;
1258                         ++forMergeLineCount;
1259                         if(forMergeLineCount > 1)
1260                                 return L""; //More then 1 branch to merge found. Octopus merge needed. Cannot pick single ref from FETCH_HEAD
1261                 }
1262         }
1263
1264         return CUnicodeUtils::GetUnicode(hashToReturn.c_str());
1265 }
1266
1267 int CGit::GetBranchList(STRING_VECTOR &list,int *current,BRANCH_TYPE type)
1268 {
1269         int ret;
1270         CString cmd, output, cur;
1271         cmd = _T("git.exe branch --no-color");
1272
1273         if((type&BRANCH_ALL) == BRANCH_ALL)
1274                 cmd += _T(" -a");
1275         else if(type&BRANCH_REMOTE)
1276                 cmd += _T(" -r");
1277
1278         ret = Run(cmd, &output, NULL, CP_UTF8);
1279         if(!ret)
1280         {
1281                 int pos=0;
1282                 CString one;
1283                 while( pos>=0 )
1284                 {
1285                         one=output.Tokenize(_T("\n"),pos);
1286                         one.Trim(L" \r\n\t");
1287                         if(one.Find(L" -> ") >= 0 || one.IsEmpty())
1288                                 continue; // skip something like: refs/origin/HEAD -> refs/origin/master
1289                         if(one[0] == _T('*'))
1290                         {
1291                                 one = one.Mid(2);
1292                                 cur = one;
1293                         }
1294                         if (one != _T("(no branch)"))
1295                                 list.push_back(one);
1296                 }
1297         }
1298
1299         if(type & BRANCH_FETCH_HEAD && !DerefFetchHead().IsEmpty())
1300                 list.push_back(L"FETCH_HEAD");
1301
1302         std::sort(list.begin(), list.end(), LogicalComparePredicate);
1303
1304         if (current && cur != _T("(no branch)"))
1305         {
1306                 for (unsigned int i = 0; i < list.size(); i++)
1307                 {
1308                         if (list[i] == cur)
1309                         {
1310                                 *current = i;
1311                                 break;
1312                         }
1313                 }
1314         }
1315
1316         return ret;
1317 }
1318
1319 int CGit::GetRemoteList(STRING_VECTOR &list)
1320 {
1321         if (this->m_IsUseLibGit2)
1322         {
1323                 git_repository *repo = NULL;
1324
1325                 CStringA gitdir = CUnicodeUtils::GetMulti(CTGitPath(m_CurrentDir).GetGitPathString(), CP_UTF8);
1326                 if (git_repository_open(&repo, gitdir.GetBuffer()))
1327                 {
1328                         gitdir.ReleaseBuffer();
1329                         return -1;
1330                 }
1331                 gitdir.ReleaseBuffer();
1332
1333                 git_strarray remotes;
1334
1335                 if (git_remote_list(&remotes, repo))
1336                 {
1337                         git_repository_free(repo);
1338                         return -1;
1339                 }
1340
1341                 for (size_t i = 0; i < remotes.count; i++)
1342                 {
1343                         CStringA remote(remotes.strings[i]);
1344                         list.push_back(CUnicodeUtils::GetUnicode(remote));
1345                 }
1346
1347                 git_strarray_free(&remotes);
1348
1349                 git_repository_free(repo);
1350
1351                 std::sort(list.begin(), list.end());
1352
1353                 return 0;
1354         }
1355         else
1356         {
1357                 int ret;
1358                 CString cmd, output;
1359                 cmd=_T("git.exe remote");
1360                 ret = Run(cmd, &output, NULL, CP_UTF8);
1361                 if(!ret)
1362                 {
1363                         int pos=0;
1364                         CString one;
1365                         while( pos>=0 )
1366                         {
1367                                 one=output.Tokenize(_T("\n"),pos);
1368                                 if (!one.IsEmpty())
1369                                         list.push_back(one);
1370                         }
1371                 }
1372                 return ret;
1373         }
1374 }
1375
1376 int CGit::GetRemoteTags(CString remote, STRING_VECTOR &list)
1377 {
1378         CString cmd, out, err;
1379         cmd.Format(_T("git.exe ls-remote -t \"%s\""), remote);
1380         if (Run(cmd, &out, &err, CP_UTF8))
1381         {
1382                 MessageBox(NULL, err, _T("TortoiseGit"), MB_ICONERROR);
1383                 return -1;
1384         }
1385
1386         int pos = 0;
1387         while (pos >= 0)
1388         {
1389                 CString one = out.Tokenize(_T("\n"), pos).Mid(51).Trim(); // sha1, tab + refs/tags/
1390                 // dot not include annotated tags twice; this works, because an annotated tag appears twice (one normal tag and one with ^{} at the end)
1391                 if (one.Find(_T("^{}")) >= 1)
1392                         continue;
1393                 if (!one.IsEmpty())
1394                         list.push_back(one);
1395         }
1396         std::sort(list.begin(), list.end(), LogicalComparePredicate);
1397         return 0;
1398 }
1399
1400 int CGit::GetRefList(STRING_VECTOR &list)
1401 {
1402         int ret;
1403         if(this->m_IsUseGitDLL)
1404         {
1405                 CAutoLocker lock(g_Git.m_critGitDllSec);
1406                 ret = git_for_each_ref_in("",addto_list_each_ref_fn, &list);
1407                 std::sort(list.begin(), list.end(), LogicalComparePredicate);
1408         }
1409         else
1410         {
1411                 CString cmd, output;
1412                 cmd=_T("git.exe show-ref -d");
1413                 ret = Run(cmd, &output, NULL, CP_UTF8);
1414                 if(!ret)
1415                 {
1416                         int pos=0;
1417                         CString one;
1418                         while( pos>=0 )
1419                         {
1420                                 one=output.Tokenize(_T("\n"),pos);
1421                                 int start=one.Find(_T(" "),0);
1422                                 if(start>0)
1423                                 {
1424                                         CString name;
1425                                         name=one.Right(one.GetLength()-start-1);
1426                                         list.push_back(name);
1427                                 }
1428                         }
1429                         std::sort(list.begin(), list.end(), LogicalComparePredicate);
1430                 }
1431         }
1432         return ret;
1433 }
1434
1435 int addto_map_each_ref_fn(const char *refname, const unsigned char *sha1, int /*flags*/, void *cb_data)
1436 {
1437         MAP_HASH_NAME *map = (MAP_HASH_NAME*)cb_data;
1438         CString str;
1439         g_Git.StringAppend(&str, (BYTE*)refname, CP_UTF8);
1440         CGitHash hash((char*)sha1);
1441
1442         (*map)[hash].push_back(str);
1443
1444         if(strncmp(refname, "refs/tags", 9) == 0)
1445         {
1446                 try
1447                 {
1448                         GIT_HASH refhash;
1449                         if(!git_deref_tag(sha1, refhash))
1450                         {
1451                                 (*map)[(char*)refhash].push_back(str+_T("^{}"));
1452                         }
1453                 }
1454                 catch (char* msg)
1455                 {
1456                         CString err(msg);
1457                         ::MessageBox(NULL, _T("Could not get (readable) reference for hash ") + hash.ToString() + _T(".\nlibgit reports:\n") + err, _T("TortoiseGit"), MB_ICONERROR);
1458                 }
1459         }
1460         return 0;
1461 }
1462
1463 int CGit::GetMapHashToFriendName(MAP_HASH_NAME &map)
1464 {
1465         int ret;
1466         if(this->m_IsUseGitDLL)
1467         {
1468                 CAutoLocker lock(g_Git.m_critGitDllSec);
1469                 return git_for_each_ref_in("",addto_map_each_ref_fn, &map);
1470
1471         }
1472         else
1473         {
1474                 CString cmd, output;
1475                 cmd=_T("git.exe show-ref -d");
1476                 ret = Run(cmd, &output, NULL, CP_UTF8);
1477                 if(!ret)
1478                 {
1479                         int pos=0;
1480                         CString one;
1481                         while( pos>=0 )
1482                         {
1483                                 one=output.Tokenize(_T("\n"),pos);
1484                                 int start=one.Find(_T(" "),0);
1485                                 if(start>0)
1486                                 {
1487                                         CString name;
1488                                         name=one.Right(one.GetLength()-start-1);
1489
1490                                         CString hash;
1491                                         hash=one.Left(start);
1492
1493                                         map[CGitHash(hash)].push_back(name);
1494                                 }
1495                         }
1496                 }
1497         }
1498         return ret;
1499 }
1500
1501 BOOL CGit::CheckMsysGitDir()
1502 {
1503         if (m_bInitialized)
1504         {
1505                 return TRUE;
1506         }
1507
1508         this->m_Environment.clear();
1509         m_Environment.CopyProcessEnvironment();
1510
1511         TCHAR *oldpath;
1512         size_t homesize,size;
1513
1514         // set HOME if not set already
1515         _tgetenv_s(&homesize, NULL, 0, _T("HOME"));
1516         if (!homesize)
1517         {
1518                 CString home = GetHomeDirectory();
1519                 m_Environment.SetEnv(_T("HOME"), home.GetBuffer());
1520                 home.ReleaseBuffer();
1521         }
1522         CString str;
1523
1524         //setup ssh client
1525         CString sshclient=CRegString(_T("Software\\TortoiseGit\\SSH"));
1526
1527         if(!sshclient.IsEmpty())
1528         {
1529                 m_Environment.SetEnv(_T("GIT_SSH"), sshclient.GetBuffer());
1530                 m_Environment.SetEnv(_T("SVN_SSH"), sshclient.GetBuffer());
1531         }
1532         else
1533         {
1534                 TCHAR sPlink[MAX_PATH];
1535                 GetModuleFileName(NULL, sPlink, _countof(sPlink));
1536                 LPTSTR ptr = _tcsrchr(sPlink, _T('\\'));
1537                 if (ptr) {
1538                         _tcscpy_s(ptr + 1, MAX_PATH - (ptr - sPlink + 1), _T("TortoiseGitPLink.exe"));
1539                         m_Environment.SetEnv(_T("GIT_SSH"), sPlink);
1540                         m_Environment.SetEnv(_T("SVN_SSH"), sPlink);
1541                 }
1542         }
1543
1544         {
1545                 TCHAR sAskPass[MAX_PATH];
1546                 GetModuleFileName(NULL, sAskPass, _countof(sAskPass));
1547                 LPTSTR ptr = _tcsrchr(sAskPass, _T('\\'));
1548                 if (ptr)
1549                 {
1550                         _tcscpy_s(ptr + 1, MAX_PATH - (ptr - sAskPass + 1), _T("SshAskPass.exe"));
1551                         m_Environment.SetEnv(_T("DISPLAY"),_T(":9999"));
1552                         m_Environment.SetEnv(_T("SSH_ASKPASS"),sAskPass);
1553                         m_Environment.SetEnv(_T("GIT_ASKPASS"),sAskPass);
1554                 }
1555         }
1556
1557         // add git/bin path to PATH
1558
1559         CRegString msysdir=CRegString(REG_MSYSGIT_PATH,_T(""),FALSE);
1560         str=msysdir;
1561         if(str.IsEmpty() || !FileExists(str + _T("\\git.exe")))
1562         {
1563                 CRegString msysinstalldir=CRegString(REG_MSYSGIT_INSTALL,_T(""),FALSE,HKEY_LOCAL_MACHINE);
1564                 str=msysinstalldir;
1565                 str.TrimRight(_T("\\"));
1566                 if ( !str.IsEmpty() )
1567                 {
1568                         str += "\\bin";
1569                         msysdir=str;
1570                         CGit::ms_LastMsysGitDir = str;
1571                         msysdir.write();
1572                 }
1573                 else
1574                 {
1575                         // search PATH if git/bin directory is already present
1576                         if ( FindGitPath() )
1577                         {
1578                                 m_bInitialized = TRUE;
1579                                 msysdir = CGit::ms_LastMsysGitDir;
1580                                 msysdir.write();
1581                                 return TRUE;
1582                         }
1583
1584                         return FALSE;
1585                 }
1586         }
1587         else
1588         {
1589                 CGit::ms_LastMsysGitDir = str;
1590         }
1591
1592         // check for git.exe existance (maybe it was deinstalled in the meantime)
1593         if (!FileExists(CGit::ms_LastMsysGitDir + _T("\\git.exe")))
1594                 return FALSE;
1595
1596         //set path
1597         _tdupenv_s(&oldpath,&size,_T("PATH"));
1598
1599         CString path;
1600         path.Format(_T("%s;%s"),oldpath,str + _T(";")+ (CString)CRegString(REG_MSYSGIT_EXTRA_PATH,_T(""),FALSE));
1601
1602         m_Environment.SetEnv(_T("PATH"),path.GetBuffer());
1603
1604         CString str1 = m_Environment.GetEnv(_T("PATH"));
1605
1606         CString sOldPath = oldpath;
1607         free(oldpath);
1608
1609         m_bInitialized = TRUE;
1610         return true;
1611 }
1612
1613 CString CGit::GetHomeDirectory()
1614 {
1615         const wchar_t * homeDir = wget_windows_home_directory();
1616         return CString(homeDir, (int)wcslen(homeDir));
1617 }
1618
1619 CString CGit::GetGitLocalConfig()
1620 {
1621         CString path;
1622         g_GitAdminDir.GetAdminDirPath(g_Git.m_CurrentDir, path);
1623         path += _T("config");
1624         return path;
1625 }
1626
1627 CString CGit::GetGitGlobalConfig()
1628 {
1629         return g_Git.GetHomeDirectory() + _T("\\.gitconfig");
1630 }
1631
1632 CString CGit::GetGitGlobalXDGConfigPath()
1633 {
1634         return g_Git.GetHomeDirectory() + _T("\\.config\\git");
1635 }
1636
1637 CString CGit::GetGitGlobalXDGConfig()
1638 {
1639         return g_Git.GetGitGlobalXDGConfigPath() + _T("\\config");
1640 }
1641
1642 CString CGit::GetGitSystemConfig()
1643 {
1644         const wchar_t * systemConfig = wget_msysgit_etc();
1645         return CString(systemConfig, (int)wcslen(systemConfig));
1646 }
1647
1648 BOOL CGit::CheckCleanWorkTree()
1649 {
1650         CString out;
1651         CString cmd;
1652         cmd=_T("git.exe rev-parse --verify HEAD");
1653
1654         if(Run(cmd,&out,CP_UTF8))
1655                 return FALSE;
1656
1657         cmd=_T("git.exe update-index --ignore-submodules --refresh");
1658         if(Run(cmd,&out,CP_UTF8))
1659                 return FALSE;
1660
1661         cmd=_T("git.exe diff-files --quiet --ignore-submodules");
1662         if(Run(cmd,&out,CP_UTF8))
1663                 return FALSE;
1664
1665         cmd=_T("git diff-index --cached --quiet HEAD --ignore-submodules");
1666         if(Run(cmd,&out,CP_UTF8))
1667                 return FALSE;
1668
1669         return TRUE;
1670 }
1671 int CGit::Revert(CString commit, CTGitPathList &list, bool)
1672 {
1673         int ret;
1674         for(int i=0;i<list.GetCount();i++)
1675         {
1676                 ret = Revert(commit, (CTGitPath&)list[i]);
1677                 if(ret)
1678                         return ret;
1679         }
1680         return 0;
1681 }
1682 int CGit::Revert(CString commit, CTGitPath &path)
1683 {
1684         CString cmd, out;
1685
1686         if(path.m_Action & CTGitPath::LOGACTIONS_REPLACED && !path.GetGitOldPathString().IsEmpty())
1687         {
1688                 if (CTGitPath(path.GetGitOldPathString()).IsDirectory())
1689                 {
1690                         CString err;
1691                         err.Format(_T("Cannot revert renaming of \"%s\". A directory with the old name \"%s\" exists."), path.GetGitPathString(), path.GetGitOldPathString());
1692                         ::MessageBox(NULL, err, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
1693                         return -1;
1694                 }
1695                 CString force;
1696                 // if the filenames only differ in case, we have to pass "-f"
1697                 if (path.GetGitPathString().CompareNoCase(path.GetGitOldPathString()) == 0)
1698                         force = _T("-f ");
1699                 cmd.Format(_T("git.exe mv %s-- \"%s\" \"%s\""), force, path.GetGitPathString(), path.GetGitOldPathString());
1700                 if (Run(cmd, &out, CP_UTF8))
1701                 {
1702                         ::MessageBox(NULL, out, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
1703                         return -1;
1704                 }
1705
1706                 cmd.Format(_T("git.exe checkout %s -f -- \"%s\""), commit, path.GetGitOldPathString());
1707                 if (Run(cmd, &out, CP_UTF8))
1708                 {
1709                         ::MessageBox(NULL, out, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
1710                         return -1;
1711                 }
1712
1713         }
1714         else if(path.m_Action & CTGitPath::LOGACTIONS_ADDED)
1715         {       //To init git repository, there are not HEAD, so we can use git reset command
1716                 cmd.Format(_T("git.exe rm -f --cached -- \"%s\""),path.GetGitPathString());
1717
1718                 if (Run(cmd, &out, CP_UTF8))
1719                 {
1720                         ::MessageBox(NULL, out, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
1721                         return -1;
1722                 }
1723         }
1724         else
1725         {
1726                 cmd.Format(_T("git.exe checkout %s -f -- \"%s\""), commit, path.GetGitPathString());
1727                 if (Run(cmd, &out, CP_UTF8))
1728                 {
1729                         ::MessageBox(NULL, out, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
1730                         return -1;
1731                 }
1732         }
1733
1734         if (path.m_Action & CTGitPath::LOGACTIONS_DELETED)
1735         {
1736                 cmd.Format(_T("git.exe add -f -- \"%s\""), path.GetGitPathString());
1737                 if (Run(cmd, &out, CP_UTF8))
1738                 {
1739                         ::MessageBox(NULL, out, _T("TortoiseGit"), MB_OK|MB_ICONERROR);
1740                         return -1;
1741                 }
1742         }
1743
1744         return 0;
1745 }
1746
1747 int CGit::ListConflictFile(CTGitPathList &list,CTGitPath *path)
1748 {
1749         BYTE_VECTOR vector;
1750
1751         CString cmd;
1752         if(path)
1753                 cmd.Format(_T("git.exe ls-files -u -t -z -- \"%s\""),path->GetGitPathString());
1754         else
1755                 cmd=_T("git.exe ls-files -u -t -z");
1756
1757         if (Run(cmd, &vector))
1758         {
1759                 return -1;
1760         }
1761
1762         list.ParserFromLsFile(vector);
1763
1764         return 0;
1765 }
1766
1767 bool CGit::IsFastForward(const CString &from, const CString &to, CGitHash * commonAncestor)
1768 {
1769         CString base;
1770         CGitHash basehash,hash;
1771         CString cmd, err;
1772         cmd.Format(_T("git.exe merge-base %s %s"), FixBranchName(to), FixBranchName(from));
1773
1774         if (Run(cmd, &base, &err, CP_UTF8))
1775         {
1776                 return false;
1777         }
1778         basehash = base.Trim();
1779
1780         hash = GetHash(from);
1781
1782         if (commonAncestor)
1783                 *commonAncestor = basehash;
1784
1785         return hash == basehash;
1786 }
1787
1788 unsigned int CGit::Hash2int(CGitHash &hash)
1789 {
1790         int ret=0;
1791         for(int i=0;i<4;i++)
1792         {
1793                 ret = ret << 8;
1794                 ret |= hash.m_hash[i];
1795         }
1796         return ret;
1797 }
1798
1799 int CGit::RefreshGitIndex()
1800 {
1801         if(g_Git.m_IsUseGitDLL)
1802         {
1803                 CAutoLocker lock(g_Git.m_critGitDllSec);
1804                 try
1805                 {
1806                         return git_run_cmd("update-index","update-index -q --refresh");
1807
1808                 }catch(...)
1809                 {
1810                         return -1;
1811                 }
1812
1813         }
1814         else
1815         {
1816                 CString cmd,output;
1817                 cmd=_T("git.exe update-index --refresh");
1818                 return Run(cmd, &output, CP_UTF8);
1819         }
1820 }
1821
1822 int CGit::GetOneFile(CString Refname, CTGitPath &path, const CString &outputfile)
1823 {
1824         if(g_Git.m_IsUseGitDLL)
1825         {
1826                 CAutoLocker lock(g_Git.m_critGitDllSec);
1827                 try
1828                 {
1829                         g_Git.CheckAndInitDll();
1830                         CStringA ref, patha, outa;
1831                         ref = CUnicodeUtils::GetMulti(Refname, CP_UTF8);
1832                         patha = CUnicodeUtils::GetMulti(path.GetGitPathString(), CP_UTF8);
1833                         outa = CUnicodeUtils::GetMulti(outputfile, CP_UTF8);
1834                         ::DeleteFile(outputfile);
1835                         return git_checkout_file((const char*)ref.GetBuffer(),(const char*)patha.GetBuffer(),(const char*)outa.GetBuffer());
1836
1837                 }catch(...)
1838                 {
1839                         return -1;
1840                 }
1841         }
1842         else
1843         {
1844                 CString cmd;
1845                 cmd.Format(_T("git.exe cat-file -p %s:\"%s\""), Refname, path.GetGitPathString());
1846                 return RunLogFile(cmd,outputfile);
1847         }
1848 }
1849 void CEnvironment::CopyProcessEnvironment()
1850 {
1851         TCHAR *p = GetEnvironmentStrings();
1852         while(*p !=0 || *(p+1) !=0)
1853                 this->push_back(*p++);
1854
1855         push_back(_T('\0'));
1856         push_back(_T('\0'));
1857 }
1858
1859 CString CEnvironment::GetEnv(TCHAR *name)
1860 {
1861         CString str;
1862         for (size_t i = 0; i < size(); i++)
1863         {
1864                 str = &(*this)[i];
1865                 int start =0;
1866                 CString sname = str.Tokenize(_T("="),start);
1867                 if(sname.CompareNoCase(name) == 0)
1868                 {
1869                         return &(*this)[i+start];
1870                 }
1871                 i+=str.GetLength();
1872         }
1873         return _T("");
1874 }
1875
1876 void CEnvironment::SetEnv(TCHAR *name, TCHAR* value)
1877 {
1878         unsigned int i;
1879         for( i=0;i<size();i++)
1880         {
1881                 CString str = &(*this)[i];
1882                 int start =0;
1883                 CString sname = str.Tokenize(_T("="),start);
1884                 if(sname.CompareNoCase(name) == 0)
1885                 {
1886                         break;
1887                 }
1888                 i+=str.GetLength();
1889         }
1890
1891         if(i == size())
1892         {
1893                 i -= 1; // roll back terminate \0\0
1894                 this->push_back(_T('\0'));
1895         }
1896
1897         CEnvironment::iterator it;
1898         it=this->begin();
1899         it += i;
1900
1901         while(*it && i<size())
1902         {
1903                 this->erase(it);
1904                 it=this->begin();
1905                 it += i;
1906         }
1907
1908         while(*name)
1909         {
1910                 this->insert(it,*name++);
1911                 i++;
1912                 it= begin()+i;
1913         }
1914
1915         this->insert(it, _T('='));
1916         i++;
1917         it= begin()+i;
1918
1919         while(*value)
1920         {
1921                 this->insert(it,*value++);
1922                 i++;
1923                 it= begin()+i;
1924         }
1925
1926 }
1927
1928 int CGit::GetGitEncode(TCHAR* configkey)
1929 {
1930         CString str=GetConfigValue(configkey);
1931
1932         if(str.IsEmpty())
1933                 return CP_UTF8;
1934
1935         return CUnicodeUtils::GetCPCode(str);
1936 }
1937
1938
1939 int CGit::GetDiffPath(CTGitPathList *PathList, CGitHash *hash1, CGitHash *hash2, char *arg)
1940 {
1941         GIT_FILE file=0;
1942         int ret=0;
1943         GIT_DIFF diff=0;
1944
1945         CAutoLocker lock(g_Git.m_critGitDllSec);
1946
1947         if(arg == NULL)
1948                 diff = GetGitDiff();
1949         else
1950                 git_open_diff(&diff, arg);
1951
1952         if(diff ==NULL)
1953                 return -1;
1954
1955         bool isStat = 0;
1956         if(arg == NULL)
1957                 isStat = true;
1958         else
1959                 isStat = !!strstr(arg, "stat");
1960
1961         int count=0;
1962
1963         if(hash2 == NULL)
1964                 ret = git_root_diff(diff, hash1->m_hash, &file, &count,isStat);
1965         else
1966                 ret = git_diff(diff,hash2->m_hash,hash1->m_hash,&file,&count,isStat);
1967
1968         if(ret)
1969                 return -1;
1970
1971         CTGitPath path;
1972         CString strnewname;
1973         CString stroldname;
1974
1975         for(int j=0;j<count;j++)
1976         {
1977                 path.Reset();
1978                 char *newname;
1979                 char *oldname;
1980
1981                 strnewname.Empty();
1982                 stroldname.Empty();
1983
1984                 int mode=0,IsBin=0,inc=0,dec=0;
1985                 git_get_diff_file(diff,file,j,&newname,&oldname,
1986                                         &mode,&IsBin,&inc,&dec);
1987
1988                 StringAppend(&strnewname, (BYTE*)newname, CP_UTF8);
1989                 StringAppend(&stroldname, (BYTE*)oldname, CP_UTF8);
1990
1991                 path.SetFromGit(strnewname,&stroldname);
1992                 path.ParserAction((BYTE)mode);
1993
1994                 if(IsBin)
1995                 {
1996                         path.m_StatAdd=_T("-");
1997                         path.m_StatDel=_T("-");
1998                 }
1999                 else
2000                 {
2001                         path.m_StatAdd.Format(_T("%d"),inc);
2002                         path.m_StatDel.Format(_T("%d"),dec);
2003                 }
2004                 PathList->AddPath(path);
2005         }
2006         git_diff_flush(diff);
2007
2008         if(arg)
2009                 git_close_diff(diff);
2010
2011         return 0;
2012 }
2013
2014 int CGit::GetShortHASHLength()
2015 {
2016         return 7;
2017 }
2018
2019 CString CGit::GetShortName(CString ref, REF_TYPE *out_type)
2020 {
2021         CString str=ref;
2022         CString shortname;
2023         REF_TYPE type;
2024
2025         if (CGit::GetShortName(str, shortname, _T("refs/heads/")))
2026         {
2027                 type = CGit::LOCAL_BRANCH;
2028
2029         }
2030         else if (CGit::GetShortName(str, shortname, _T("refs/remotes/")))
2031         {
2032                 type = CGit::REMOTE_BRANCH;
2033         }
2034         else if (CGit::GetShortName(str, shortname, _T("refs/tags/")))
2035         {
2036                 type = CGit::TAG;
2037         }
2038         else if (CGit::GetShortName(str, shortname, _T("refs/stash")))
2039         {
2040                 type = CGit::STASH;
2041                 shortname=_T("stash");
2042         }
2043         else if (CGit::GetShortName(str, shortname, _T("refs/bisect/")))
2044         {
2045                 if (shortname.Find(_T("good")) == 0)
2046                 {
2047                         type = CGit::BISECT_GOOD;
2048                         shortname = _T("good");
2049                 }
2050
2051                 if (shortname.Find(_T("bad")) == 0)
2052                 {
2053                         type = CGit::BISECT_BAD;
2054                         shortname = _T("bad");
2055                 }
2056         }
2057         else if (CGit::GetShortName(str, shortname, _T("refs/notes/")))
2058         {
2059                 type = CGit::NOTES;
2060         }
2061         else
2062         {
2063                 type = CGit::UNKNOWN;
2064                 shortname = _T("Unknown");
2065         }
2066
2067         if(out_type)
2068                 *out_type = type;
2069
2070         return shortname;
2071 }