src/Git/gitindex.h

   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 "GitHash.h"
  21 #include "gitdll.h"
  22 #include "GitStatus.h"
  23 #include "UnicodeUtils.h"
  24 #include "ReaderWriterLock.h"
  25 #include "GitAdminDir.h"
  26 #include "StringUtils.h"
  27 #include "PathUtils.h"
  28
  29 #ifndef S_IFLNK
  30 #define S_IFLNK 0120000
  31 #undef _S_IFLNK
  32 #define _S_IFLNK S_IFLNK
  33 #endif
  34 #ifndef S_ISLNK
  35 #define S_ISLNK(m) (((m) & _S_IFMT) == _S_IFLNK)
  36 #endif
  37
  38 class CGitIndex
  39 {
  40 public:
  41         CString    m_FileName;
  42         __time64_t      m_ModifyTime;
  43         uint16_t        m_Flags;
  44         uint16_t        m_FlagsExtended;
  45         CGitHash        m_IndexHash;
  46         __int64         m_Size;
  47         uint32_t        m_Mode;
  48
  49         int Print();
  50 };
  51
  52 class CGitIndexList:public std::vector<CGitIndex>
  53 {
  54 public:
  55         __time64_t  m_LastModifyTime;
  56         __int64         m_LastFileSize;
  57         BOOL            m_bHasConflicts;
  58         int                     m_iIndexCaps;
  59
  60         CGitIndexList();
  61         ~CGitIndexList();
  62
  63         int ReadIndex(CString dotgitdir);
  64         int GetFileStatus(const CString& gitdir, const CString& path, git_wc_status2_t& status, CGitHash* pHash = nullptr);
  65         int GetFileStatus(CAutoRepository& repository, const CString& gitdir, CGitIndex& entry, git_wc_status2_t& status, __int64 time, __int64 filesize, bool isSymlink);
  66 #ifdef GTEST_INCLUDE_GTEST_GTEST_H_
  67         FRIEND_TEST(GitIndexCBasicGitWithTestRepoFixture, GetFileStatus);
  68 #endif
  69 protected:
  70         __int64 m_iMaxCheckSize;
  71         CAutoConfig config;
  72         int GetFileStatus(const CString& gitdir, const CString& path, git_wc_status2_t& status, __int64 time, __int64 filesize, bool isSymlink, CGitHash* pHash = nullptr);
  73 };
  74
  75 typedef std::shared_ptr<CGitIndexList> SHARED_INDEX_PTR;
  76 typedef CComCritSecLock<CComCriticalSection> CAutoLocker;
  77
  78 class CGitIndexFileMap:public std::map<CString, SHARED_INDEX_PTR>
  79 {
  80 public:
  81         CComCriticalSection                     m_critIndexSec;
  82
  83         CGitIndexFileMap() { m_critIndexSec.Init(); }
  84         ~CGitIndexFileMap() { m_critIndexSec.Term(); }
  85
  86         SHARED_INDEX_PTR SafeGet(const CString& path)
  87         {
  88                 CString thePath(CPathUtils::NormalizePath(path));
  89                 CAutoLocker lock(m_critIndexSec);
  90                 auto lookup = find(thePath);
  91                 if (lookup == cend())
  92                         return SHARED_INDEX_PTR();
  93                 return lookup->second;
  94         }
  95
  96         void SafeSet(const CString& path, SHARED_INDEX_PTR ptr)
  97         {
  98                 CString thePath(CPathUtils::NormalizePath(path));
  99                 CAutoLocker lock(m_critIndexSec);
 100                 (*this)[thePath] = ptr;
 101         }
 102
 103         bool SafeClear(const CString& path)
 104         {
 105                 CString thePath(CPathUtils::NormalizePath(path));
 106                 CAutoLocker lock(m_critIndexSec);
 107                 auto lookup = find(thePath);
 108                 if (lookup == cend())
 109                         return false;
 110                 erase(lookup);
 111                 return true;
 112         }
 113
 114         bool SafeClearRecursively(const CString& path)
 115         {
 116                 CString thePath(CPathUtils::NormalizePath(path));
 117                 CAutoLocker lock(m_critIndexSec);
 118                 std::vector<CString> toRemove;
 119                 for (auto it = this->cbegin(); it != this->cend(); ++it)
 120                 {
 121                         if (CStringUtils::StartsWith((*it).first, thePath))
 122                                 toRemove.push_back((*it).first);
 123                 }
 124                 for (auto it = toRemove.cbegin(); it != toRemove.cend(); ++it)
 125                         this->erase(*it);
 126                 return !toRemove.empty();
 127         }
 128
 129         bool HasIndexChangedOnDisk(const CString& gitdir);
 130         int LoadIndex(const CString &gitdir);
 131
 132         void CheckAndUpdate(const CString& gitdir)
 133         {
 134                 if (HasIndexChangedOnDisk(gitdir))
 135                         LoadIndex(gitdir);
 136         }
 137 };
 138
 139 class CGitTreeItem
 140 {
 141 public:
 142         CString m_FileName;
 143         CGitHash        m_Hash;
 144         int                     m_Flags;
 145 };
 146
 147 /* After object create, never change field agains
 148  * that needn't lock to get field
 149 */
 150 class CGitHeadFileList:public std::vector<CGitTreeItem>
 151 {
 152 private:
 153         int GetPackRef(const CString &gitdir);
 154
 155         __time64_t  m_LastModifyTimeHead;
 156         __time64_t  m_LastModifyTimeRef;
 157         __time64_t      m_LastModifyTimePackRef;
 158
 159         __int64         m_LastFileSizeHead;
 160         __int64         m_LastFileSizePackRef;
 161
 162         CString         m_HeadRefFile;
 163         CGitHash        m_Head;
 164         CString         m_HeadFile;
 165         CString         m_Gitdir;
 166         CString         m_PackRefFile;
 167
 168         std::map<CString,CGitHash> m_PackRefMap;
 169
 170 public:
 171         CGitHeadFileList()
 172         : m_LastModifyTimeHead(0)
 173         , m_LastModifyTimeRef(0)
 174         , m_LastModifyTimePackRef(0)
 175         , m_LastFileSizeHead(-1)
 176         , m_LastFileSizePackRef(-1)
 177         {
 178         }
 179
 180         int ReadTree();
 181         int ReadHeadHash(const CString& gitdir);
 182         bool CheckHeadUpdate();
 183         static int CallBack(const unsigned char *, const char *, int, const char *, unsigned int, int, void *);
 184 };
 185
 186 typedef std::shared_ptr<CGitHeadFileList> SHARED_TREE_PTR;
 187 class CGitHeadFileMap:public std::map<CString,SHARED_TREE_PTR>
 188 {
 189 public:
 190
 191         CComCriticalSection                     m_critTreeSec;
 192
 193         CGitHeadFileMap() { m_critTreeSec.Init(); }
 194         ~CGitHeadFileMap() { m_critTreeSec.Term(); }
 195
 196         SHARED_TREE_PTR SafeGet(const CString& path)
 197         {
 198                 CString thePath(CPathUtils::NormalizePath(path));
 199                 CAutoLocker lock(m_critTreeSec);
 200                 auto lookup = find(thePath);
 201                 if (lookup == cend())
 202                         return SHARED_TREE_PTR();
 203                 return lookup->second;
 204         }
 205
 206         void SafeSet(const CString& path, SHARED_TREE_PTR ptr)
 207         {
 208                 CString thePath(CPathUtils::NormalizePath(path));
 209                 CAutoLocker lock(m_critTreeSec);
 210                 (*this)[thePath] = ptr;
 211         }
 212
 213         bool SafeClear(const CString& path)
 214         {
 215                 CString thePath(CPathUtils::NormalizePath(path));
 216                 CAutoLocker lock(m_critTreeSec);
 217                 auto lookup = find(thePath);
 218                 if (lookup == cend())
 219                         return false;
 220                 erase(lookup);
 221                 return true;
 222         }
 223
 224         bool SafeClearRecursively(const CString& path)
 225         {
 226                 CString thePath(CPathUtils::NormalizePath(path));
 227                 CAutoLocker lock(m_critTreeSec);
 228                 std::vector<CString> toRemove;
 229                 for (auto it = this->cbegin(); it != this->cend(); ++it)
 230                 {
 231                         if (CStringUtils::StartsWith((*it).first, thePath))
 232                                 toRemove.push_back((*it).first);
 233                 }
 234                 for (auto it = toRemove.cbegin(); it != toRemove.cend(); ++it)
 235                         this->erase(*it);
 236                 return !toRemove.empty();
 237         }
 238         void CheckHeadAndUpdate(const CString& gitdir);
 239 };
 240
 241 class CGitFileName
 242 {
 243 public:
 244         CGitFileName() {}
 245         CGitFileName(LPCTSTR filename, __int64 size, __int64 lastmodified)
 246         : m_FileName(filename)
 247         , m_Size(size)
 248         , m_LastModified(lastmodified)
 249         , m_bSymlink(false)
 250         {
 251         }
 252         CString m_FileName;
 253         __int64 m_Size;
 254         __int64 m_LastModified;
 255         bool    m_bSymlink;
 256 };
 257
 258 static bool SortCGitFileName(const CGitFileName& item1, const CGitFileName& item2)
 259 {
 260         return item1.m_FileName.Compare(item2.m_FileName) < 0;
 261 }
 262
 263 class CGitIgnoreItem
 264 {
 265 public:
 266         CGitIgnoreItem()
 267         : m_LastModifyTime(0)
 268         , m_LastFileSize(-1)
 269         , m_pExcludeList(nullptr)
 270         , m_buffer(nullptr)
 271         , m_iIgnoreCase(nullptr)
 272         {
 273         }
 274
 275         ~CGitIgnoreItem()
 276         {
 277                 if(m_pExcludeList)
 278                         git_free_exclude_list(m_pExcludeList);
 279                 free(m_buffer);
 280         }
 281
 282         __time64_t  m_LastModifyTime;
 283         __int64         m_LastFileSize;
 284         CStringA m_BaseDir;
 285         BYTE *m_buffer;
 286         EXCLUDE_LIST m_pExcludeList;
 287         int* m_iIgnoreCase;
 288
 289         int FetchIgnoreList(const CString& projectroot, const CString& file, bool isGlobal, int* ignoreCase);
 290
 291         /**
 292         * patha: the filename to be checked whether is is ignored or not
 293         * base: must be a pointer to the beginning of the base filename WITHIN patha
 294         * type: DT_DIR or DT_REG
 295         */
 296         int IsPathIgnored(const CStringA& patha, const char* base, int& type);
 297 #ifdef GTEST_INCLUDE_GTEST_GTEST_H_
 298         int IsPathIgnored(const CStringA& patha, int& type);
 299 #endif
 300 };
 301
 302 class CGitIgnoreList
 303 {
 304 private:
 305         bool CheckFileChanged(const CString &path);
 306         int FetchIgnoreFile(const CString &gitdir, const CString &gitignore, bool isGlobal);
 307
 308         int  CheckIgnore(const CString &path, const CString &root, bool isDir);
 309         int CheckFileAgainstIgnoreList(const CString &ignorefile, const CStringA &patha, const char * base, int &type);
 310
 311         // core.excludesfile stuff
 312         std::map<CString, CString> m_CoreExcludesfiles;
 313         std::map<CString, int> m_IgnoreCase;
 314         CString m_sGitSystemConfigPath;
 315         CString m_sGitProgramDataConfigPath;
 316         ULONGLONG m_dGitSystemConfigPathLastChecked;
 317         CReaderWriterLock       m_coreExcludefilesSharedMutex;
 318         // checks if the msysgit path has changed and return true/false
 319         // if the path changed, the cache is update
 320         // force is only ised in constructor
 321         bool CheckAndUpdateGitSystemConfigPath(bool force = true);
 322         bool CheckAndUpdateCoreExcludefile(const CString &adminDir);
 323         const CString GetWindowsHome();
 324
 325 public:
 326         CReaderWriterLock               m_SharedMutex;
 327
 328         CGitIgnoreList(){ CheckAndUpdateGitSystemConfigPath(true); }
 329
 330         std::map<CString, CGitIgnoreItem> m_Map;
 331
 332         bool CheckAndUpdateIgnoreFiles(const CString& gitdir, const CString& path, bool isDir);
 333         bool IsIgnore(CString path, const CString& root, bool isDir);
 334 };
 335
 336 static const size_t NPOS = (size_t)-1; // bad/missing length/position
 337 static_assert(MAXSIZE_T == NPOS, "NPOS must equal MAXSIZE_T");
 338 #pragma warning(push)
 339 #pragma warning(disable: 4310)
 340 static_assert(-1 == (int)NPOS, "NPOS must equal -1");
 341 #pragma warning(pop)
 342
 343 template<class T>
 344 int GetRangeInSortVector(const T& vector, LPCTSTR pstr, size_t len, size_t* start, size_t* end, size_t pos)
 345 {
 346         if (pos == NPOS)
 347                 return -1;
 348         if (!start || !end)
 349                 return -1;
 350
 351         *start = *end = NPOS;
 352
 353         if (vector.empty())
 354                 return -1;
 355
 356         if (pos >= vector.size())
 357                 return -1;
 358
 359         if (wcsncmp(vector[pos].m_FileName, pstr, len) != 0)
 360                 return -1;
 361
 362         *start = 0;
 363         *end = vector.size() - 1;
 364
 365         // shortcut, if all entries are going match
 366         if (!len)
 367                 return 0;
 368
 369         for (size_t i = pos; i < vector.size(); ++i)
 370         {
 371                 if (wcsncmp(vector[i].m_FileName, pstr, len) != 0)
 372                         break;
 373
 374                 *end = i;
 375         }
 376         for (size_t i = pos + 1; i-- > 0;)
 377         {
 378                 if (wcsncmp(vector[i].m_FileName, pstr, len) != 0)
 379                         break;
 380
 381                 *start = i;
 382         }
 383
 384         return 0;
 385 }
 386
 387 template<class T>
 388 inline size_t SearchInSortVector(const T& vector, LPCTSTR pstr, int len)
 389 {
 390         if (len < 0)
 391                 return SearchInSortVector(vector, pstr, wcscmp);
 392
 393         return SearchInSortVector(vector, pstr, [len](const auto& s1, const auto& s2) { return wcsncmp(s1, s2, len); });
 394 }
 395
 396 template<class T, class V>
 397 static size_t SearchInSortVector(const T& vector, LPCTSTR pstr, V compare)
 398 {
 399         size_t end = vector.size() - 1;
 400         size_t start = 0;
 401         size_t mid = (start + end) / 2;
 402
 403         if (vector.empty())
 404                 return NPOS;
 405
 406         while(!( start == end && start==mid))
 407         {
 408                 int cmp = compare(vector[mid].m_FileName, pstr);
 409                 if (cmp == 0)
 410                         return mid;
 411                 else if (cmp < 0)
 412                         start = mid + 1;
 413                 else // (cmp > 0)
 414                         end = mid;
 415
 416                 mid=(start +end ) /2;
 417
 418         }
 419
 420         if (compare(vector[mid].m_FileName, pstr) == 0)
 421                 return mid;
 422
 423         return NPOS;
 424 };
 425
 426 class CGitAdminDirMap:public std::map<CString, CString>
 427 {
 428 public:
 429         CComCriticalSection                     m_critIndexSec;
 430         std::map<CString, CString>      m_reverseLookup;
 431         std::map<CString, CString>      m_WorktreeAdminDirLookup;
 432
 433         CGitAdminDirMap() { m_critIndexSec.Init(); }
 434         ~CGitAdminDirMap() { m_critIndexSec.Term(); }
 435
 436         CString GetAdminDir(const CString &path)
 437         {
 438                 CString thePath(CPathUtils::NormalizePath(path));
 439                 CAutoLocker lock(m_critIndexSec);
 440                 auto lookup = find(thePath);
 441                 if (lookup == cend())
 442                 {
 443                         CString adminDir;
 444                         bool isWorktree = false;
 445                         GitAdminDir::GetAdminDirPath(thePath, adminDir, &isWorktree);
 446                         if (PathIsDirectory(adminDir))
 447                         {
 448                                 adminDir = CPathUtils::BuildPathWithPathDelimiter(CPathUtils::NormalizePath(adminDir));
 449                                 (*this)[thePath] = adminDir;
 450                                 if (!isWorktree) // GitAdminDir::GetAdminDirPath returns the commongit dir ("parent/.git") and this would override the lookup path for the main repo
 451                                         m_reverseLookup[adminDir] = thePath;
 452                                 return (*this)[thePath];
 453                         }
 454                         return thePath + L".git\\"; // in case of an error stick to old behavior
 455                 }
 456
 457                 return lookup->second;
 458         }
 459
 460         CString GetAdminDirConcat(const CString& path, const CString& subpath)
 461         {
 462                 CString result(GetAdminDir(path));
 463                 result += subpath;
 464                 return result;
 465         }
 466
 467         CString GetWorktreeAdminDir(const CString& path)
 468         {
 469                 CString thePath(CPathUtils::NormalizePath(path));
 470                 CAutoLocker lock(m_critIndexSec);
 471                 auto lookup = m_WorktreeAdminDirLookup.find(thePath);
 472                 if (lookup == m_WorktreeAdminDirLookup.cend())
 473                 {
 474                         CString wtadmindir;
 475                         GitAdminDir::GetWorktreeAdminDirPath(thePath, wtadmindir);
 476                         if (PathIsDirectory(wtadmindir))
 477                         {
 478                                 wtadmindir = CPathUtils::BuildPathWithPathDelimiter(CPathUtils::NormalizePath(wtadmindir));
 479                                 m_WorktreeAdminDirLookup[thePath] = wtadmindir;
 480                                 m_reverseLookup[wtadmindir] = thePath;
 481                                 return m_WorktreeAdminDirLookup[thePath];
 482                         }
 483                         ATLASSERT(false);
 484                         return thePath + L".git\\"; // we should never get here
 485                 }
 486                 return lookup->second;
 487         }
 488
 489         CString GetWorktreeAdminDirConcat(const CString& path, const CString& subpath)
 490         {
 491                 CString result(GetWorktreeAdminDir(path));
 492                 result += subpath;
 493                 return result;
 494         }
 495
 496         CString GetWorkingCopy(const CString &gitDir)
 497         {
 498                 CString path(CPathUtils::BuildPathWithPathDelimiter(CPathUtils::NormalizePath(gitDir)));
 499                 CAutoLocker lock(m_critIndexSec);
 500                 auto lookup = m_reverseLookup.find(path);
 501                 if (lookup == m_reverseLookup.cend())
 502                         return gitDir;
 503                 return lookup->second;
 504         }
 505 };