src/Git/GitIndex.cpp

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