src/Git/GitIndex.cpp

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