src/Utils/PathWatcher.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // External Cache Copyright (C) 2007 - 2007 - Stefan Kueng
   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 #include "StdAfx.h"
  20 #include "Dbt.h"
  21 #include "PathWatcher.h"
  22
  23 CPathWatcher::CPathWatcher(void) : m_hCompPort(NULL)
  24         , m_bRunning(TRUE)
  25 {
  26         // enable the required privileges for this process
  27         LPCTSTR arPrivelegeNames[] = {  SE_BACKUP_NAME,
  28                                                                         SE_RESTORE_NAME,
  29                                                                         SE_CHANGE_NOTIFY_NAME
  30                                                                  };
  31
  32         for (int i=0; i<(sizeof(arPrivelegeNames)/sizeof(LPCTSTR)); ++i)
  33         {
  34                 CAutoGeneralHandle hToken;
  35                 if (OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, hToken.GetPointer()))
  36                 {
  37                         TOKEN_PRIVILEGES tp = { 1 };
  38
  39                         if (LookupPrivilegeValue(NULL, arPrivelegeNames[i],  &tp.Privileges[0].Luid))
  40                         {
  41                                 tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
  42
  43                                 AdjustTokenPrivileges(hToken, FALSE, &tp, sizeof(tp), NULL, NULL);
  44                         }
  45                 }
  46         }
  47
  48         unsigned int threadId;
  49         m_hThread = (HANDLE)_beginthreadex(NULL,0,ThreadEntry,this,0,&threadId);
  50 }
  51
  52 CPathWatcher::~CPathWatcher(void)
  53 {
  54         InterlockedExchange(&m_bRunning, FALSE);
  55         m_hThread.CloseHandle();
  56         AutoLocker lock(m_critSec);
  57         ClearInfoMap();
  58 }
  59
  60 void CPathWatcher::Stop()
  61 {
  62         InterlockedExchange(&m_bRunning, FALSE);
  63         if (m_hCompPort)
  64         {
  65                 PostQueuedCompletionStatus(m_hCompPort, 0, NULL, NULL);
  66                 m_hCompPort.CloseHandle();
  67         }
  68
  69         if (m_hThread)
  70         {
  71                 if( WaitForSingleObject(m_hThread, 1000) != WAIT_OBJECT_0 )
  72                 {
  73                         TerminateThread(m_hThread, (DWORD)-1);
  74                 }
  75                 m_hThread.CloseHandle();
  76         }
  77 }
  78
  79 bool CPathWatcher::RemovePathAndChildren(const CTGitPath& path)
  80 {
  81         bool bRemoved = false;
  82         AutoLocker lock(m_critSec);
  83 repeat:
  84         for (int i=0; i<watchedPaths.GetCount(); ++i)
  85         {
  86                 if (path.IsAncestorOf(watchedPaths[i]))
  87                 {
  88                         watchedPaths.RemovePath(watchedPaths[i]);
  89                         bRemoved = true;
  90                         goto repeat;
  91                 }
  92         }
  93         return bRemoved;
  94 }
  95
  96 bool CPathWatcher::AddPath(const CTGitPath& path)
  97 {
  98         AutoLocker lock(m_critSec);
  99         for (int i=0; i<watchedPaths.GetCount(); ++i)
 100         {
 101                 if (watchedPaths[i].IsAncestorOf(path))
 102                         return false;           // already watched (recursively)
 103         }
 104
 105         // now check if with the new path we might have a new root
 106         CTGitPath newroot;
 107         for (int i=0; i<watchedPaths.GetCount(); ++i)
 108         {
 109                 const CString& watched = watchedPaths[i].GetWinPathString();
 110                 const CString& sPath = path.GetWinPathString();
 111                 int minlen = min(sPath.GetLength(), watched.GetLength());
 112                 int len = 0;
 113                 for (len = 0; len < minlen; ++len)
 114                 {
 115                         if (watched.GetAt(len) != sPath.GetAt(len))
 116                         {
 117                                 if ((len > 1)&&(len < minlen))
 118                                 {
 119                                         if (sPath.GetAt(len)=='\\')
 120                                         {
 121                                                 newroot = CTGitPath(sPath.Left(len));
 122                                         }
 123                                         else if (watched.GetAt(len)=='\\')
 124                                         {
 125                                                 newroot = CTGitPath(watched.Left(len));
 126                                         }
 127                                 }
 128                                 break;
 129                         }
 130                 }
 131                 if (len == minlen)
 132                 {
 133                         if (sPath.GetLength() == minlen)
 134                         {
 135                                 if (watched.GetLength() > minlen)
 136                                 {
 137                                         if (watched.GetAt(len)=='\\')
 138                                         {
 139                                                 newroot = path;
 140                                         }
 141                                         else if (sPath.GetLength() == 3 && sPath[1] == ':')
 142                                         {
 143                                                 newroot = path;
 144                                         }
 145                                 }
 146                         }
 147                         else
 148                         {
 149                                 if (sPath.GetLength() > minlen)
 150                                 {
 151                                         if (sPath.GetAt(len)=='\\')
 152                                         {
 153                                                 newroot = CTGitPath(watched);
 154                                         }
 155                                         else if (watched.GetLength() == 3 && watched[1] == ':')
 156                                         {
 157                                                 newroot = CTGitPath(watched);
 158                                         }
 159                                 }
 160                         }
 161                 }
 162         }
 163         if (!newroot.IsEmpty())
 164         {
 165                 ATLTRACE(_T("add path to watch %s\n"), newroot.GetWinPath());
 166                 watchedPaths.AddPath(newroot);
 167                 watchedPaths.RemoveChildren();
 168                 m_hCompPort.CloseHandle();
 169                 return true;
 170         }
 171         ATLTRACE(_T("add path to watch %s\n"), path.GetWinPath());
 172         watchedPaths.AddPath(path);
 173         m_hCompPort.CloseHandle();
 174         return true;
 175 }
 176
 177
 178 unsigned int CPathWatcher::ThreadEntry(void* pContext)
 179 {
 180         ((CPathWatcher*)pContext)->WorkerThread();
 181         return 0;
 182 }
 183
 184 void CPathWatcher::WorkerThread()
 185 {
 186         DWORD numBytes;
 187         CDirWatchInfo * pdi = NULL;
 188         LPOVERLAPPED lpOverlapped;
 189         WCHAR buf[MAX_PATH*4] = {0};
 190         while (m_bRunning)
 191         {
 192                 if (watchedPaths.GetCount())
 193                 {
 194                         if (!m_hCompPort || !GetQueuedCompletionStatus(m_hCompPort,
 195                                                                                         &numBytes,
 196                                                                                         (PULONG_PTR) &pdi,
 197                                                                                         &lpOverlapped,
 198                                                                                         INFINITE))
 199                         {
 200                                 // Error retrieving changes
 201                                 // Clear the list of watched objects and recreate that list
 202                                 if (!m_bRunning)
 203                                         return;
 204                                 {
 205                                         AutoLocker lock(m_critSec);
 206                                         ClearInfoMap();
 207                                 }
 208                                 DWORD lasterr = GetLastError();
 209                                 if ((m_hCompPort)&&(lasterr!=ERROR_SUCCESS)&&(lasterr!=ERROR_INVALID_HANDLE))
 210                                 {
 211                                         m_hCompPort.CloseHandle();
 212                                 }
 213                                 // Since we pass m_hCompPort to CreateIoCompletionPort, we
 214                                 // have to set this to NULL to have that API create a new
 215                                 // handle.
 216                                 m_hCompPort = NULL;
 217                                 for (int i=0; i<watchedPaths.GetCount(); ++i)
 218                                 {
 219                                         CAutoFile hDir = CreateFile(watchedPaths[i].GetWinPath(),
 220                                                                                         FILE_LIST_DIRECTORY,
 221                                                                                         FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
 222                                                                                         NULL, //security attributes
 223                                                                                         OPEN_EXISTING,
 224                                                                                         FILE_FLAG_BACKUP_SEMANTICS | //required privileges: SE_BACKUP_NAME and SE_RESTORE_NAME.
 225                                                                                         FILE_FLAG_OVERLAPPED,
 226                                                                                         NULL);
 227                                         if (!hDir)
 228                                         {
 229                                                 // this could happen if a watched folder has been removed/renamed
 230                                                 m_hCompPort.CloseHandle();
 231                                                 AutoLocker lock(m_critSec);
 232                                                 watchedPaths.RemovePath(watchedPaths[i]);
 233                                                 i--; if (i<0) i=0;
 234                                                 break;
 235                                         }
 236
 237                                         CDirWatchInfo * pDirInfo = new CDirWatchInfo(hDir, watchedPaths[i]);
 238                                         hDir.Detach();  // the new CDirWatchInfo object owns the handle now
 239                                         m_hCompPort = CreateIoCompletionPort(pDirInfo->m_hDir, m_hCompPort, (ULONG_PTR)pDirInfo, 0);
 240                                         if (m_hCompPort == NULL)
 241                                         {
 242                                                 AutoLocker lock(m_critSec);
 243                                                 ClearInfoMap();
 244                                                 delete pDirInfo;
 245                                                 pDirInfo = NULL;
 246                                                 watchedPaths.RemovePath(watchedPaths[i]);
 247                                                 i--; if (i<0) i=0;
 248                                                 break;
 249                                         }
 250                                         if (!ReadDirectoryChangesW(pDirInfo->m_hDir,
 251                                                                                                 pDirInfo->m_Buffer,
 252                                                                                                 READ_DIR_CHANGE_BUFFER_SIZE,
 253                                                                                                 TRUE,
 254                                                                                                 FILE_NOTIFY_CHANGE_FILE_NAME | FILE_NOTIFY_CHANGE_DIR_NAME | FILE_NOTIFY_CHANGE_LAST_WRITE,
 255                                                                                                 &numBytes,// not used
 256                                                                                                 &pDirInfo->m_Overlapped,
 257                                                                                                 NULL))  //no completion routine!
 258                                         {
 259                                                 AutoLocker lock(m_critSec);
 260                                                 ClearInfoMap();
 261                                                 delete pDirInfo;
 262                                                 pDirInfo = NULL;
 263                                                 watchedPaths.RemovePath(watchedPaths[i]);
 264                                                 i--; if (i<0) i=0;
 265                                                 break;
 266                                         }
 267                                         AutoLocker lock(m_critSec);
 268                                         watchInfoMap[pDirInfo->m_hDir] = pDirInfo;
 269                                         ATLTRACE(_T("watching path %s\n"), pDirInfo->m_DirName.GetWinPath());
 270                                 }
 271                         }
 272                         else
 273                         {
 274                                 if (!m_bRunning)
 275                                         return;
 276                                 // NOTE: the longer this code takes to execute until ReadDirectoryChangesW
 277                                 // is called again, the higher the chance that we miss some
 278                                 // changes in the file system!
 279                                 if (pdi)
 280                                 {
 281                                         if (numBytes == 0)
 282                                         {
 283                                                 goto continuewatching;
 284                                         }
 285                                         PFILE_NOTIFY_INFORMATION pnotify = (PFILE_NOTIFY_INFORMATION)pdi->m_Buffer;
 286                                         if ((ULONG_PTR)pnotify - (ULONG_PTR)pdi->m_Buffer > READ_DIR_CHANGE_BUFFER_SIZE)
 287                                                 goto continuewatching;
 288                                         DWORD nOffset = pnotify->NextEntryOffset;
 289                                         do
 290                                         {
 291                                                 nOffset = pnotify->NextEntryOffset;
 292                                                 SecureZeroMemory(buf, MAX_PATH*4*sizeof(TCHAR));
 293                                                 _tcsncpy_s(buf, MAX_PATH*4, pdi->m_DirPath, MAX_PATH*4);
 294                                                 errno_t err = _tcsncat_s(buf+pdi->m_DirPath.GetLength(), (MAX_PATH*4)-pdi->m_DirPath.GetLength(), pnotify->FileName, _TRUNCATE);
 295                                                 if (err == STRUNCATE)
 296                                                 {
 297                                                         pnotify = (PFILE_NOTIFY_INFORMATION)((LPBYTE)pnotify + nOffset);
 298                                                         continue;
 299                                                 }
 300                                                 buf[min(MAX_PATH*4-1, pdi->m_DirPath.GetLength()+(pnotify->FileNameLength/sizeof(WCHAR)))] = 0;
 301                                                 pnotify = (PFILE_NOTIFY_INFORMATION)((LPBYTE)pnotify + nOffset);
 302                                                 ATLTRACE(_T("change notification: %s\n"), buf);
 303                                                 m_changedPaths.AddPath(CTGitPath(buf));
 304                                                 if ((ULONG_PTR)pnotify - (ULONG_PTR)pdi->m_Buffer > READ_DIR_CHANGE_BUFFER_SIZE)
 305                                                         break;
 306                                         } while (nOffset);
 307 continuewatching:
 308                                         SecureZeroMemory(pdi->m_Buffer, sizeof(pdi->m_Buffer));
 309                                         SecureZeroMemory(&pdi->m_Overlapped, sizeof(OVERLAPPED));
 310                                         if (!ReadDirectoryChangesW(pdi->m_hDir,
 311                                                                                                 pdi->m_Buffer,
 312                                                                                                 READ_DIR_CHANGE_BUFFER_SIZE,
 313                                                                                                 TRUE,
 314                                                                                                 FILE_NOTIFY_CHANGE_FILE_NAME | FILE_NOTIFY_CHANGE_DIR_NAME | FILE_NOTIFY_CHANGE_LAST_WRITE,
 315                                                                                                 &numBytes,// not used
 316                                                                                                 &pdi->m_Overlapped,
 317                                                                                                 NULL))  //no completion routine!
 318                                         {
 319                                                 // Since the call to ReadDirectoryChangesW failed, just
 320                                                 // wait a while. We don't want to have this thread
 321                                                 // running using 100% CPU if something goes completely
 322                                                 // wrong.
 323                                                 Sleep(200);
 324                                         }
 325                                 }
 326                         }
 327                 }// if (watchedPaths.GetCount())
 328                 else
 329                         Sleep(200);
 330         }// while (m_bRunning)
 331 }
 332
 333 void CPathWatcher::ClearInfoMap()
 334 {
 335         if (watchInfoMap.size()!=0)
 336         {
 337                 AutoLocker lock(m_critSec);
 338                 for (std::map<HANDLE, CDirWatchInfo *>::iterator I = watchInfoMap.begin(); I != watchInfoMap.end(); ++I)
 339                 {
 340                         CPathWatcher::CDirWatchInfo * info = I->second;
 341                         delete info;
 342                         info = NULL;
 343                 }
 344         }
 345         watchInfoMap.clear();
 346         m_hCompPort.CloseHandle();
 347 }
 348
 349 CPathWatcher::CDirWatchInfo::CDirWatchInfo(HANDLE hDir, const CTGitPath& DirectoryName) :
 350         m_hDir(hDir),
 351         m_DirName(DirectoryName)
 352 {
 353         ATLASSERT( hDir && !DirectoryName.IsEmpty());
 354         m_Buffer[0] = 0;
 355         memset(&m_Overlapped, 0, sizeof(m_Overlapped));
 356         m_DirPath = m_DirName.GetWinPathString();
 357         if (m_DirPath.GetAt(m_DirPath.GetLength()-1) != '\\')
 358                 m_DirPath += _T("\\");
 359 }
 360
 361 CPathWatcher::CDirWatchInfo::~CDirWatchInfo()
 362 {
 363         CloseDirectoryHandle();
 364 }
 365
 366 bool CPathWatcher::CDirWatchInfo::CloseDirectoryHandle()
 367 {
 368         return m_hDir.CloseHandle();
 369 }
 370