src/TGitCache/DirectoryWatcher.cpp

   1 // TortoiseSVN - a Windows shell extension for easy version control
   2
   3 // External Cache Copyright (C) 2005 - 2007 - TortoiseSVN
   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 "GitStatusCache.h"
  22 #include ".\directorywatcher.h"
  23
  24 extern HWND hWnd;
  25
  26 CDirectoryWatcher::CDirectoryWatcher(void) : m_hCompPort(NULL)
  27         , m_bRunning(TRUE)
  28         , m_FolderCrawler(NULL)
  29         , blockTickCount(0)
  30 {
  31         // enable the required privileges for this process
  32
  33         LPCTSTR arPrivelegeNames[] = {  SE_BACKUP_NAME,
  34                                                                         SE_RESTORE_NAME,
  35                                                                         SE_CHANGE_NOTIFY_NAME
  36                                                                  };
  37
  38         for (int i=0; i<(sizeof(arPrivelegeNames)/sizeof(LPCTSTR)); ++i)
  39         {
  40                 HANDLE hToken;
  41                 if (OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &hToken))
  42                 {
  43                         TOKEN_PRIVILEGES tp = { 1 };
  44
  45                         if (LookupPrivilegeValue(NULL, arPrivelegeNames[i],  &tp.Privileges[0].Luid))
  46                         {
  47                                 tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
  48
  49                                 AdjustTokenPrivileges(hToken, FALSE, &tp, sizeof(tp), NULL, NULL);
  50                         }
  51                         CloseHandle(hToken);
  52                 }
  53         }
  54
  55         unsigned int threadId;
  56         m_hThread = (HANDLE)_beginthreadex(NULL,0,ThreadEntry,this,0,&threadId);
  57 }
  58
  59 CDirectoryWatcher::~CDirectoryWatcher(void)
  60 {
  61         InterlockedExchange(&m_bRunning, FALSE);
  62         if (m_hThread != INVALID_HANDLE_VALUE)
  63         {
  64                 CloseHandle(m_hThread);
  65                 m_hThread = INVALID_HANDLE_VALUE;
  66         }
  67         AutoLocker lock(m_critSec);
  68         ClearInfoMap();
  69 }
  70
  71 void CDirectoryWatcher::Stop()
  72 {
  73         InterlockedExchange(&m_bRunning, FALSE);
  74         if (m_hThread != INVALID_HANDLE_VALUE)
  75                 CloseHandle(m_hThread);
  76         m_hThread = INVALID_HANDLE_VALUE;
  77         if (m_hCompPort != INVALID_HANDLE_VALUE)
  78                 CloseHandle(m_hCompPort);
  79         m_hCompPort = INVALID_HANDLE_VALUE;
  80 }
  81
  82 void CDirectoryWatcher::SetFolderCrawler(CFolderCrawler * crawler)
  83 {
  84         m_FolderCrawler = crawler;
  85 }
  86
  87 bool CDirectoryWatcher::RemovePathAndChildren(const CTGitPath& path)
  88 {
  89         bool bRemoved = false;
  90         AutoLocker lock(m_critSec);
  91 repeat:
  92         for (int i=0; i<watchedPaths.GetCount(); ++i)
  93         {
  94                 if (path.IsAncestorOf(watchedPaths[i]))
  95                 {
  96                         watchedPaths.RemovePath(watchedPaths[i]);
  97                         bRemoved = true;
  98                         goto repeat;
  99                 }
 100         }
 101         return bRemoved;
 102 }
 103
 104 void CDirectoryWatcher::BlockPath(const CTGitPath& path)
 105 {
 106         blockedPath = path;
 107         // block the path from being watched for 4 seconds
 108         blockTickCount = GetTickCount()+4000;
 109         ATLTRACE(_T("Blocking path: %s\n"), path.GetWinPath());
 110 }
 111
 112 bool CDirectoryWatcher::AddPath(const CTGitPath& path)
 113 {
 114         if (!CGitStatusCache::Instance().IsPathAllowed(path))
 115                 return false;
 116         if ((!blockedPath.IsEmpty())&&(blockedPath.IsAncestorOf(path)))
 117         {
 118                 if (GetTickCount() < blockTickCount)
 119                 {
 120                         ATLTRACE(_T("Path %s prevented from being watched\n"), path.GetWinPath());
 121                         return false;
 122                 }
 123         }
 124         AutoLocker lock(m_critSec);
 125         for (int i=0; i<watchedPaths.GetCount(); ++i)
 126         {
 127                 if (watchedPaths[i].IsAncestorOf(path))
 128                         return false;           // already watched (recursively)
 129         }
 130
 131         // now check if with the new path we might have a new root
 132         CTGitPath newroot;
 133         for (int i=0; i<watchedPaths.GetCount(); ++i)
 134         {
 135                 const CString& watched = watchedPaths[i].GetWinPathString();
 136                 const CString& sPath = path.GetWinPathString();
 137                 int minlen = min(sPath.GetLength(), watched.GetLength());
 138                 int len = 0;
 139                 for (len = 0; len < minlen; ++len)
 140                 {
 141                         if (watched.GetAt(len) != sPath.GetAt(len))
 142                         {
 143                                 if ((len > 1)&&(len < minlen))
 144                                 {
 145                                         if (sPath.GetAt(len)=='\\')
 146                                         {
 147                                                 newroot = CTGitPath(sPath.Left(len));
 148                                         }
 149                                         else if (watched.GetAt(len)=='\\')
 150                                         {
 151                                                 newroot = CTGitPath(watched.Left(len));
 152                                         }
 153                                 }
 154                                 break;
 155                         }
 156                 }
 157                 if (len == minlen)
 158                 {
 159                         if (sPath.GetLength() == minlen)
 160                         {
 161                                 if (watched.GetLength() > minlen)
 162                                 {
 163                                         if (watched.GetAt(len)=='\\')
 164                                         {
 165                                                 newroot = path;
 166                                         }
 167                                         else if (sPath.GetLength() == 3 && sPath[1] == ':')
 168                                         {
 169                                                 newroot = path;
 170                                         }
 171                                 }
 172                         }
 173                         else
 174                         {
 175                                 if (sPath.GetLength() > minlen)
 176                                 {
 177                                         if (sPath.GetAt(len)=='\\')
 178                                         {
 179                                                 newroot = CTGitPath(watched);
 180                                         }
 181                                         else if (watched.GetLength() == 3 && watched[1] == ':')
 182                                         {
 183                                                 newroot = CTGitPath(watched);
 184                                         }
 185                                 }
 186                         }
 187                 }
 188         }
 189         if (!newroot.IsEmpty())
 190         {
 191                 ATLTRACE(_T("add path to watch %s\n"), newroot.GetWinPath());
 192                 watchedPaths.AddPath(newroot);
 193                 watchedPaths.RemoveChildren();
 194                 CloseInfoMap();
 195                 m_hCompPort = INVALID_HANDLE_VALUE;
 196                 return true;
 197         }
 198         ATLTRACE(_T("add path to watch %s\n"), path.GetWinPath());
 199         watchedPaths.AddPath(path);
 200         CloseInfoMap();
 201         m_hCompPort = INVALID_HANDLE_VALUE;
 202         return true;
 203 }
 204
 205 bool CDirectoryWatcher::IsPathWatched(const CTGitPath& path)
 206 {
 207         AutoLocker lock(m_critSec);
 208         for (int i=0; i<watchedPaths.GetCount(); ++i)
 209         {
 210                 if (watchedPaths[i].IsAncestorOf(path))
 211                         return true;
 212         }
 213         return false;
 214 }
 215
 216 unsigned int CDirectoryWatcher::ThreadEntry(void* pContext)
 217 {
 218         ((CDirectoryWatcher*)pContext)->WorkerThread();
 219         return 0;
 220 }
 221
 222 void CDirectoryWatcher::WorkerThread()
 223 {
 224         DWORD numBytes;
 225         CDirWatchInfo * pdi = NULL;
 226         LPOVERLAPPED lpOverlapped;
 227         WCHAR buf[READ_DIR_CHANGE_BUFFER_SIZE] = {0};
 228         WCHAR * pFound = NULL;
 229         while (m_bRunning)
 230         {
 231                 if (watchedPaths.GetCount())
 232                 {
 233                         if (!GetQueuedCompletionStatus(m_hCompPort,
 234                                                                                         &numBytes,
 235                                                                                         (PULONG_PTR) &pdi,
 236                                                                                         &lpOverlapped,
 237                                                                                         INFINITE))
 238                         {
 239                                 // Error retrieving changes
 240                                 // Clear the list of watched objects and recreate that list
 241                                 if (!m_bRunning)
 242                                         return;
 243                                 {
 244                                         AutoLocker lock(m_critSec);
 245                                         ClearInfoMap();
 246                                 }
 247                                 DWORD lasterr = GetLastError();
 248                                 if ((m_hCompPort != INVALID_HANDLE_VALUE)&&(lasterr!=ERROR_SUCCESS)&&(lasterr!=ERROR_INVALID_HANDLE))
 249                                 {
 250                                         CloseHandle(m_hCompPort);
 251                                         m_hCompPort = INVALID_HANDLE_VALUE;
 252                                 }
 253                                 // Since we pass m_hCompPort to CreateIoCompletionPort, we
 254                                 // have to set this to NULL to have that API create a new
 255                                 // handle.
 256                                 m_hCompPort = NULL;
 257                                 for (int i=0; i<watchedPaths.GetCount(); ++i)
 258                                 {
 259                                         CTGitPath watchedPath = watchedPaths[i];
 260
 261                                         HANDLE hDir = CreateFile(watchedPath.GetWinPath(),
 262                                                                                         FILE_LIST_DIRECTORY,
 263                                                                                         FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
 264                                                                                         NULL, //security attributes
 265                                                                                         OPEN_EXISTING,
 266                                                                                         FILE_FLAG_BACKUP_SEMANTICS | //required privileges: SE_BACKUP_NAME and SE_RESTORE_NAME.
 267                                                                                         FILE_FLAG_OVERLAPPED,
 268                                                                                         NULL);
 269                                         if (hDir == INVALID_HANDLE_VALUE)
 270                                         {
 271                                                 // this could happen if a watched folder has been removed/renamed
 272                                                 ATLTRACE(_T("CDirectoryWatcher: CreateFile failed. Can't watch directory %s\n"), watchedPaths[i].GetWinPath());
 273                                                 CloseHandle(m_hCompPort);
 274                                                 m_hCompPort = INVALID_HANDLE_VALUE;
 275                                                 AutoLocker lock(m_critSec);
 276                                                 watchedPaths.RemovePath(watchedPath);
 277                                                 i--; if (i<0) i=0;
 278                                                 break;
 279                                         }
 280
 281                                         DEV_BROADCAST_HANDLE NotificationFilter;
 282                                         SecureZeroMemory(&NotificationFilter, sizeof(NotificationFilter));
 283                                         NotificationFilter.dbch_size = sizeof(DEV_BROADCAST_HANDLE);
 284                                         NotificationFilter.dbch_devicetype = DBT_DEVTYP_HANDLE;
 285                                         NotificationFilter.dbch_handle = hDir;
 286                                         NotificationFilter.dbch_hdevnotify = RegisterDeviceNotification(hWnd, &NotificationFilter, DEVICE_NOTIFY_WINDOW_HANDLE);
 287
 288                                         CDirWatchInfo * pDirInfo = new CDirWatchInfo(hDir, watchedPath);
 289                                         pDirInfo->m_hDevNotify = NotificationFilter.dbch_hdevnotify;
 290                                         m_hCompPort = CreateIoCompletionPort(hDir, m_hCompPort, (ULONG_PTR)pDirInfo, 0);
 291                                         if (m_hCompPort == NULL)
 292                                         {
 293                                                 ATLTRACE(_T("CDirectoryWatcher: CreateIoCompletionPort failed. Can't watch directory %s\n"), watchedPath.GetWinPath());
 294                                                 AutoLocker lock(m_critSec);
 295                                                 ClearInfoMap();
 296                                                 delete pDirInfo;
 297                                                 pDirInfo = NULL;
 298                                                 watchedPaths.RemovePath(watchedPath);
 299                                                 i--; if (i<0) i=0;
 300                                                 break;
 301                                         }
 302                                         if (!ReadDirectoryChangesW(pDirInfo->m_hDir,
 303                                                                                                 pDirInfo->m_Buffer,
 304                                                                                                 READ_DIR_CHANGE_BUFFER_SIZE,
 305                                                                                                 TRUE,
 306                                                                                                 FILE_NOTIFY_CHANGE_FILE_NAME | FILE_NOTIFY_CHANGE_DIR_NAME | FILE_NOTIFY_CHANGE_LAST_WRITE,
 307                                                                                                 &numBytes,// not used
 308                                                                                                 &pDirInfo->m_Overlapped,
 309                                                                                                 NULL))  //no completion routine!
 310                                         {
 311                                                 ATLTRACE(_T("CDirectoryWatcher: ReadDirectoryChangesW failed. Can't watch directory %s\n"), watchedPath.GetWinPath());
 312                                                 AutoLocker lock(m_critSec);
 313                                                 ClearInfoMap();
 314                                                 delete pDirInfo;
 315                                                 pDirInfo = NULL;
 316                                                 watchedPaths.RemovePath(watchedPath);
 317                                                 i--; if (i<0) i=0;
 318                                                 break;
 319                                         }
 320                                         AutoLocker lock(m_critSec);
 321                                         watchInfoMap[pDirInfo->m_hDir] = pDirInfo;
 322                                         ATLTRACE(_T("watching path %s\n"), pDirInfo->m_DirName.GetWinPath());
 323                                 }
 324                         }
 325                         else
 326                         {
 327                                 if (!m_bRunning)
 328                                         return;
 329                                 // NOTE: the longer this code takes to execute until ReadDirectoryChangesW
 330                                 // is called again, the higher the chance that we miss some
 331                                 // changes in the file system!
 332                                 if (pdi)
 333                                 {
 334                                         if (numBytes == 0)
 335                                         {
 336                                                 goto continuewatching;
 337                                         }
 338                                         PFILE_NOTIFY_INFORMATION pnotify = (PFILE_NOTIFY_INFORMATION)pdi->m_Buffer;
 339                                         if ((ULONG_PTR)pnotify - (ULONG_PTR)pdi->m_Buffer > READ_DIR_CHANGE_BUFFER_SIZE)
 340                                                 goto continuewatching;
 341                                         DWORD nOffset = pnotify->NextEntryOffset;
 342                                         do
 343                                         {
 344                                                 nOffset = pnotify->NextEntryOffset;
 345                                                 if (pnotify->FileNameLength >= (READ_DIR_CHANGE_BUFFER_SIZE*sizeof(TCHAR)))
 346                                                         continue;
 347                                                 SecureZeroMemory(buf, READ_DIR_CHANGE_BUFFER_SIZE*sizeof(TCHAR));
 348                                                 _tcsncpy_s(buf, READ_DIR_CHANGE_BUFFER_SIZE, pdi->m_DirPath, READ_DIR_CHANGE_BUFFER_SIZE);
 349                                                 errno_t err = _tcsncat_s(buf+pdi->m_DirPath.GetLength(), READ_DIR_CHANGE_BUFFER_SIZE-pdi->m_DirPath.GetLength(), pnotify->FileName, _TRUNCATE);
 350                                                 if (err == STRUNCATE)
 351                                                 {
 352                                                         pnotify = (PFILE_NOTIFY_INFORMATION)((LPBYTE)pnotify + nOffset);
 353                                                         continue;
 354                                                 }
 355                                                 buf[(pnotify->FileNameLength/sizeof(TCHAR))+pdi->m_DirPath.GetLength()] = 0;
 356                                                 pnotify = (PFILE_NOTIFY_INFORMATION)((LPBYTE)pnotify + nOffset);
 357                                                 if (m_FolderCrawler)
 358                                                 {
 359                                                         if ((pFound = wcsstr(buf, L"\\tmp"))!=NULL)
 360                                                         {
 361                                                                 pFound += 4;
 362                                                                 if (((*pFound)=='\\')||((*pFound)=='\0'))
 363                                                                 {
 364                                                                         if ((ULONG_PTR)pnotify - (ULONG_PTR)pdi->m_Buffer > READ_DIR_CHANGE_BUFFER_SIZE)
 365                                                                                 break;
 366                                                                         continue;
 367                                                                 }
 368                                                         }
 369                                                         if ((pFound = wcsstr(buf, L":\\RECYCLER\\"))!=NULL)
 370                                                         {
 371                                                                 if ((pFound-buf) < 5)
 372                                                                 {
 373                                                                         // a notification for the recycle bin - ignore it
 374                                                                         if ((ULONG_PTR)pnotify - (ULONG_PTR)pdi->m_Buffer > READ_DIR_CHANGE_BUFFER_SIZE)
 375                                                                                 break;
 376                                                                         continue;
 377                                                                 }
 378                                                         }
 379                                                         if ((pFound = wcsstr(buf, L":\\$Recycle.Bin\\"))!=NULL)
 380                                                         {
 381                                                                 if ((pFound-buf) < 5)
 382                                                                 {
 383                                                                         // a notification for the recycle bin - ignore it
 384                                                                         if ((ULONG_PTR)pnotify - (ULONG_PTR)pdi->m_Buffer > READ_DIR_CHANGE_BUFFER_SIZE)
 385                                                                                 break;
 386                                                                         continue;
 387                                                                 }
 388                                                         }
 389                                                         if ((pFound = wcsstr(buf, L".tmp"))!=NULL)
 390                                                         {
 391                                                                 // assume files with a .tmp extension are not versioned and interesting,
 392                                                                 // so ignore them.
 393                                                                 if ((ULONG_PTR)pnotify - (ULONG_PTR)pdi->m_Buffer > READ_DIR_CHANGE_BUFFER_SIZE)
 394                                                                         break;
 395                                                                 continue;
 396                                                         }
 397                                                         ATLTRACE(_T("change notification: %s\n"), buf);
 398                                                         m_FolderCrawler->AddPathForUpdate(CTGitPath(buf));
 399                                                 }
 400                                                 if ((ULONG_PTR)pnotify - (ULONG_PTR)pdi->m_Buffer > READ_DIR_CHANGE_BUFFER_SIZE)
 401                                                         break;
 402                                         } while (nOffset);
 403 continuewatching:
 404                                         SecureZeroMemory(pdi->m_Buffer, sizeof(pdi->m_Buffer));
 405                                         SecureZeroMemory(&pdi->m_Overlapped, sizeof(OVERLAPPED));
 406                                         if (!ReadDirectoryChangesW(pdi->m_hDir,
 407                                                                                                 pdi->m_Buffer,
 408                                                                                                 READ_DIR_CHANGE_BUFFER_SIZE,
 409                                                                                                 TRUE,
 410                                                                                                 FILE_NOTIFY_CHANGE_FILE_NAME | FILE_NOTIFY_CHANGE_DIR_NAME | FILE_NOTIFY_CHANGE_LAST_WRITE,
 411                                                                                                 &numBytes,// not used
 412                                                                                                 &pdi->m_Overlapped,
 413                                                                                                 NULL))  //no completion routine!
 414                                         {
 415                                                 // Since the call to ReadDirectoryChangesW failed, just
 416                                                 // wait a while. We don't want to have this thread
 417                                                 // running using 100% CPU if something goes completely
 418                                                 // wrong.
 419                                                 Sleep(200);
 420                                         }
 421                                 }
 422                         }
 423                 }// if (watchedPaths.GetCount())
 424                 else
 425                         Sleep(200);
 426         }// while (m_bRunning)
 427 }
 428
 429 void CDirectoryWatcher::ClearInfoMap()
 430 {
 431         if (watchInfoMap.size()!=0)
 432         {
 433                 AutoLocker lock(m_critSec);
 434                 for (std::map<HANDLE, CDirWatchInfo *>::iterator I = watchInfoMap.begin(); I != watchInfoMap.end(); ++I)
 435                 {
 436                         CDirectoryWatcher::CDirWatchInfo * info = I->second;
 437                         delete info;
 438                         info = NULL;
 439                 }
 440         }
 441         watchInfoMap.clear();
 442         if (m_hCompPort != INVALID_HANDLE_VALUE)
 443                 CloseHandle(m_hCompPort);
 444         m_hCompPort = INVALID_HANDLE_VALUE;
 445 }
 446
 447 CTGitPath CDirectoryWatcher::CloseInfoMap(HDEVNOTIFY hdev)
 448 {
 449         CTGitPath path;
 450         if (watchInfoMap.size() == 0)
 451                 return path;
 452         AutoLocker lock(m_critSec);
 453         for (std::map<HANDLE, CDirWatchInfo *>::iterator I = watchInfoMap.begin(); I != watchInfoMap.end(); ++I)
 454         {
 455                 CDirectoryWatcher::CDirWatchInfo * info = I->second;
 456                 if (info->m_hDevNotify == hdev)
 457                 {
 458                         path = info->m_DirName;
 459                         RemovePathAndChildren(path);
 460                         BlockPath(path);
 461                 }
 462                 info->CloseDirectoryHandle();
 463         }
 464         watchInfoMap.clear();
 465         if (m_hCompPort != INVALID_HANDLE_VALUE)
 466                 CloseHandle(m_hCompPort);
 467         m_hCompPort = INVALID_HANDLE_VALUE;
 468         return path;
 469 }
 470
 471 bool CDirectoryWatcher::CloseHandlesForPath(const CTGitPath& path)
 472 {
 473         if (watchInfoMap.size() == 0)
 474                 return false;
 475         AutoLocker lock(m_critSec);
 476         for (std::map<HANDLE, CDirWatchInfo *>::iterator I = watchInfoMap.begin(); I != watchInfoMap.end(); ++I)
 477         {
 478                 CDirectoryWatcher::CDirWatchInfo * info = I->second;
 479                 CTGitPath p = CTGitPath(info->m_DirPath);
 480                 if (path.IsAncestorOf(p))
 481                 {
 482                         RemovePathAndChildren(p);
 483                         BlockPath(p);
 484                 }
 485                 info->CloseDirectoryHandle();
 486         }
 487         watchInfoMap.clear();
 488         if (m_hCompPort != INVALID_HANDLE_VALUE)
 489                 CloseHandle(m_hCompPort);
 490         m_hCompPort = INVALID_HANDLE_VALUE;
 491         return true;
 492 }
 493
 494 CDirectoryWatcher::CDirWatchInfo::CDirWatchInfo(HANDLE hDir, const CTGitPath& DirectoryName) :
 495         m_hDir(hDir),
 496         m_DirName(DirectoryName)
 497 {
 498         ATLASSERT( hDir != INVALID_HANDLE_VALUE
 499                 && !DirectoryName.IsEmpty());
 500         memset(&m_Overlapped, 0, sizeof(m_Overlapped));
 501         m_DirPath = m_DirName.GetWinPathString();
 502         if (m_DirPath.GetAt(m_DirPath.GetLength()-1) != '\\')
 503                 m_DirPath += _T("\\");
 504         m_hDevNotify = INVALID_HANDLE_VALUE;
 505 }
 506
 507 CDirectoryWatcher::CDirWatchInfo::~CDirWatchInfo()
 508 {
 509         CloseDirectoryHandle();
 510 }
 511
 512 bool CDirectoryWatcher::CDirWatchInfo::CloseDirectoryHandle()
 513 {
 514         bool b = TRUE;
 515         if( m_hDir != INVALID_HANDLE_VALUE )
 516         {
 517                 b = !!CloseHandle(m_hDir);
 518                 m_hDir = INVALID_HANDLE_VALUE;
 519         }
 520         if (m_hDevNotify != INVALID_HANDLE_VALUE)
 521         {
 522                 UnregisterDeviceNotification(m_hDevNotify);
 523         }
 524         return b;
 525 }
 526
 527
 528
 529
 530
 531
 532
 533