src/Git/gitindex.h

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