src/Utils/PathWatcher.cpp

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