src/Git/gitindex.h

   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 "GitHash.h"
  21 #include "gitdll.h"
  22 #include "GitStatus.h"
  23 #include "UnicodeUtils.h"
  24 #include "ReaderWriterLock.h"
  25
  26 class CGitIndex
  27 {
  28 public:
  29         CString    m_FileName;
  30         __time64_t      m_ModifyTime;
  31         unsigned short m_Flags;
  32         CGitHash        m_IndexHash;
  33         __int64         m_Size;
  34
  35         int Print();
  36 };
  37
  38 class CGitIndexList:public std::vector<CGitIndex>
  39 {
  40 protected:
  41
  42 public:
  43         __time64_t  m_LastModifyTime;
  44
  45         CGitIndexList();
  46         ~CGitIndexList();
  47
  48         int ReadIndex(CString file);
  49         int GetStatus(const CString &gitdir, const CString &path, git_wc_status_kind * status, BOOL IsFull = false, BOOL IsRecursive = false, FILL_STATUS_CALLBACK callback = nullptr, void *pData = nullptr, CGitHash *pHash = nullptr, bool * assumeValid = nullptr, bool * skipWorktree = nullptr);
  50 protected:
  51         bool m_bCheckContent;
  52         __int64 m_iMaxCheckSize;
  53         CComCriticalSection m_critRepoSec;
  54         CAutoRepository repository;
  55         int GetFileStatus(const CString &gitdir, const CString &path, git_wc_status_kind * status, __int64 time, __int64 filesize, FILL_STATUS_CALLBACK callback = nullptr, void *pData = nullptr, CGitHash *pHash = nullptr, bool * assumeValid = nullptr, bool * skipWorktree = nullptr);
  56         int GetDirStatus(const CString &gitdir, const CString &path, git_wc_status_kind * status,__int64 time, FILL_STATUS_CALLBACK callback = nullptr, void *pData = nullptr,CGitHash *pHash = nullptr);
  57 };
  58
  59 typedef std::tr1::shared_ptr<CGitIndexList> SHARED_INDEX_PTR;
  60 typedef CComCritSecLock<CComCriticalSection> CAutoLocker;
  61
  62 class CGitIndexFileMap:public std::map<CString, SHARED_INDEX_PTR>
  63 {
  64 public:
  65         CComCriticalSection                     m_critIndexSec;
  66
  67         CGitIndexFileMap() { m_critIndexSec.Init(); }
  68         ~CGitIndexFileMap() { m_critIndexSec.Term(); }
  69
  70         SHARED_INDEX_PTR SafeGet(const CString &path)
  71         {
  72                 CString thePath = path;
  73                 thePath.MakeLower();
  74                 CAutoLocker lock(m_critIndexSec);
  75                 if(this->find(thePath) == end())
  76                         return SHARED_INDEX_PTR();
  77                 else
  78                         return (*this)[thePath];
  79         }
  80
  81         void SafeSet(const CString &path, SHARED_INDEX_PTR ptr)
  82         {
  83                 CString thePath = path;
  84                 thePath.MakeLower();
  85                 CAutoLocker lock(m_critIndexSec);
  86                 (*this)[thePath] = ptr;
  87         }
  88
  89         bool SafeClear(const CString &path)
  90         {
  91                 CString thePath = path;
  92                 thePath.MakeLower();
  93                 CAutoLocker lock(m_critIndexSec);
  94                 if (this->find(thePath) == end())
  95                         return false;
  96                 (*this)[thePath] = nullptr;
  97                 return true;
  98         }
  99
 100         bool SafeClearRecursively(const CString &rootpath)
 101         {
 102                 CString thePath = rootpath;
 103                 thePath.MakeLower();
 104                 CAutoLocker lock(m_critIndexSec);
 105                 for (auto it = this->begin(); it != this->end(); ++it)
 106                 {
 107                         if ((*it).first.Find(thePath) == 0)
 108                                 (*this)[(*it).first] = nullptr;
 109                 }
 110                 return true;
 111         }
 112
 113         int Check(const CString &gitdir, bool *isChanged);
 114         int LoadIndex(const CString &gitdir);
 115
 116         bool CheckAndUpdate(const CString &gitdir,bool isLoadUpdatedIndex)
 117         {
 118                 bool isChanged=false;
 119                 if(isLoadUpdatedIndex && Check(gitdir,&isChanged))
 120                         return false;
 121
 122                 if(isChanged && isLoadUpdatedIndex)
 123                 {
 124                         LoadIndex(gitdir);
 125                         return true;
 126                 }
 127
 128                 return false;
 129         }
 130         int GetFileStatus(const CString &gitdir,const CString &path,git_wc_status_kind * status,
 131                                                         BOOL IsFull=false, BOOL IsRecursive=false,
 132                                                         FILL_STATUS_CALLBACK callback = nullptr,
 133                                                         void *pData=NULL,CGitHash *pHash=NULL,
 134                                                         bool isLoadUpdatedIndex = true, bool * assumeValid = NULL, bool * skipWorktree = NULL);
 135
 136         int IsUnderVersionControl(const CString &gitdir,
 137                                                           const CString &path,
 138                                                           bool isDir,
 139                                                           bool *isVersion,
 140                                                           bool isLoadUpdateIndex=true);
 141 };
 142
 143
 144 class CGitTreeItem
 145 {
 146 public:
 147         CString m_FileName;
 148         CGitHash        m_Hash;
 149         int                     m_Flags;
 150 };
 151
 152 /* After object create, never change field agains
 153  * that needn't lock to get field
 154 */
 155 class CGitHeadFileList:public std::vector<CGitTreeItem>
 156 {
 157 private:
 158         int GetPackRef(const CString &gitdir);
 159         CReaderWriterLock m_SharedMutex;
 160
 161         __time64_t  m_LastModifyTimeHead;
 162         __time64_t  m_LastModifyTimeRef;
 163         __time64_t      m_LastModifyTimePackRef;
 164
 165         CString         m_HeadRefFile;
 166         CGitHash        m_Head;
 167         CString         m_HeadFile;
 168         CString         m_Gitdir;
 169         CString         m_PackRefFile;
 170
 171         CGitHash        m_TreeHash; /* buffered tree hash value */
 172
 173         std::map<CString,CGitHash> m_PackRefMap;
 174
 175 public:
 176         CGitHeadFileList()
 177         {
 178                 m_LastModifyTimeHead=0;
 179                 m_LastModifyTimeRef=0;
 180                 m_LastModifyTimePackRef = 0;
 181         }
 182
 183         int ReadTree();
 184         int ReadHeadHash(CString gitdir);
 185         bool CheckHeadUpdate();
 186         bool HeadHashEqualsTreeHash();
 187         bool HeadFileIsEmpty();
 188         bool HeadIsEmpty();
 189         static int CallBack(const unsigned char *, const char *, int, const char *, unsigned int, int, void *);
 190 };
 191
 192 typedef std::tr1::shared_ptr<CGitHeadFileList> SHARED_TREE_PTR;
 193 class CGitHeadFileMap:public std::map<CString,SHARED_TREE_PTR>
 194 {
 195 public:
 196
 197         CComCriticalSection                     m_critTreeSec;
 198
 199         CGitHeadFileMap() { m_critTreeSec.Init(); }
 200         ~CGitHeadFileMap() { m_critTreeSec.Term(); }
 201
 202         SHARED_TREE_PTR SafeGet(const CString &path)
 203         {
 204                 CString thePath = path;
 205                 thePath.MakeLower();
 206                 CAutoLocker lock(m_critTreeSec);
 207                 if(this->find(thePath) == end())
 208                         return SHARED_TREE_PTR();
 209                 else
 210                         return (*this)[thePath];
 211         }
 212
 213         void SafeSet(const CString &path, SHARED_TREE_PTR ptr)
 214         {
 215                 CString thePath = path;
 216                 thePath.MakeLower();
 217                 CAutoLocker lock(m_critTreeSec);
 218                 (*this)[thePath] = ptr;
 219         }
 220
 221         int GetFileStatus(const CString &gitdir,const CString &path,git_wc_status_kind * status,BOOL IsFull=false, BOOL IsRecursive=false,
 222                                                 FILL_STATUS_CALLBACK callback = nullptr, void *pData = nullptr,
 223                                                 bool isLoaded=false);
 224         bool CheckHeadAndUpdate(const CString &gitdir, bool readTree = true);
 225         int IsUnderVersionControl(const CString &gitdir, const CString &path, bool isDir, bool *isVersion);
 226 };
 227
 228 class CGitFileName
 229 {
 230 public:
 231         CString m_FileName;
 232         CString m_CaseFileName;
 233 };
 234
 235 class CGitIgnoreItem
 236 {
 237 public:
 238         CGitIgnoreItem()
 239         {
 240                 m_LastModifyTime =0;
 241                 m_pExcludeList =NULL;
 242                 m_buffer = NULL;
 243         }
 244         ~CGitIgnoreItem()
 245         {
 246                 if(m_pExcludeList)
 247                         git_free_exclude_list(m_pExcludeList);
 248                 free(m_buffer);
 249                 m_pExcludeList=NULL;
 250                 m_buffer = NULL;
 251         }
 252         __time64_t  m_LastModifyTime;
 253         CStringA m_BaseDir;
 254         BYTE *m_buffer;
 255         EXCLUDE_LIST m_pExcludeList;
 256
 257         int FetchIgnoreList(const CString &projectroot, const CString &file, bool isGlobal);
 258 };
 259
 260 class CGitIgnoreList
 261 {
 262 private:
 263         bool CheckFileChanged(const CString &path);
 264         int FetchIgnoreFile(const CString &gitdir, const CString &gitignore, bool isGlobal);
 265
 266         int  CheckIgnore(const CString &path, const CString &root, bool isDir);
 267         int CheckFileAgainstIgnoreList(const CString &ignorefile, const CStringA &patha, const char * base, int &type);
 268
 269         // core.excludesfile stuff
 270         std::map<CString, CString> m_CoreExcludesfiles;
 271         CString m_sMsysGitBinPath;
 272         DWORD m_dMsysGitBinPathLastChecked;
 273         CReaderWriterLock       m_coreExcludefilesSharedMutex;
 274         // checks if the msysgit path has changed and return true/false
 275         // if the path changed, the cache is update
 276         // force is only ised in constructor
 277         bool CheckAndUpdateMsysGitBinpath(bool force = true);
 278         bool CheckAndUpdateCoreExcludefile(const CString &adminDir);
 279         const CString GetWindowsHome();
 280
 281 public:
 282         CReaderWriterLock               m_SharedMutex;
 283
 284         CGitIgnoreList(){ CheckAndUpdateMsysGitBinpath(true); }
 285
 286         std::map<CString, CGitIgnoreItem> m_Map;
 287
 288         bool CheckIgnoreChanged(const CString &gitdir,const CString &path, bool isDir);
 289         int  LoadAllIgnoreFile(const CString &gitdir, const CString &path, bool isDir);
 290         bool IsIgnore(const CString &path, const CString &root, bool isDir);
 291 };
 292
 293 template<class T>
 294 int GetRangeInSortVector(const T &vector, LPCTSTR pstr, int len, int *start, int *end, int pos)
 295 {
 296         if( pos < 0)
 297         {
 298                 return -1;
 299         }
 300         if(start == 0 || end == NULL)
 301                 return -1;
 302
 303         *start=*end=-1;
 304
 305         if (vector.empty())
 306                 return -1;
 307
 308         if (pos >= (int)vector.size())
 309                 return -1;
 310
 311         if( _tcsnccmp(vector[pos].m_FileName, pstr,len) != 0)
 312         {
 313                 for (int i = 0; i < (int)vector.size(); ++i)
 314                 {
 315                         if( _tcsnccmp(vector[i].m_FileName, pstr,len) == 0 )
 316                         {
 317                                 if(*start<0)
 318                                         *start =i;
 319                                 *end =i;
 320                         }
 321                 }
 322                 return -1;
 323         }
 324         else
 325         {
 326                 *start =0;
 327                 *end = (int)vector.size();
 328
 329                 for (int i = pos; i < (int)vector.size(); ++i)
 330                 {
 331                         if( _tcsnccmp(vector[i].m_FileName, pstr,len) == 0 )
 332                         {
 333                                 *end=i;
 334                         }
 335                         else
 336                         {
 337                                 break;
 338                         }
 339                 }
 340                 for(int i=pos;i>=0;i--)
 341                 {
 342                         if( _tcsnccmp(vector[i].m_FileName, pstr,len) == 0 )
 343                         {
 344                                 *start=i;
 345                         }
 346                         else
 347                         {
 348                                 break;
 349                         }
 350                 }
 351         }
 352         return 0;
 353 }
 354
 355 template<class T>
 356 int SearchInSortVector(const T &vector, LPCTSTR pstr, int len)
 357 {
 358         int end = (int)vector.size() - 1;
 359         int start = 0;
 360         int mid = (start+end)/2;
 361
 362         if (vector.empty())
 363                 return -1;
 364
 365         while(!( start == end && start==mid))
 366         {
 367                 int cmp;
 368                 if(len < 0)
 369                         cmp = _tcscmp(vector[mid].m_FileName,pstr);
 370                 else
 371                         cmp = _tcsnccmp( vector[mid].m_FileName,pstr,len );
 372
 373                 if (cmp == 0)
 374                         return mid;
 375                 else if (cmp < 0)
 376                         start = mid + 1;
 377                 else // (cmp > 0)
 378                         end = mid;
 379
 380                 mid=(start +end ) /2;
 381
 382         }
 383         if(len <0)
 384         {
 385                 if(_tcscmp(vector[mid].m_FileName,pstr) == 0)
 386                         return mid;
 387         }
 388         else
 389         {
 390                 if(_tcsnccmp( vector[mid].m_FileName,pstr,len ) == 0)
 391                         return mid;
 392         }
 393         return -1;
 394 };
 395
 396 class CGitAdminDirMap:public std::map<CString, CString>
 397 {
 398 public:
 399         CComCriticalSection                     m_critIndexSec;
 400         std::map<CString, CString>      m_reverseLookup;
 401
 402         CGitAdminDirMap() { m_critIndexSec.Init(); }
 403         ~CGitAdminDirMap() { m_critIndexSec.Term(); }
 404
 405         CString GetAdminDir(const CString &path)
 406         {
 407                 CString thePath = path;
 408                 thePath.MakeLower();
 409                 CAutoLocker lock(m_critIndexSec);
 410                 if(this->find(thePath) == end())
 411                 {
 412                         if (PathIsDirectory(path + _T("\\.git")))
 413                         {
 414                                 (*this)[thePath] = path + _T("\\.git\\");
 415                                 m_reverseLookup[thePath + _T("\\.git")] = path;
 416                                 return (*this)[thePath];
 417                         }
 418                         else
 419                         {
 420                                 FILE * pFile = _tfsopen(path + _T("\\.git"), _T("r"), SH_DENYWR);
 421                                 if (pFile)
 422                                 {
 423                                         int size = 65536;
 424                                         std::unique_ptr<char[]> buffer(new char[size]);
 425                                         int length = 0;
 426                                         if ((length = (int)fread(buffer.get(), sizeof(char), size, pFile)) >= 8)
 427                                         {
 428                                                 fclose(pFile);
 429                                                 CStringA strA(buffer.get(), length);
 430                                                 if (strA.Left(8) == "gitdir: ")
 431                                                 {
 432                                                         CString str = CUnicodeUtils::GetUnicode(strA.Trim().Mid(8)); // 8 = len("gitdir: ")
 433                                                         str.Replace(_T("/"), _T("\\"));
 434                                                         str.TrimRight(_T("\\"));
 435                                                         if (str.GetLength() > 0 && str[0] == _T('.'))
 436                                                         {
 437                                                                 str = path + _T("\\") + str;
 438                                                                 CString newPath;
 439                                                                 PathCanonicalize(newPath.GetBuffer(MAX_PATH), str.GetBuffer());
 440                                                                 newPath.ReleaseBuffer();
 441                                                                 str.ReleaseBuffer();
 442                                                                 str = newPath;
 443                                                         }
 444                                                         (*this)[thePath] = str + _T("\\");
 445                                                         m_reverseLookup[str.MakeLower()] = path;
 446                                                         return (*this)[thePath];
 447                                                 }
 448                                         }
 449                                         else
 450                                                 fclose(pFile);
 451                                 }
 452                                 return path + _T("\\.git\\"); // in case of an error stick to old behavior
 453                         }
 454                 }
 455                 else
 456                         return (*this)[thePath];
 457         }
 458
 459         CString GetWorkingCopy(const CString &gitDir)
 460         {
 461                 CString path = gitDir;
 462                 path.MakeLower();
 463                 CAutoLocker lock(m_critIndexSec);
 464                 if (m_reverseLookup.find(path) == m_reverseLookup.end())
 465                         return gitDir;
 466                 else
 467                         return m_reverseLookup[path];
 468         }
 469 };