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