src/Git/GitIndex.cpp

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