src/Git/gitindex.h

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