src/Utils/PathWatcher.cpp

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2013 - 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) : m_hCompPort(NULL)
  25         , m_bRunning(TRUE)
  26         , m_bLimitReached(false)
  27 {
  28         // enable the required privileges for this process
  29         LPCTSTR arPrivelegeNames[] = {  SE_BACKUP_NAME,
  30                                                                         SE_RESTORE_NAME,
  31                                                                         SE_CHANGE_NOTIFY_NAME
  32                                                                  };
  33
  34         for (int i=0; i<(sizeof(arPrivelegeNames)/sizeof(LPCTSTR)); ++i)
  35         {
  36                 CAutoGeneralHandle hToken;
  37                 if (OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, hToken.GetPointer()))
  38                 {
  39                         TOKEN_PRIVILEGES tp = { 1 };
  40
  41                         if (LookupPrivilegeValue(NULL, arPrivelegeNames[i],  &tp.Privileges[0].Luid))
  42                         {
  43                                 tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
  44
  45                                 AdjustTokenPrivileges(hToken, FALSE, &tp, sizeof(tp), NULL, NULL);
  46                         }
  47                 }
  48         }
  49
  50         unsigned int threadId = 0;
  51         m_hThread = (HANDLE)_beginthreadex(NULL,0,ThreadEntry,this,0,&threadId);
  52 }
  53
  54 CPathWatcher::~CPathWatcher(void)
  55 {
  56         Stop();
  57         AutoLocker lock(m_critSec);
  58         ClearInfoMap();
  59 }
  60
  61 void CPathWatcher::Stop()
  62 {
  63         InterlockedExchange(&m_bRunning, FALSE);
  64         if (m_hCompPort)
  65         {
  66                 PostQueuedCompletionStatus(m_hCompPort, 0, NULL, NULL);
  67                 m_hCompPort.CloseHandle();
  68         }
  69
  70         if (m_hThread)
  71         {
  72                 // the background thread sleeps for 200ms,
  73                 // so lets wait for it to finish for 1000 ms.
  74
  75                 WaitForSingleObject(m_hThread, 1000);
  76                 m_hThread.CloseHandle();
  77         }
  78 }
  79
  80 bool CPathWatcher::RemovePathAndChildren(const CTGitPath& path)
  81 {
  82         bool bRemoved = false;
  83         AutoLocker lock(m_critSec);
  84 repeat:
  85         for (int i=0; i<watchedPaths.GetCount(); ++i)
  86         {
  87                 if (path.IsAncestorOf(watchedPaths[i]))
  88                 {
  89                         watchedPaths.RemovePath(watchedPaths[i]);
  90                         bRemoved = true;
  91                         goto repeat;
  92                 }
  93         }
  94         return bRemoved;
  95 }
  96
  97 bool CPathWatcher::AddPath(const CTGitPath& path)
  98 {
  99         AutoLocker lock(m_critSec);
 100         for (int i=0; i<watchedPaths.GetCount(); ++i)
 101         {
 102                 if (watchedPaths[i].IsAncestorOf(path))
 103                         return false;           // already watched (recursively)
 104         }
 105
 106         // now check if with the new path we might have a new root
 107         CTGitPath newroot;
 108         for (int i=0; i<watchedPaths.GetCount(); ++i)
 109         {
 110                 const CString& watched = watchedPaths[i].GetWinPathString();
 111                 const CString& sPath = path.GetWinPathString();
 112                 int minlen = min(sPath.GetLength(), watched.GetLength());
 113                 int len = 0;
 114                 for (len = 0; len < minlen; ++len)
 115                 {
 116                         if (watched.GetAt(len) != sPath.GetAt(len))
 117                         {
 118                                 if ((len > 1)&&(len < minlen))
 119                                 {
 120                                         if (sPath.GetAt(len)=='\\')
 121                                         {
 122                                                 newroot = CTGitPath(sPath.Left(len));
 123                                         }
 124                                         else if (watched.GetAt(len)=='\\')
 125                                         {
 126                                                 newroot = CTGitPath(watched.Left(len));
 127                                         }
 128                                 }
 129                                 break;
 130                         }
 131                 }
 132                 if (len == minlen)
 133                 {
 134                         if (sPath.GetLength() == minlen)
 135                         {
 136                                 if (watched.GetLength() > minlen)
 137                                 {
 138                                         if (watched.GetAt(len)=='\\')
 139                                         {
 140                                                 newroot = path;
 141                                         }
 142                                         else if (sPath.GetLength() == 3 && sPath[1] == ':')
 143                                         {
 144                                                 newroot = path;
 145                                         }
 146                                 }
 147                         }
 148                         else
 149                         {
 150                                 if (sPath.GetLength() > minlen)
 151                                 {
 152                                         if (sPath.GetAt(len)=='\\')
 153                                         {
 154                                                 newroot = CTGitPath(watched);
 155                                         }
 156                                         else if (watched.GetLength() == 3 && watched[1] == ':')
 157                                         {
 158                                                 newroot = CTGitPath(watched);
 159                                         }
 160                                 }
 161                         }
 162                 }
 163         }
 164         if (!newroot.IsEmpty())
 165         {
 166                 CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": add path to watch %s\n"), newroot.GetWinPath());
 167                 watchedPaths.AddPath(newroot);
 168                 watchedPaths.RemoveChildren();
 169                 m_hCompPort.CloseHandle();
 170                 return true;
 171         }
 172         CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": add path to watch %s\n"), path.GetWinPath());
 173         watchedPaths.AddPath(path);
 174         m_hCompPort.CloseHandle();
 175         return true;
 176 }
 177
 178
 179 unsigned int CPathWatcher::ThreadEntry(void* pContext)
 180 {
 181         ((CPathWatcher*)pContext)->WorkerThread();
 182         return 0;
 183 }
 184
 185 void CPathWatcher::WorkerThread()
 186 {
 187         DWORD numBytes;
 188         CDirWatchInfo * pdi = NULL;
 189         LPOVERLAPPED lpOverlapped;
 190         const int bufferSize = MAX_PATH * 4;
 191         TCHAR buf[bufferSize] = {0};
 192         while (m_bRunning)
 193         {
 194                 if (!watchedPaths.IsEmpty())
 195                 {
 196                         if (!m_hCompPort || !GetQueuedCompletionStatus(m_hCompPort,
 197                                                                                         &numBytes,
 198                                                                                         (PULONG_PTR) &pdi,
 199                                                                                         &lpOverlapped,
 200                                                                                         INFINITE))
 201                         {
 202                                 // Error retrieving changes
 203                                 // Clear the list of watched objects and recreate that list
 204                                 if (!m_bRunning)
 205                                         return;
 206                                 {
 207                                         AutoLocker lock(m_critSec);
 208                                         ClearInfoMap();
 209                                 }
 210                                 DWORD lasterr = GetLastError();
 211                                 if ((m_hCompPort)&&(lasterr!=ERROR_SUCCESS)&&(lasterr!=ERROR_INVALID_HANDLE))
 212                                 {
 213                                         m_hCompPort.CloseHandle();
 214                                 }
 215                                 for (int i=0; i<watchedPaths.GetCount(); ++i)
 216                                 {
 217                                         CAutoFile hDir = CreateFile(watchedPaths[i].GetWinPath(),
 218                                                                                                 FILE_LIST_DIRECTORY,
 219                                                                                                 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
 220                                                                                                 NULL, //security attributes
 221                                                                                                 OPEN_EXISTING,
 222                                                                                                 FILE_FLAG_BACKUP_SEMANTICS | //required privileges: SE_BACKUP_NAME and SE_RESTORE_NAME.
 223                                                                                                 FILE_FLAG_OVERLAPPED,
 224                                                                                                 NULL);
 225                                         if (!hDir)
 226                                         {
 227                                                 // this could happen if a watched folder has been removed/renamed
 228                                                 m_hCompPort.CloseHandle();
 229                                                 AutoLocker lock(m_critSec);
 230                                                 watchedPaths.RemovePath(watchedPaths[i]);
 231                                                 i--; if (i<0) i=0;
 232                                                 break;
 233                                         }
 234
 235                                         CDirWatchInfo * pDirInfo = new CDirWatchInfo(hDir, watchedPaths[i]);
 236                                         hDir.Detach();  // 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 == NULL)
 239                                         {
 240                                                 AutoLocker lock(m_critSec);
 241                                                 ClearInfoMap();
 242                                                 delete pDirInfo;
 243                                                 pDirInfo = NULL;
 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                                                                                                 NULL))  //no completion routine!
 256                                         {
 257                                                 AutoLocker lock(m_critSec);
 258                                                 ClearInfoMap();
 259                                                 delete pDirInfo;
 260                                                 pDirInfo = NULL;
 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__) _T(": 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                                                 _tcsncpy_s(buf, bufferSize, pdi->m_DirPath, bufferSize);
 292                                                 errno_t err = _tcsncat_s(buf+pdi->m_DirPath.GetLength(), bufferSize-pdi->m_DirPath.GetLength(), pnotify->FileName, min(bufferSize-pdi->m_DirPath.GetLength(), 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)))] = 0;
 299                                                 pnotify = (PFILE_NOTIFY_INFORMATION)((LPBYTE)pnotify + nOffset);
 300                                                 CTraceToOutputDebugString::Instance()(_T(__FUNCTION__) _T(": 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                                                                                                 NULL))  //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 = NULL;
 351                 }
 352         }
 353         watchInfoMap.clear();
 354         m_hCompPort.CloseHandle();
 355 }
 356
 357 CPathWatcher::CDirWatchInfo::CDirWatchInfo(HANDLE hDir, const CTGitPath& DirectoryName)
 358         : m_hDir(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 += _T("\\");
 367 }
 368
 369 CPathWatcher::CDirWatchInfo::~CDirWatchInfo()
 370 {
 371         CloseDirectoryHandle();
 372 }
 373
 374 bool CPathWatcher::CDirWatchInfo::CloseDirectoryHandle()
 375 {
 376         return m_hDir.CloseHandle();
 377 }