src/Git/GitIndex.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2008-2013 - 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 "TGitPath.h"
  29 #include "gitindex.h"
  30 #include <sys/types.h>
  31 #include <sys/stat.h>
  32 #include "SmartHandle.h"
  33
  34 class CAutoReadLock
  35 {
  36         SharedMutex *m_Lock;
  37 public:
  38         CAutoReadLock(SharedMutex * lock)
  39         {
  40                 m_Lock = lock;
  41                 lock->AcquireShared();
  42         }
  43         ~CAutoReadLock()
  44         {
  45                 m_Lock->ReleaseShared();
  46         }
  47 };
  48
  49 class CAutoWriteLock
  50 {
  51         SharedMutex *m_Lock;
  52 public:
  53         CAutoWriteLock(SharedMutex * lock)
  54         {
  55                 m_Lock = lock;
  56                 lock->AcquireExclusive();
  57         }
  58         ~CAutoWriteLock()
  59         {
  60                 m_Lock->ReleaseExclusive();
  61         }
  62 };
  63
  64 CGitAdminDirMap g_AdminDirMap;
  65
  66 int CGitIndex::Print()
  67 {
  68         _tprintf(_T("0x%08X  0x%08X %s %s\n"),
  69                 (int)this->m_ModifyTime,
  70                 this->m_Flags,
  71                 this->m_IndexHash.ToString(),
  72                 this->m_FileName);
  73
  74         return 0;
  75 }
  76
  77 CGitIndexList::CGitIndexList()
  78 {
  79         this->m_LastModifyTime = 0;
  80         m_critRepoSec.Init();
  81         repository = NULL;
  82         m_bCheckContent = !!(CRegDWORD(_T("Software\\TortoiseGit\\TGitCacheCheckContent"), TRUE) == TRUE);
  83 }
  84
  85 CGitIndexList::~CGitIndexList()
  86 {
  87         if (repository != NULL)
  88         {
  89                 git_repository_free(repository);
  90                 m_critRepoSec.Term();
  91         }
  92 }
  93
  94 static bool SortIndex(CGitIndex &Item1, CGitIndex &Item2)
  95 {
  96         return Item1.m_FileName.Compare(Item2.m_FileName) < 0;
  97 }
  98
  99 static bool SortTree(CGitTreeItem &Item1, CGitTreeItem &Item2)
 100 {
 101         return Item1.m_FileName.Compare(Item2.m_FileName) < 0;
 102 }
 103
 104 int CGitIndexList::ReadIndex(CString dgitdir)
 105 {
 106         this->clear();
 107
 108         CStringA gitdir = CUnicodeUtils::GetMulti(dgitdir, CP_UTF8);
 109
 110         m_critRepoSec.Lock();
 111         if (repository != NULL)
 112         {
 113                 git_repository_free(repository);
 114                 repository = NULL;
 115         }
 116         git_index *index = NULL;
 117
 118         int ret = git_repository_open(&repository, gitdir.GetBuffer());
 119         gitdir.ReleaseBuffer();
 120         if (ret)
 121                 return -1;
 122
 123         // add config files
 124         git_config * config;
 125         git_config_new(&config);
 126
 127         CString projectConfig = dgitdir + _T("config");
 128         CString globalConfig = g_Git.GetGitGlobalConfig();
 129         CString globalXDGConfig = g_Git.GetGitGlobalXDGConfig();
 130         CString msysGitBinPath(CRegString(REG_MSYSGIT_PATH, _T(""), FALSE));
 131
 132         CStringA projectConfigA = CUnicodeUtils::GetMulti(projectConfig, CP_UTF8);
 133         git_config_add_file_ondisk(config, projectConfigA.GetBuffer(), 4, FALSE);
 134         projectConfigA.ReleaseBuffer();
 135         CStringA globalConfigA = CUnicodeUtils::GetMulti(globalConfig, CP_UTF8);
 136         git_config_add_file_ondisk(config, globalConfigA.GetBuffer(), 3, FALSE);
 137         globalConfigA.ReleaseBuffer();
 138         CStringA globalXDGConfigA = CUnicodeUtils::GetMulti(globalXDGConfig, CP_UTF8);
 139         git_config_add_file_ondisk(config, globalXDGConfigA.GetBuffer(), 2, FALSE);
 140         globalXDGConfigA.ReleaseBuffer();
 141         if (!msysGitBinPath.IsEmpty())
 142         {
 143                 CString systemConfig = msysGitBinPath + _T("\\..\\etc\\gitconfig");
 144                 CStringA systemConfigA = CUnicodeUtils::GetMulti(systemConfig, CP_UTF8);
 145                 git_config_add_file_ondisk(config, systemConfigA.GetBuffer(), 1, FALSE);
 146                 systemConfigA.ReleaseBuffer();
 147         }
 148
 149         git_repository_set_config(repository, config);
 150
 151         // load index in order to enumerate files
 152         if (git_repository_index(&index, repository))
 153         {
 154                 repository = NULL;
 155                 m_critRepoSec.Unlock();
 156                 return -1;
 157         }
 158
 159         size_t ecount = git_index_entrycount(index);
 160         resize(ecount);
 161         for (size_t i = 0; i < ecount; ++i)
 162         {
 163                 const git_index_entry *e = git_index_get_byindex(index, i);
 164
 165                 this->at(i).m_FileName.Empty();
 166                 g_Git.StringAppend(&this->at(i).m_FileName, (BYTE*)e->path, CP_UTF8);
 167                 this->at(i).m_FileName.MakeLower();
 168                 this->at(i).m_ModifyTime = e->mtime.seconds;
 169                 this->at(i).m_Flags = e->flags | e->flags_extended;
 170                 this->at(i).m_IndexHash = (char *) e->oid.id;
 171         }
 172
 173         git_index_free(index);
 174
 175         g_Git.GetFileModifyTime(dgitdir + _T("index"), &this->m_LastModifyTime);
 176         std::sort(this->begin(), this->end(), SortIndex);
 177
 178         m_critRepoSec.Unlock();
 179
 180         return 0;
 181 }
 182
 183 int CGitIndexList::GetFileStatus(const CString &gitdir,const CString &pathorg,git_wc_status_kind *status,__int64 time,FIll_STATUS_CALLBACK callback,void *pData, CGitHash *pHash, bool * assumeValid, bool * skipWorktree)
 184 {
 185         if(status)
 186         {
 187                 CString path = pathorg;
 188                 path.MakeLower();
 189
 190                 int start = SearchInSortVector(*this, ((CString&)path).GetBuffer(), -1);
 191                 ((CString&)path).ReleaseBuffer();
 192
 193                 if (start < 0)
 194                 {
 195                         *status = git_wc_status_unversioned;
 196                         if (pHash)
 197                                 pHash->Empty();
 198
 199                 }
 200                 else
 201                 {
 202                         int index = start;
 203                         if (index <0)
 204                                 return -1;
 205                         if (index >= (int)size())
 206                                 return -1;
 207
 208                         // skip-worktree has higher priority than assume-valid
 209                         if (at(index).m_Flags & GIT_IDXENTRY_SKIP_WORKTREE)
 210                         {
 211                                 *status = git_wc_status_normal;
 212                                 if (skipWorktree)
 213                                         *skipWorktree = true;
 214                         }
 215                         else if (at(index).m_Flags & GIT_IDXENTRY_VALID)
 216                         {
 217                                 *status = git_wc_status_normal;
 218                                 if (assumeValid)
 219                                         *assumeValid = true;
 220                         }
 221                         else if (time == at(index).m_ModifyTime)
 222                         {
 223                                 *status = git_wc_status_normal;
 224                         }
 225                         else if (m_bCheckContent && repository)
 226                         {
 227                                 git_oid actual;
 228                                 CStringA fileA = CUnicodeUtils::GetMulti(pathorg, CP_UTF8);
 229                                 m_critRepoSec.Lock(); // prevent concurrent access to repository instance and especially filter-lists
 230                                 if (!git_repository_hashfile(&actual, repository, fileA.GetBuffer(), GIT_OBJ_BLOB, NULL) && !git_oid_cmp(&actual, (const git_oid*)at(index).m_IndexHash.m_hash))
 231                                 {
 232                                         at(index).m_ModifyTime = time;
 233                                         *status = git_wc_status_normal;
 234                                 }
 235                                 else
 236                                         *status = git_wc_status_modified;
 237                                 fileA.ReleaseBuffer();
 238                                 m_critRepoSec.Unlock();
 239                         }
 240                         else
 241                                 *status = git_wc_status_modified;
 242
 243                         if (at(index).m_Flags & GIT_IDXENTRY_STAGEMASK)
 244                                 *status = git_wc_status_conflicted;
 245                         else if (at(index).m_Flags & GIT_IDXENTRY_INTENT_TO_ADD)
 246                                 *status = git_wc_status_added;
 247
 248                         if(pHash)
 249                                 *pHash = at(index).m_IndexHash;
 250                 }
 251
 252         }
 253
 254         if(callback && status)
 255                         callback(gitdir + _T("\\") + pathorg, *status, false, pData, *assumeValid, *skipWorktree);
 256         return 0;
 257 }
 258
 259 int CGitIndexList::GetStatus(const CString &gitdir,const CString &pathParam, git_wc_status_kind *status,
 260                                                          BOOL IsFull, BOOL /*IsRecursive*/,
 261                                                          FIll_STATUS_CALLBACK callback,void *pData,
 262                                                          CGitHash *pHash, bool * assumeValid, bool * skipWorktree)
 263 {
 264         int result;
 265         git_wc_status_kind dirstatus = git_wc_status_none;
 266         __int64 time;
 267         bool isDir = false;
 268         CString path = pathParam;
 269
 270         if (status)
 271         {
 272                 if (path.IsEmpty())
 273                         result = g_Git.GetFileModifyTime(gitdir, &time, &isDir);
 274                 else
 275                         result = g_Git.GetFileModifyTime(gitdir + _T("\\") + path, &time, &isDir);
 276
 277                 if (result)
 278                 {
 279                         *status = git_wc_status_deleted;
 280                         if (callback)
 281                                 callback(gitdir + _T("\\") + path, git_wc_status_deleted, false, pData, *assumeValid, *skipWorktree);
 282
 283                         return 0;
 284                 }
 285                 if (isDir)
 286                 {
 287                         if (!path.IsEmpty())
 288                         {
 289                                 if (path.Right(1) != _T("\\"))
 290                                         path += _T("\\");
 291                         }
 292                         int len = path.GetLength();
 293
 294                                 for (size_t i = 0; i < size(); ++i)
 295                                 {
 296                                         if (at(i).m_FileName.GetLength() > len)
 297                                         {
 298                                                 if (at(i).m_FileName.Left(len) == path)
 299                                                 {
 300                                                         if (!IsFull)
 301                                                         {
 302                                                                 *status = git_wc_status_normal;
 303                                                                 if (callback)
 304                                                                         callback(gitdir + _T("\\") + path, *status, false, pData, (at(i).m_Flags & GIT_IDXENTRY_VALID) && !(at(i).m_Flags & GIT_IDXENTRY_SKIP_WORKTREE), (at(i).m_Flags & GIT_IDXENTRY_SKIP_WORKTREE) != 0);
 305                                                                 return 0;
 306
 307                                                         }
 308                                                         else
 309                                                         {
 310                                                                 result = g_Git.GetFileModifyTime(gitdir+_T("\\") + at(i).m_FileName, &time);
 311                                                                 if (result)
 312                                                                         continue;
 313
 314                                                                 *status = git_wc_status_none;
 315                                                                 if (assumeValid)
 316                                                                         *assumeValid = false;
 317                                                                 if (skipWorktree)
 318                                                                         *skipWorktree = false;
 319                                                                 GetFileStatus(gitdir, at(i).m_FileName, status, time, callback, pData, NULL, assumeValid, skipWorktree);
 320                                                                 // if a file is assumed valid, we need to inform the caller, otherwise the assumevalid flag might not get to the explorer on first open of a repository
 321                                                                 if (callback && (assumeValid || skipWorktree))
 322                                                                         callback(gitdir + _T("\\") + path, *status, false, pData, *assumeValid, *skipWorktree);
 323                                                                 if (*status != git_wc_status_none)
 324                                                                 {
 325                                                                         if (dirstatus == git_wc_status_none)
 326                                                                         {
 327                                                                                 dirstatus = git_wc_status_normal;
 328                                                                         }
 329                                                                         if (*status != git_wc_status_normal)
 330                                                                         {
 331                                                                                 dirstatus = git_wc_status_modified;
 332                                                                         }
 333                                                                 }
 334
 335                                                         }
 336                                                 }
 337                                         }
 338                                 } /* End For */
 339
 340                         if (dirstatus != git_wc_status_none)
 341                         {
 342                                 *status = dirstatus;
 343                         }
 344                         else
 345                         {
 346                                 *status = git_wc_status_unversioned;
 347                         }
 348                         if(callback)
 349                                 callback(gitdir + _T("\\") + path, *status, false, pData, false, false);
 350
 351                         return 0;
 352
 353                 }
 354                 else
 355                 {
 356                         GetFileStatus(gitdir, path, status, time, callback, pData, pHash, assumeValid, skipWorktree);
 357                 }
 358         }
 359         return 0;
 360 }
 361
 362 int CGitIndexFileMap::Check(const CString &gitdir, bool *isChanged)
 363 {
 364         __int64 time;
 365         int result;
 366
 367         CString IndexFile = g_AdminDirMap.GetAdminDir(gitdir) + _T("index");
 368
 369         /* Get data associated with "crt_stat.c": */
 370         result = g_Git.GetFileModifyTime(IndexFile, &time);
 371
 372         if (result)
 373                 return result;
 374
 375         SHARED_INDEX_PTR pIndex;
 376         pIndex = this->SafeGet(gitdir);
 377
 378         if (pIndex.get() == NULL)
 379         {
 380                 if(isChanged)
 381                         *isChanged = true;
 382                 return 0;
 383         }
 384
 385         if (pIndex->m_LastModifyTime == time)
 386         {
 387                 if (isChanged)
 388                         *isChanged = false;
 389         }
 390         else
 391         {
 392                 if (isChanged)
 393                         *isChanged = true;
 394         }
 395         return 0;
 396 }
 397
 398 int CGitIndexFileMap::LoadIndex(const CString &gitdir)
 399 {
 400         try
 401         {
 402                 SHARED_INDEX_PTR pIndex(new CGitIndexList);
 403
 404                 if(pIndex->ReadIndex(g_AdminDirMap.GetAdminDir(gitdir)))
 405                         return -1;
 406
 407                 this->SafeSet(gitdir, pIndex);
 408
 409         }catch(...)
 410         {
 411                 return -1;
 412         }
 413         return 0;
 414 }
 415
 416 int CGitIndexFileMap::GetFileStatus(const CString &gitdir, const CString &path, git_wc_status_kind *status,BOOL IsFull, BOOL IsRecursive,
 417                                                                         FIll_STATUS_CALLBACK callback,void *pData,
 418                                                                         CGitHash *pHash,
 419                                                                         bool isLoadUpdatedIndex, bool * assumeValid, bool * skipWorktree)
 420 {
 421         try
 422         {
 423                 CheckAndUpdate(gitdir, isLoadUpdatedIndex);
 424
 425                 SHARED_INDEX_PTR pIndex = this->SafeGet(gitdir);
 426                 if (pIndex.get() != NULL)
 427                 {
 428                         pIndex->GetStatus(gitdir, path, status, IsFull, IsRecursive, callback, pData, pHash, assumeValid, skipWorktree);
 429                 }
 430                 else
 431                 {
 432                         // git working tree has not index
 433                         *status = git_wc_status_unversioned;
 434                 }
 435         }
 436         catch(...)
 437         {
 438                 return -1;
 439         }
 440         return 0;
 441 }
 442
 443 int CGitIndexFileMap::IsUnderVersionControl(const CString &gitdir, const CString &path, bool isDir,bool *isVersion, bool isLoadUpdateIndex)
 444 {
 445         try
 446         {
 447                 if (path.IsEmpty())
 448                 {
 449                         *isVersion = true;
 450                         return 0;
 451                 }
 452
 453                 CString subpath = path;
 454                 subpath.Replace(_T('\\'), _T('/'));
 455                 if(isDir)
 456                         subpath += _T('/');
 457
 458                 subpath.MakeLower();
 459
 460                 CheckAndUpdate(gitdir, isLoadUpdateIndex);
 461
 462                 SHARED_INDEX_PTR pIndex = this->SafeGet(gitdir);
 463
 464                 if(pIndex.get())
 465                 {
 466                         if(isDir)
 467                                 *isVersion = (SearchInSortVector(*pIndex, subpath.GetBuffer(), subpath.GetLength()) >= 0);
 468                         else
 469                                 *isVersion = (SearchInSortVector(*pIndex, subpath.GetBuffer(), -1) >= 0);
 470                         subpath.ReleaseBuffer();
 471                 }
 472
 473         }catch(...)
 474         {
 475                 return -1;
 476         }
 477         return 0;
 478 }
 479
 480 // This method is assumed to be called with m_SharedMutex locked.
 481 int CGitHeadFileList::GetPackRef(const CString &gitdir)
 482 {
 483         CString PackRef = g_AdminDirMap.GetAdminDir(gitdir) + _T("packed-refs");
 484
 485         __int64 mtime;
 486         if (g_Git.GetFileModifyTime(PackRef, &mtime))
 487         {
 488                 //packed refs is not existed
 489                 this->m_PackRefFile.Empty();
 490                 this->m_PackRefMap.clear();
 491                 return 0;
 492         }
 493         else if(mtime == m_LastModifyTimePackRef)
 494         {
 495                 return 0;
 496         }
 497         else
 498         {
 499                 this->m_PackRefFile = PackRef;
 500                 this->m_LastModifyTimePackRef = mtime;
 501         }
 502
 503         int ret = 0;
 504         {
 505                 this->m_PackRefMap.clear();
 506
 507                 CAutoFile hfile = CreateFile(PackRef,
 508                         GENERIC_READ,
 509                         FILE_SHARE_READ|FILE_SHARE_DELETE|FILE_SHARE_WRITE,
 510                         NULL,
 511                         OPEN_EXISTING,
 512                         FILE_ATTRIBUTE_NORMAL,
 513                         NULL);
 514                 do
 515                 {
 516                         if (!hfile)
 517                         {
 518                                 ret = -1;
 519                                 break;
 520                         }
 521
 522                         DWORD filesize = GetFileSize(hfile, NULL);
 523                         if (filesize == 0)
 524                         {
 525                                 ret = -1;
 526                                 break;
 527                         }
 528                         DWORD size =0;
 529                         char *buff;
 530                         buff = new char[filesize];
 531
 532                         ReadFile(hfile, buff, filesize, &size, NULL);
 533
 534                         if (size != filesize)
 535                         {
 536                                 delete[] buff;
 537                                 ret = -1;
 538                                 break;
 539                         }
 540
 541                         CString hash;
 542                         CString ref;
 543
 544                         for(DWORD i=0;i<filesize;)
 545                         {
 546                                 hash.Empty();
 547                                 ref.Empty();
 548                                 if (buff[i] == '#' || buff[i] == '^')
 549                                 {
 550                                         while (buff[i] != '\n')
 551                                         {
 552                                                 ++i;
 553                                                 if (i == filesize)
 554                                                         break;
 555                                         }
 556                                         ++i;
 557                                 }
 558
 559                                 if (i >= filesize)
 560                                         break;
 561
 562                                 while (buff[i] != ' ')
 563                                 {
 564                                         hash.AppendChar(buff[i]);
 565                                         ++i;
 566                                         if (i == filesize)
 567                                                 break;
 568                                 }
 569
 570                                 ++i;
 571                                 if (i >= filesize)
 572                                         break;
 573
 574                                 while (buff[i] != '\n')
 575                                 {
 576                                         ref.AppendChar(buff[i]);
 577                                         ++i;
 578                                         if (i == filesize)
 579                                                 break;
 580                                 }
 581
 582                                 if (!ref.IsEmpty() )
 583                                 {
 584                                         this->m_PackRefMap[ref] = hash;
 585                                 }
 586
 587                                 while (buff[i] == '\n')
 588                                 {
 589                                         ++i;
 590                                         if (i == filesize)
 591                                                 break;
 592                                 }
 593                         }
 594
 595                         delete[] buff;
 596
 597                 } while(0);
 598         }
 599         return ret;
 600
 601 }
 602 int CGitHeadFileList::ReadHeadHash(CString gitdir)
 603 {
 604         int ret = 0;
 605         CAutoWriteLock lock(&this->m_SharedMutex);
 606         m_Gitdir = g_AdminDirMap.GetAdminDir(gitdir);
 607
 608         m_HeadFile = m_Gitdir + _T("HEAD");
 609
 610         if( g_Git.GetFileModifyTime(m_HeadFile, &m_LastModifyTimeHead))
 611                 return -1;
 612
 613         try
 614         {
 615                 do
 616                 {
 617                         CAutoFile hfile = CreateFile(m_HeadFile,
 618                                 GENERIC_READ,
 619                                 FILE_SHARE_READ|FILE_SHARE_DELETE|FILE_SHARE_WRITE,
 620                                 NULL,
 621                                 OPEN_EXISTING,
 622                                 FILE_ATTRIBUTE_NORMAL,
 623                                 NULL);
 624
 625                         if (!hfile)
 626                         {
 627                                 ret = -1;
 628                                 break;
 629                         }
 630
 631                         DWORD size = 0,filesize = 0;
 632                         unsigned char buffer[40] ;
 633                         ReadFile(hfile, buffer, 4, &size, NULL);
 634                         if (size != 4)
 635                         {
 636                                 ret = -1;
 637                                 break;
 638                         }
 639                         buffer[4]=0;
 640                         if (strcmp((const char*)buffer,"ref:") == 0)
 641                         {
 642                                 filesize = GetFileSize(hfile, NULL);
 643                                 if (filesize < 5)
 644                                 {
 645                                         m_HeadRefFile.Empty();
 646                                         ret = -1;
 647                                         break;
 648                                 }
 649
 650                                 unsigned char *p = (unsigned char*)malloc(filesize -4);
 651
 652                                 ReadFile(hfile, p, filesize - 4, &size, NULL);
 653
 654                                 m_HeadRefFile.Empty();
 655                                 g_Git.StringAppend(&this->m_HeadRefFile, p, CP_UTF8, filesize - 4);
 656                                 CString ref = this->m_HeadRefFile;
 657                                 ref = ref.Trim();
 658                                 int start = 0;
 659                                 ref = ref.Tokenize(_T("\n"), start);
 660                                 free(p);
 661                                 m_HeadRefFile = m_Gitdir + m_HeadRefFile.Trim();
 662                                 m_HeadRefFile.Replace(_T('/'),_T('\\'));
 663
 664                                 __int64 time;
 665                                 if (g_Git.GetFileModifyTime(m_HeadRefFile, &time, NULL))
 666                                 {
 667                                         m_HeadRefFile.Empty();
 668                                         if (GetPackRef(gitdir))
 669                                         {
 670                                                 ret = -1;
 671                                                 break;
 672                                         }
 673                                         if (this->m_PackRefMap.find(ref) == m_PackRefMap.end())
 674                                         {
 675                                                 ret = -1;
 676                                                 break;
 677                                         }
 678                                         this ->m_Head = m_PackRefMap[ref];
 679                                         ret = 0;
 680                                         break;
 681                                 }
 682
 683                                 CAutoFile href = CreateFile(m_HeadRefFile,
 684                                         GENERIC_READ,
 685                                         FILE_SHARE_READ|FILE_SHARE_DELETE|FILE_SHARE_WRITE,
 686                                         NULL,
 687                                         OPEN_EXISTING,
 688                                         FILE_ATTRIBUTE_NORMAL,
 689                                         NULL);
 690
 691                                 if (!href)
 692                                 {
 693                                         m_HeadRefFile.Empty();
 694
 695                                         if (GetPackRef(gitdir))
 696                                         {
 697                                                 ret = -1;
 698                                                 break;
 699                                         }
 700
 701                                         if (this->m_PackRefMap.find(ref) == m_PackRefMap.end())
 702                                         {
 703                                                 ret = -1;
 704                                                 break;
 705                                         }
 706                                         this ->m_Head = m_PackRefMap[ref];
 707                                         ret = 0;
 708                                         break;
 709                                 }
 710                                 ReadFile(href, buffer, 40, &size, NULL);
 711                                 if (size != 40)
 712                                 {
 713                                         ret = -1;
 714                                         break;
 715                                 }
 716                                 this->m_Head.ConvertFromStrA((char*)buffer);
 717
 718                                 this->m_LastModifyTimeRef = time;
 719
 720                         }
 721                         else
 722                         {
 723                                 ReadFile(hfile, buffer + 4, 40 - 4, &size, NULL);
 724                                 if(size != 36)
 725                                 {
 726                                         ret = -1;
 727                                         break;
 728                                 }
 729                                 m_HeadRefFile.Empty();
 730
 731                                 this->m_Head.ConvertFromStrA((char*)buffer);
 732                         }
 733                 } while(0);
 734         }
 735         catch(...)
 736         {
 737                 ret = -1;
 738         }
 739
 740         return ret;
 741 }
 742
 743 bool CGitHeadFileList::CheckHeadUpdate()
 744 {
 745         CAutoReadLock lock(&m_SharedMutex);
 746         if (this->m_HeadFile.IsEmpty())
 747                 return true;
 748
 749         __int64 mtime=0;
 750
 751         if (g_Git.GetFileModifyTime(m_HeadFile, &mtime))
 752                 return true;
 753
 754         if (mtime != this->m_LastModifyTimeHead)
 755                 return true;
 756
 757         if (!this->m_HeadRefFile.IsEmpty())
 758         {
 759                 if (g_Git.GetFileModifyTime(m_HeadRefFile, &mtime))
 760                         return true;
 761
 762                 if (mtime != this->m_LastModifyTimeRef)
 763                         return true;
 764         }
 765
 766         if(!this->m_PackRefFile.IsEmpty())
 767         {
 768                 if (g_Git.GetFileModifyTime(m_PackRefFile, &mtime))
 769                         return true;
 770
 771                 if (mtime != this->m_LastModifyTimePackRef)
 772                         return true;
 773         }
 774
 775         // in an empty repo HEAD points to refs/heads/master, but this ref doesn't exist.
 776         // So we need to retry again and again until the ref exists - otherwise we will never notice
 777         if (this->m_Head.IsEmpty() && this->m_HeadRefFile.IsEmpty() && this->m_PackRefFile.IsEmpty())
 778                 return true;
 779
 780         return false;
 781 }
 782
 783 bool CGitHeadFileList::HeadHashEqualsTreeHash()
 784 {
 785         CAutoReadLock lock(&this->m_SharedMutex);
 786         return (m_Head == m_TreeHash);
 787 }
 788
 789 bool CGitHeadFileList::HeadFileIsEmpty()
 790 {
 791         CAutoReadLock lock(&this->m_SharedMutex);
 792         return m_HeadFile.IsEmpty();
 793 }
 794
 795 bool CGitHeadFileList::HeadIsEmpty()
 796 {
 797         CAutoReadLock lock(&this->m_SharedMutex);
 798         return m_Head.IsEmpty();
 799 }
 800
 801 int CGitHeadFileList::CallBack(const unsigned char *sha1, const char *base, int baselen,
 802                 const char *pathname, unsigned mode, int /*stage*/, void *context)
 803 {
 804 #define S_IFGITLINK     0160000
 805
 806         CGitHeadFileList *p = (CGitHeadFileList*)context;
 807         if( mode&S_IFDIR )
 808         {
 809                 if( (mode&S_IFMT) != S_IFGITLINK)
 810                         return READ_TREE_RECURSIVE;
 811         }
 812
 813         size_t cur = p->size();
 814         p->resize(p->size() + 1);
 815         p->at(cur).m_Hash = (char*)sha1;
 816         p->at(cur).m_FileName.Empty();
 817
 818         if(base)
 819                 g_Git.StringAppend(&p->at(cur).m_FileName, (BYTE*)base, CP_UTF8, baselen);
 820
 821         g_Git.StringAppend(&p->at(cur).m_FileName,(BYTE*)pathname, CP_UTF8);
 822
 823         p->at(cur).m_FileName.MakeLower();
 824
 825         //p->at(cur).m_FileName.Replace(_T('/'), _T('\\'));
 826
 827         //p->m_Map[p->at(cur).m_FileName] = cur;
 828
 829         if( (mode&S_IFMT) == S_IFGITLINK)
 830                 return 0;
 831
 832         return READ_TREE_RECURSIVE;
 833 }
 834
 835 int ReadTreeRecursive(git_repository &repo, git_tree * tree, CStringA base, int (*CallBack) (const unsigned char *, const char *, int, const char *, unsigned int, int, void *),void *data)
 836 {
 837         size_t count = git_tree_entrycount(tree);
 838         for (size_t i = 0; i < count; ++i)
 839         {
 840                 const git_tree_entry *entry = git_tree_entry_byindex(tree, i);
 841                 if (entry == NULL)
 842                         continue;
 843                 int mode = git_tree_entry_filemode(entry);
 844                 if( CallBack(git_tree_entry_id(entry)->id,
 845                         base,
 846                         base.GetLength(),
 847                         git_tree_entry_name(entry),
 848                         mode,
 849                         0,
 850                         data) == READ_TREE_RECURSIVE
 851                   )
 852                 {
 853                         if(mode&S_IFDIR)
 854                         {
 855                                 git_object *object = NULL;
 856                                 git_tree_entry_to_object(&object, &repo, entry);
 857                                 if (object == NULL)
 858                                         continue;
 859                                 CStringA parent = base;
 860                                 parent += git_tree_entry_name(entry);
 861                                 parent += "/";
 862                                 ReadTreeRecursive(repo, (git_tree*)object, parent, CallBack, data);
 863                                 git_object_free(object);
 864                         }
 865                 }
 866
 867         }
 868
 869         return 0;
 870 }
 871
 872 // ReadTree is/must only be executed on an empty list
 873 int CGitHeadFileList::ReadTree()
 874 {
 875         CAutoWriteLock lock(&m_SharedMutex);
 876         CStringA gitdir = CUnicodeUtils::GetMulti(m_Gitdir, CP_UTF8);
 877         git_repository *repository = NULL;
 878         git_commit *commit = NULL;
 879         git_tree * tree = NULL;
 880         int ret = 0;
 881         ATLASSERT(this->empty());
 882         do
 883         {
 884                 ret = git_repository_open(&repository, gitdir.GetBuffer());
 885                 gitdir.ReleaseBuffer();
 886                 if(ret)
 887                         break;
 888                 ret = git_commit_lookup(&commit, repository, (const git_oid*)m_Head.m_hash);
 889                 if(ret)
 890                         break;
 891
 892                 ret = git_commit_tree(&tree, commit);
 893                 if(ret)
 894                         break;
 895
 896                 ret = ReadTreeRecursive(*repository, tree,"", CGitHeadFileList::CallBack,this);
 897                 if(ret)
 898                         break;
 899
 900                 std::sort(this->begin(), this->end(), SortTree);
 901                 this->m_TreeHash = (char*)(git_commit_id(commit)->id);
 902
 903         } while(0);
 904
 905         if (tree)
 906                 git_tree_free(tree);
 907
 908         if (commit)
 909                 git_commit_free(commit);
 910
 911         if (repository)
 912                 git_repository_free(repository);
 913
 914         if (ret)
 915         {
 916                 clear();
 917                 m_LastModifyTimeHead = 0;
 918         }
 919
 920         return ret;
 921
 922 }
 923 int CGitIgnoreItem::FetchIgnoreList(const CString &projectroot, const CString &file, bool isGlobal)
 924 {
 925         CAutoWriteLock lock(&this->m_SharedMutex);
 926
 927         if (this->m_pExcludeList)
 928         {
 929                 git_free_exclude_list(m_pExcludeList);
 930                 m_pExcludeList=NULL;
 931         }
 932         if (m_buffer)
 933         {
 934                 free(m_buffer);
 935                 m_buffer = NULL;
 936         }
 937
 938         this->m_BaseDir.Empty();
 939         if (!isGlobal)
 940         {
 941                 CString base = file.Mid(projectroot.GetLength() + 1);
 942                 base.Replace(_T('\\'), _T('/'));
 943
 944                 int start = base.ReverseFind(_T('/'));
 945                 if(start > 0)
 946                 {
 947                         base = base.Left(start);
 948                         this->m_BaseDir = CUnicodeUtils::GetMulti(base, CP_UTF8) + "/";
 949                 }
 950         }
 951         {
 952
 953                 if(g_Git.GetFileModifyTime(file, &m_LastModifyTime))
 954                         return -1;
 955
 956                 if(git_create_exclude_list(&this->m_pExcludeList))
 957                         return -1;
 958
 959
 960                 CAutoFile hfile = CreateFile(file,
 961                         GENERIC_READ,
 962                         FILE_SHARE_READ|FILE_SHARE_DELETE|FILE_SHARE_WRITE,
 963                         NULL,
 964                         OPEN_EXISTING,
 965                         FILE_ATTRIBUTE_NORMAL,
 966                         NULL);
 967
 968
 969                 if (!hfile)
 970                         return -1 ;
 971
 972                 DWORD size=0,filesize=0;
 973
 974                 filesize=GetFileSize(hfile, NULL);
 975
 976                 if(filesize == INVALID_FILE_SIZE)
 977                         return -1;
 978
 979                 m_buffer = new BYTE[filesize + 1];
 980
 981                 if (m_buffer == NULL)
 982                         return -1;
 983
 984                 if (!ReadFile(hfile, m_buffer, filesize, &size, NULL))
 985                         return GetLastError();
 986
 987                 BYTE *p = m_buffer;
 988                 for (DWORD i = 0; i < size; ++i)
 989                 {
 990                         if (m_buffer[i] == '\n' || m_buffer[i] == '\r' || i == (size - 1))
 991                         {
 992                                 if (m_buffer[i] == '\n' || m_buffer[i] == '\r')
 993                                         m_buffer[i] = 0;
 994                                 if (i == size - 1)
 995                                         m_buffer[size] = 0;
 996
 997                                 if(p[0] != '#' && p[0] != 0)
 998                                         git_add_exclude((const char*)p,
 999                                                                                 this->m_BaseDir.GetBuffer(),
1000                                                                                 m_BaseDir.GetLength(),
1001                                                                                 this->m_pExcludeList);
1002
1003                                 p = m_buffer + i + 1;
1004                         }
1005                 }
1006         }
1007         return 0;
1008 }
1009
1010 bool CGitIgnoreList::CheckFileChanged(const CString &path)
1011 {
1012         __int64 time = 0;
1013
1014         int ret = g_Git.GetFileModifyTime(path, &time);
1015
1016         this->m_SharedMutex.AcquireShared();
1017         bool cacheExist = (m_Map.find(path) != m_Map.end());
1018         this->m_SharedMutex.ReleaseShared();
1019
1020         if (!cacheExist && ret == 0)
1021         {
1022                 CAutoWriteLock lock(&this->m_SharedMutex);
1023                 m_Map[path].m_LastModifyTime = 0;
1024                 m_Map[path].m_SharedMutex.Init();
1025         }
1026         // both cache and file is not exist
1027         if ((ret != 0) && (!cacheExist))
1028                 return false;
1029
1030         // file exist but cache miss
1031         if ((ret == 0) && (!cacheExist))
1032                 return true;
1033
1034         // file not exist but cache exist
1035         if ((ret != 0) && (cacheExist))
1036         {
1037                 return true;
1038         }
1039         // file exist and cache exist
1040
1041         {
1042                 CAutoReadLock lock(&this->m_SharedMutex);
1043                 if (m_Map[path].m_LastModifyTime == time)
1044                         return false;
1045         }
1046         return true;
1047 }
1048
1049 bool CGitIgnoreList::CheckIgnoreChanged(const CString &gitdir,const CString &path)
1050 {
1051         CString temp;
1052         temp = gitdir;
1053         temp += _T("\\");
1054         temp += path;
1055
1056         temp.Replace(_T('/'), _T('\\'));
1057
1058         while(!temp.IsEmpty())
1059         {
1060                 CString tempOrig = temp;
1061                 temp += _T("\\.git");
1062
1063                 if (CGit::GitPathFileExists(temp))
1064                 {
1065                         CString gitignore=temp;
1066                         gitignore += _T("ignore");
1067                         if (CheckFileChanged(gitignore))
1068                                 return true;
1069
1070                         CString adminDir = g_AdminDirMap.GetAdminDir(tempOrig);
1071                         CString wcglobalgitignore = adminDir + _T("info\\exclude");
1072                         if (CheckFileChanged(wcglobalgitignore))
1073                                 return true;
1074
1075                         if (CheckAndUpdateCoreExcludefile(adminDir))
1076                                 return true;
1077
1078                         return false;
1079                 }
1080                 else
1081                 {
1082                         temp += _T("ignore");
1083                         if (CheckFileChanged(temp))
1084                                 return true;
1085                 }
1086
1087                 int found=0;
1088                 int i;
1089                 for (i = temp.GetLength() - 1; i >= 0; i--)
1090                 {
1091                         if(temp[i] == _T('\\'))
1092                                 ++found;
1093
1094                         if(found == 2)
1095                                 break;
1096                 }
1097
1098                 temp = temp.Left(i);
1099         }
1100         return true;
1101 }
1102
1103 int CGitIgnoreList::FetchIgnoreFile(const CString &gitdir, const CString &gitignore, bool isGlobal)
1104 {
1105         if (CGit::GitPathFileExists(gitignore)) //if .gitignore remove, we need remote cache
1106         {
1107                 CAutoWriteLock lock(&this->m_SharedMutex);
1108                 if (m_Map.find(gitignore) == m_Map.end())
1109                         m_Map[gitignore].m_SharedMutex.Init();
1110
1111                 m_Map[gitignore].FetchIgnoreList(gitdir, gitignore, isGlobal);
1112         }
1113         else
1114         {
1115                 CAutoWriteLock lock(&this->m_SharedMutex);
1116                 if (m_Map.find(gitignore) != m_Map.end())
1117                         m_Map[gitignore].m_SharedMutex.Release();
1118
1119                 m_Map.erase(gitignore);
1120         }
1121         return 0;
1122 }
1123
1124 int CGitIgnoreList::LoadAllIgnoreFile(const CString &gitdir,const CString &path)
1125 {
1126         CString temp;
1127
1128         temp = gitdir;
1129         temp += _T("\\");
1130         temp += path;
1131
1132         temp.Replace(_T('/'), _T('\\'));
1133
1134         while (!temp.IsEmpty())
1135         {
1136                 CString tempOrig = temp;
1137                 temp += _T("\\.git");
1138
1139                 if (CGit::GitPathFileExists(temp))
1140                 {
1141                         CString gitignore = temp;
1142                         gitignore += _T("ignore");
1143                         if (CheckFileChanged(gitignore))
1144                         {
1145                                 FetchIgnoreFile(gitdir, gitignore, false);
1146                         }
1147
1148                         CString adminDir = g_AdminDirMap.GetAdminDir(tempOrig);
1149                         CString wcglobalgitignore = adminDir + _T("info\\exclude");
1150                         if (CheckFileChanged(wcglobalgitignore))
1151                         {
1152                                 FetchIgnoreFile(gitdir, wcglobalgitignore, true);
1153                         }
1154
1155                         if (CheckAndUpdateCoreExcludefile(adminDir))
1156                         {
1157                                 m_SharedMutex.AcquireShared();
1158                                 CString excludesFile = m_CoreExcludesfiles[adminDir];
1159                                 m_SharedMutex.ReleaseShared();
1160                                 if (!excludesFile.IsEmpty())
1161                                         FetchIgnoreFile(gitdir, excludesFile, true);
1162                         }
1163
1164                         return 0;
1165                 }
1166                 else
1167                 {
1168                         temp += _T("ignore");
1169                         if (CheckFileChanged(temp))
1170                         {
1171                                 FetchIgnoreFile(gitdir, temp, false);
1172                         }
1173                 }
1174
1175                 int found = 0;
1176                 int i;
1177                 for (i = temp.GetLength() - 1; i >= 0; i--)
1178                 {
1179                         if(temp[i] == _T('\\'))
1180                                 ++found;
1181
1182                         if(found == 2)
1183                                 break;
1184                 }
1185
1186                 temp = temp.Left(i);
1187         }
1188         return 0;
1189 }
1190 bool CGitIgnoreList::CheckAndUpdateMsysGitBinpath(bool force)
1191 {
1192         // recheck every 30 seconds
1193         if (GetTickCount() - m_dMsysGitBinPathLastChecked > 30000 || force)
1194         {
1195                 m_dMsysGitBinPathLastChecked = GetTickCount();
1196                 CString msysGitBinPath(CRegString(REG_MSYSGIT_PATH, _T(""), FALSE));
1197                 if (msysGitBinPath != m_sMsysGitBinPath)
1198                 {
1199                         m_sMsysGitBinPath = msysGitBinPath;
1200                         return true;
1201                 }
1202         }
1203         return false;
1204 }
1205 bool CGitIgnoreList::CheckAndUpdateCoreExcludefile(const CString &adminDir)
1206 {
1207         bool hasChanged = false;
1208
1209         CString projectConfig = adminDir + _T("config");
1210         CString globalConfig = g_Git.GetGitGlobalConfig();
1211         CString globalXDGConfig = g_Git.GetGitGlobalXDGConfig();
1212
1213         CAutoWriteLock lock(&m_coreExcludefilesSharedMutex);
1214         hasChanged = CheckAndUpdateMsysGitBinpath();
1215         CString systemConfig = m_sMsysGitBinPath + _T("\\..\\etc\\gitconfig");
1216
1217         hasChanged = hasChanged || CheckFileChanged(projectConfig);
1218         hasChanged = hasChanged || CheckFileChanged(globalConfig);
1219         hasChanged = hasChanged || CheckFileChanged(globalXDGConfig);
1220         if (!m_sMsysGitBinPath.IsEmpty())
1221                 hasChanged = hasChanged || CheckFileChanged(systemConfig);
1222
1223         m_SharedMutex.AcquireShared();
1224         CString excludesFile = m_CoreExcludesfiles[adminDir];
1225         m_SharedMutex.ReleaseShared();
1226         if (!excludesFile.IsEmpty())
1227                 hasChanged = hasChanged || CheckFileChanged(excludesFile);
1228
1229         if (!hasChanged)
1230                 return false;
1231
1232         git_config * config;
1233         git_config_new(&config);
1234         CStringA projectConfigA = CUnicodeUtils::GetMulti(projectConfig, CP_UTF8);
1235         git_config_add_file_ondisk(config, projectConfigA.GetBuffer(), 4, FALSE);
1236         projectConfigA.ReleaseBuffer();
1237         CStringA globalConfigA = CUnicodeUtils::GetMulti(globalConfig, CP_UTF8);
1238         git_config_add_file_ondisk(config, globalConfigA.GetBuffer(), 3, FALSE);
1239         globalConfigA.ReleaseBuffer();
1240         CStringA globalXDGConfigA = CUnicodeUtils::GetMulti(globalXDGConfig, CP_UTF8);
1241         git_config_add_file_ondisk(config, globalXDGConfigA.GetBuffer(), 2, FALSE);
1242         globalXDGConfigA.ReleaseBuffer();
1243         if (!m_sMsysGitBinPath.IsEmpty())
1244         {
1245                 CStringA systemConfigA = CUnicodeUtils::GetMulti(systemConfig, CP_UTF8);
1246                 git_config_add_file_ondisk(config, systemConfigA.GetBuffer(), 1, FALSE);
1247                 systemConfigA.ReleaseBuffer();
1248         }
1249         const char * out = NULL;
1250         CStringA name(_T("core.excludesfile"));
1251         git_config_get_string(&out, config, name.GetBuffer());
1252         name.ReleaseBuffer();
1253         CStringA excludesFileA(out);
1254         excludesFile = CUnicodeUtils::GetUnicode(excludesFileA);
1255         if (excludesFile.IsEmpty())
1256                 excludesFile = GetWindowsHome() + _T("\\.config\\git\\ignore");
1257         else if (excludesFile.Find(_T("~/")) == 0)
1258                 excludesFile = GetWindowsHome() + excludesFile.Mid(1);
1259         git_config_free(config);
1260
1261         CAutoWriteLock lockMap(&m_SharedMutex);
1262         g_Git.GetFileModifyTime(projectConfig, &m_Map[projectConfig].m_LastModifyTime);
1263         g_Git.GetFileModifyTime(globalXDGConfig, &m_Map[globalXDGConfig].m_LastModifyTime);
1264         if (m_Map[globalXDGConfig].m_LastModifyTime == 0)
1265         {
1266                 m_Map[globalXDGConfig].m_SharedMutex.Release();
1267                 m_Map.erase(globalXDGConfig);
1268         }
1269         g_Git.GetFileModifyTime(globalConfig, &m_Map[globalConfig].m_LastModifyTime);
1270         if (m_Map[globalConfig].m_LastModifyTime == 0)
1271         {
1272                 m_Map[globalConfig].m_SharedMutex.Release();
1273                 m_Map.erase(globalConfig);
1274         }
1275         if (!m_sMsysGitBinPath.IsEmpty())
1276                 g_Git.GetFileModifyTime(systemConfig, &m_Map[systemConfig].m_LastModifyTime);
1277         if (m_Map[systemConfig].m_LastModifyTime == 0 || m_sMsysGitBinPath.IsEmpty())
1278         {
1279                 m_Map[systemConfig].m_SharedMutex.Release();
1280                 m_Map.erase(systemConfig);
1281         }
1282         m_CoreExcludesfiles[adminDir] = excludesFile;
1283
1284         return true;
1285 }
1286 const CString CGitIgnoreList::GetWindowsHome()
1287 {
1288         static CString sWindowsHome(g_Git.GetHomeDirectory());
1289         return sWindowsHome;
1290 }
1291 bool CGitIgnoreList::IsIgnore(const CString &path,const CString &projectroot)
1292 {
1293         CString str=path;
1294
1295         str.Replace(_T('\\'),_T('/'));
1296
1297         if (str.GetLength()>0)
1298                 if (str[str.GetLength()-1] == _T('/'))
1299                         str = str.Left(str.GetLength() - 1);
1300
1301         int ret;
1302         ret = CheckIgnore(str, projectroot);
1303         while (ret < 0)
1304         {
1305                 int start = str.ReverseFind(_T('/'));
1306                 if(start < 0)
1307                         return (ret == 1);
1308
1309                 str = str.Left(start);
1310                 ret = CheckIgnore(str, projectroot);
1311         }
1312
1313         return (ret == 1);
1314 }
1315 int CGitIgnoreList::CheckFileAgainstIgnoreList(const CString &ignorefile, const CStringA &patha, const char * base, int &type)
1316 {
1317         if (m_Map.find(ignorefile) != m_Map.end())
1318         {
1319                 int ret = -1;
1320                 if(m_Map[ignorefile].m_pExcludeList)
1321                         ret = git_check_excluded_1(patha, patha.GetLength(), base, &type, m_Map[ignorefile].m_pExcludeList);
1322                 if (ret == 0 || ret == 1)
1323                         return ret;
1324         }
1325         return -1;
1326 }
1327 int CGitIgnoreList::CheckIgnore(const CString &path,const CString &projectroot)
1328 {
1329         __int64 time = 0;
1330         bool dir = 0;
1331         CString temp = projectroot + _T("\\") + path;
1332         temp.Replace(_T('/'), _T('\\'));
1333
1334         CStringA patha = CUnicodeUtils::GetMulti(path, CP_UTF8);
1335         patha.Replace('\\', '/');
1336
1337         if(g_Git.GetFileModifyTime(temp, &time, &dir))
1338                 return -1;
1339
1340         int type = 0;
1341         if (dir)
1342         {
1343                 type = DT_DIR;
1344
1345                 // strip directory name
1346                 // we do not need to check for a .ignore file inside a directory we might ignore
1347                 int i = temp.ReverseFind(_T('\\'));
1348                 if (i >= 0)
1349                         temp = temp.Left(i);
1350         }
1351         else
1352                 type = DT_REG;
1353
1354         char * base = NULL;
1355         int pos = patha.ReverseFind('/');
1356         base = pos >= 0 ? patha.GetBuffer() + pos + 1 : patha.GetBuffer();
1357
1358         int ret = -1;
1359
1360         CAutoReadLock lock(&this->m_SharedMutex);
1361         while (!temp.IsEmpty())
1362         {
1363                 CString tempOrig = temp;
1364                 temp += _T("\\.git");
1365
1366                 if (CGit::GitPathFileExists(temp))
1367                 {
1368                         CString gitignore = temp;
1369                         gitignore += _T("ignore");
1370                         if ((ret = CheckFileAgainstIgnoreList(gitignore, patha, base, type)) != -1)
1371                                 break;
1372
1373                         CString adminDir = g_AdminDirMap.GetAdminDir(tempOrig);
1374                         CString wcglobalgitignore = adminDir + _T("info\\exclude");
1375                         if ((ret = CheckFileAgainstIgnoreList(wcglobalgitignore, patha, base, type)) != -1)
1376                                 break;
1377
1378                         m_SharedMutex.AcquireShared();
1379                         CString excludesFile = m_CoreExcludesfiles[adminDir];
1380                         m_SharedMutex.ReleaseShared();
1381                         if (!excludesFile.IsEmpty())
1382                                 ret = CheckFileAgainstIgnoreList(excludesFile, patha, base, type);
1383
1384                         break;
1385                 }
1386                 else
1387                 {
1388                         temp += _T("ignore");
1389                         if ((ret = CheckFileAgainstIgnoreList(temp, patha, base, type)) != -1)
1390                                 break;
1391                 }
1392
1393                 int found = 0;
1394                 int i;
1395                 for (i = temp.GetLength() - 1; i >= 0; i--)
1396                 {
1397                         if (temp[i] == _T('\\'))
1398                                 ++found;
1399
1400                         if (found == 2)
1401                                 break;
1402                 }
1403
1404                 temp = temp.Left(i);
1405         }
1406
1407         patha.ReleaseBuffer();
1408
1409         return ret;
1410 }
1411
1412 bool CGitHeadFileMap::CheckHeadAndUpdate(const CString &gitdir, bool readTree /* = true */)
1413 {
1414         SHARED_TREE_PTR ptr;
1415         ptr = this->SafeGet(gitdir);
1416
1417         if (ptr.get() && !ptr->CheckHeadUpdate() && (!readTree || ptr->HeadHashEqualsTreeHash()))
1418                 return false;
1419
1420         ptr = SHARED_TREE_PTR(new CGitHeadFileList);
1421         ptr->ReadHeadHash(gitdir);
1422         if (readTree)
1423                 ptr->ReadTree();
1424
1425         this->SafeSet(gitdir, ptr);
1426
1427         return true;
1428 }
1429
1430 int CGitHeadFileMap::IsUnderVersionControl(const CString &gitdir, const CString &path, bool isDir, bool *isVersion)
1431 {
1432         try
1433         {
1434                 if (path.IsEmpty())
1435                 {
1436                         *isVersion = true;
1437                         return 0;
1438                 }
1439
1440                 CString subpath = path;
1441                 subpath.Replace(_T('\\'), _T('/'));
1442                 if(isDir)
1443                         subpath += _T('/');
1444
1445                 subpath.MakeLower();
1446
1447                 CheckHeadAndUpdate(gitdir);
1448
1449                 SHARED_TREE_PTR treeptr = SafeGet(gitdir);
1450
1451                 // Init Repository
1452                 if (treeptr->HeadFileIsEmpty())
1453                 {
1454                         *isVersion = false;
1455                         return 0;
1456                 }
1457                 else if (treeptr->empty())
1458                 {
1459                         *isVersion = false;
1460                         return 1;
1461                 }
1462
1463                 if(isDir)
1464                         *isVersion = (SearchInSortVector(*treeptr, subpath.GetBuffer(), subpath.GetLength()) >= 0);
1465                 else
1466                         *isVersion = (SearchInSortVector(*treeptr, subpath.GetBuffer(), -1) >= 0);
1467                 subpath.ReleaseBuffer();
1468         }
1469         catch(...)
1470         {
1471                 return -1;
1472         }
1473
1474         return 0;
1475 }