native/fileWatcher/fileWatcher3.cpp - platform/tools/idea - Git at Google

 /*
  * Copyright 2000-2011 JetBrains s.r.o.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include "stdafx.h"

 struct WatchRootInfo {
 	char driveLetter;
 	HANDLE hThread;
 	HANDLE hStopEvent;
 	bool bInitialized;
 	bool bUsed;
 	bool bFailed;
 };

 struct WatchRoot {
 	char *path;
 	WatchRoot *next;
 };

 const int ROOT_COUNT = 26;

 WatchRootInfo watchRootInfos[ROOT_COUNT];

 WatchRoot *firstWatchRoot = NULL;

 CRITICAL_SECTION csOutput;

 void NormalizeSlashes(char *path, char slash)
 {
 	for(char *p=path; *p; p++)
 		if (*p == '\\' || *p == '/')
 			*p = slash;
 }

 // -- Watchable root checks ---------------------------------------------------

 bool IsNetworkDrive(const char *name)
 {
     const int BUF_SIZE = 1024;
     char buffer[BUF_SIZE];
     UNIVERSAL_NAME_INFO* uni = (UNIVERSAL_NAME_INFO*) buffer;
     DWORD size = BUF_SIZE;

     DWORD result = WNetGetUniversalNameA(
         name,  // path for network resource
         UNIVERSAL_NAME_INFO_LEVEL, // level of information
         buffer, // name buffer
         &size // size of buffer
     );

     return result == NO_ERROR;
 }

 bool IsUnwatchableFS(const char *path)
 {
     char volumeName[MAX_PATH];
 	char fsName[MAX_PATH];
 	DWORD fsFlags;
 	DWORD maxComponentLength;
 	SetErrorMode(SEM_FAILCRITICALERRORS);
 	if (!GetVolumeInformationA(path, volumeName, MAX_PATH-1, NULL, &maxComponentLength, &fsFlags, fsName, MAX_PATH-1))
 		return false;
 	if (strcmp(fsName, "NTFS") && strcmp(fsName, "FAT") && strcmp(fsName, "FAT32"))
 		return true;

     if (!strcmp(fsName, "NTFS") && maxComponentLength != 255 && !(fsFlags & FILE_SUPPORTS_REPARSE_POINTS))
 	{
 		// SAMBA reports itself as NTFS
 		return true;
 	}

 	return false;
 }

 bool IsWatchable(const char *path)
 {
 	if (IsNetworkDrive(path))
 		return false;
 	if (IsUnwatchableFS(path))
 		return false;
 	return true;
 }

 // -- Substed drive checks ----------------------------------------------------

 void PrintRemapForSubstDrive(char driveLetter)
 {
     const int BUF_SIZE = 1024;
     char targetPath[BUF_SIZE];

 	char rootPath[8];
 	sprintf_s(rootPath, 8, "%c:", driveLetter);

     DWORD result = QueryDosDeviceA(rootPath, targetPath, BUF_SIZE);
     if (result == 0) {
         return;
     }
     else
 	{
         if (targetPath[0] == '\\' && targetPath[1] == '?' && targetPath[2] == '?' && targetPath[3] == '\\')
 		{
 			// example path: \??\C:\jetbrains\idea
 			NormalizeSlashes(targetPath, '/');
 			printf("%c:\n%s\n", driveLetter, targetPath+4);
 		}
     }
 }

 void PrintRemapForSubstDrives()
 {
 	for(int i=0; i<ROOT_COUNT; i++)
 	{
 		if (watchRootInfos [i].bUsed)
 		{
 			PrintRemapForSubstDrive(watchRootInfos [i].driveLetter);
 		}
 	}
 }

 // -- Mount point enumeration -------------------------------------------------

 const int BUFSIZE = 1024;

 void PrintDirectoryReparsePoint(const char *path)
 {
 	int size = strlen(path)+2;
 	char *directory = (char *) malloc(size);
 	strcpy_s(directory, size, path);
 	NormalizeSlashes(directory, '\\');
 	if (directory [strlen(directory)-1] != '\\')
 		strcat_s(directory, size, "\\");

 	char volumeName[_MAX_PATH];
 	int rc = GetVolumeNameForVolumeMountPointA(directory, volumeName, sizeof(volumeName));
 	if (rc)
 	{
 		char volumePathNames[_MAX_PATH];
 		DWORD returnLength;
 		rc = GetVolumePathNamesForVolumeNameA(volumeName, volumePathNames, sizeof(volumePathNames), &returnLength);
 		if (rc)
 		{
 			char *p = volumePathNames;
 			while(*p)
 			{
 				if (_stricmp(p, directory))   // if it's not the path we've already found
 				{
 					NormalizeSlashes(directory, '/');
 					NormalizeSlashes(p, '/');
 					puts(directory);
 					puts(p);
 				}
 				p += strlen(p)+1;
 			}
 		}
 	}
 	free(directory);
 }

 bool PrintMountPointsForVolume(HANDLE hVol, const char* volumePath, char *Buf)
 {
     HANDLE hPt;                  // handle for mount point scan
     char Path[BUFSIZE];          // string buffer for mount points
     DWORD dwSysFlags;            // flags that describe the file system
     char FileSysNameBuf[BUFSIZE];

     // Is this volume NTFS?
     GetVolumeInformationA(Buf, NULL, 0, NULL, NULL, &dwSysFlags, FileSysNameBuf, BUFSIZE);

     // Detect support for reparse points, and therefore for volume
     // mount points, which are implemented using reparse points.

     if (! (dwSysFlags & FILE_SUPPORTS_REPARSE_POINTS)) {
        return true;
     }

     // Start processing mount points on this volume.
     hPt = FindFirstVolumeMountPointA(
         Buf, // root path of volume to be scanned
         Path, // pointer to output string
         BUFSIZE // size of output buffer
     );

     // Shall we error out?
     if (hPt == INVALID_HANDLE_VALUE) {
 		return GetLastError() != ERROR_ACCESS_DENIED;
     }

     // Process the volume mount point.
 	char *buf = new char[MAX_PATH];
     do {
 		strcpy_s(buf, MAX_PATH, volumePath);
 		strcat_s(buf, MAX_PATH, Path);
 		PrintDirectoryReparsePoint(buf);
     } while (FindNextVolumeMountPointA(hPt, Path, BUFSIZE));

     FindVolumeMountPointClose(hPt);
 	return true;
 }

 bool PrintMountPoints(const char *path)
 {
 	char volumeUniqueName[128];
 	BOOL res = GetVolumeNameForVolumeMountPointA(path, volumeUniqueName, 128);
 	if (!res) {
         return false;
     }

     char buf[BUFSIZE];            // buffer for unique volume identifiers
     HANDLE hVol;                  // handle for the volume scan

     // Open a scan for volumes.
     hVol = FindFirstVolumeA(buf, BUFSIZE );

     // Shall we error out?
     if (hVol == INVALID_HANDLE_VALUE) {
         return false;
     }

     bool success = true;
 	do {
        if (!strcmp(buf, volumeUniqueName)) {
 		   success = PrintMountPointsForVolume(hVol, path, buf);
 		   if (!success) break;
 	   }
     } while (FindNextVolumeA(hVol, buf, BUFSIZE));

     FindVolumeClose(hVol);
 	return success;
 }

 // -- Searching for mount points in watch roots (fallback) --------------------

 void PrintDirectoryReparsePoints(const char *path)
 {
 	char *const buf = _strdup(path);
 	while(strchr(buf, '/'))
 	{
 		DWORD attributes = GetFileAttributesA(buf);
 		if (attributes == INVALID_FILE_ATTRIBUTES)
 			break;
 		if (attributes & FILE_ATTRIBUTE_REPARSE_POINT)
 		{
 			PrintDirectoryReparsePoint(buf);
 		}
 		char *pSlash = strrchr(buf, '/');
 		if (pSlash)
 		{
 			*pSlash = '\0';
 		}
 	}
 	free(buf);
 }

 // This is called if we got an ERROR_ACCESS_DENIED when trying to enumerate all mount points for volume.
 // In this case, we walk the directory tree up from each watch root, and look at each parent directory
 // to check whether it's a reparse point.
 void PrintWatchRootReparsePoints()
 {
 	WatchRoot *pWatchRoot = firstWatchRoot;
 	while(pWatchRoot)
 	{
 		PrintDirectoryReparsePoints(pWatchRoot->path);
 		pWatchRoot = pWatchRoot->next;
 	}
 }

 // -- Watcher thread ----------------------------------------------------------

 void PrintChangeInfo(char *rootPath, FILE_NOTIFY_INFORMATION *info)
 {
 	char FileNameBuffer[_MAX_PATH];
 	int converted = WideCharToMultiByte(CP_ACP, 0, info->FileName, info->FileNameLength/sizeof(WCHAR), FileNameBuffer, _MAX_PATH-1, NULL, NULL);
 	FileNameBuffer[converted] = '\0';
 	char *command;
 	if (info->Action == FILE_ACTION_ADDED || info->Action == FILE_ACTION_RENAMED_OLD_NAME)
 	{
 		command = "CREATE";
 	}
 	else if (info->Action == FILE_ACTION_REMOVED || info->Action == FILE_ACTION_RENAMED_OLD_NAME)
 	{
 		command = "DELETE";
 	}
 	else if (info->Action == FILE_ACTION_MODIFIED)
 	{
 		command = "CHANGE";
 	}
 	else
 	{
 		return;  // unknown command
 	}

 	EnterCriticalSection(&csOutput);
 	puts(command);
 	printf("%s", rootPath);
 	puts(FileNameBuffer);
 	fflush(stdout);
 	LeaveCriticalSection(&csOutput);
 }

 void PrintEverythingChangedUnderRoot(char *rootPath)
 {
 	EnterCriticalSection(&csOutput);
 	puts("RECDIRTY");
 	puts(rootPath);
 	fflush(stdout);
 	LeaveCriticalSection(&csOutput);
 }

 DWORD WINAPI WatcherThread(void *param)
 {
 	WatchRootInfo *info = (WatchRootInfo *) param;

 	OVERLAPPED overlapped;
 	memset(&overlapped, 0, sizeof(overlapped));
 	overlapped.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);

 	char rootPath[8];
 	sprintf_s(rootPath, 8, "%c:\\", info->driveLetter);
 	HANDLE hRootDir = CreateFileA(rootPath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
 		NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED, NULL);

 	int buffer_size = 10240;
 	char *buffer = new char[buffer_size];

 	HANDLE handles [2];
 	handles [0] = info->hStopEvent;
 	handles [1] = overlapped.hEvent;
 	while(true)
 	{
 		int rcDir = ReadDirectoryChangesW(hRootDir, buffer, buffer_size, TRUE,
 			FILE_NOTIFY_CHANGE_FILE_NAME |
 			FILE_NOTIFY_CHANGE_DIR_NAME |
 			FILE_NOTIFY_CHANGE_ATTRIBUTES |
 			FILE_NOTIFY_CHANGE_SIZE |
 			FILE_NOTIFY_CHANGE_LAST_WRITE,
 			NULL,
 			&overlapped,
 			NULL);
 		if (rcDir == 0)
 		{
 			info->bFailed = true;
 			break;
 		}

 		int rc = WaitForMultipleObjects(2, handles, FALSE, INFINITE);
 		if (rc == WAIT_OBJECT_0)
 		{
 			break;
 		}
 		if (rc == WAIT_OBJECT_0+1)
 		{
 			DWORD dwBytesReturned;
 			if(!GetOverlappedResult(hRootDir, &overlapped, &dwBytesReturned, FALSE))
 			{
 				info->bFailed = true;
 				break;
 			}

 			if (dwBytesReturned == 0)
 			{
 				// don't send dirty too much, everything is changed anyway
 				if (WaitForSingleObject(info->hStopEvent, 500) == WAIT_OBJECT_0)
 					break;

 				// Got a buffer overflow => current changes lost => send RECDIRTY on root
 				PrintEverythingChangedUnderRoot(rootPath);
 			} else {
 				FILE_NOTIFY_INFORMATION *info = (FILE_NOTIFY_INFORMATION *) buffer;
 				while(true)
 				{
 					PrintChangeInfo(rootPath, info);
 					if (!info->NextEntryOffset)
 						break;
 					info = (FILE_NOTIFY_INFORMATION *) ((char *) info + info->NextEntryOffset);
 				}
 			}
 		}
 	}
 	CloseHandle(overlapped.hEvent);
 	CloseHandle(hRootDir);
 	delete[] buffer;
 	return 0;
 }

 // -- Roots update ------------------------------------------------------------

 void MarkAllRootsUnused()
 {
 	for(int i=0; i<ROOT_COUNT; i++)
 	{
 		watchRootInfos [i].bUsed = false;
 	}
 }

 void StartRoot(WatchRootInfo *info)
 {
 	info->hStopEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
 	info->hThread = CreateThread(NULL, 0, &WatcherThread, info, 0, NULL);
 	info->bInitialized = true;
 }

 void StopRoot(WatchRootInfo *info)
 {
 	SetEvent(info->hStopEvent);
 	WaitForSingleObject(info->hThread, INFINITE);
 	CloseHandle(info->hThread);
 	CloseHandle(info->hStopEvent);
 	info->bInitialized = false;
 }

 void UpdateRoots()
 {
 	char infoBuffer [256];
 	strcpy_s(infoBuffer, "UNWATCHEABLE\n");
 	for(int i=0; i<ROOT_COUNT; i++)
 	{
 		if (watchRootInfos [i].bInitialized && (!watchRootInfos [i].bUsed || watchRootInfos [i].bFailed))
 		{
 			StopRoot(&watchRootInfos [i]);
 			watchRootInfos [i].bFailed = false;
 		}
 		if (watchRootInfos [i].bUsed)
 		{
 			char rootPath[8];
 			sprintf_s(rootPath, 8, "%c:\\", watchRootInfos [i].driveLetter);
 			if (!IsWatchable(rootPath))
 			{
 				strcat_s(infoBuffer, rootPath);
 				strcat_s(infoBuffer, "\n");
 				continue;
 			}
 			if (!watchRootInfos [i].bInitialized)
 			{
 				StartRoot(&watchRootInfos [i]);
 			}
 		}
 	}
 	EnterCriticalSection(&csOutput);
 	fprintf(stdout, "%s", infoBuffer);
 	puts("#\nREMAP");
 	PrintRemapForSubstDrives();
 	bool printedMountPoints = true;
 	for(int i=0; i<ROOT_COUNT; i++)
 	{
 		if (watchRootInfos [i].bUsed)
 		{
 			char rootPath[8];
 			sprintf_s(rootPath, 8, "%c:\\", watchRootInfos [i].driveLetter);
 			if (!PrintMountPoints(rootPath))
 				printedMountPoints = false;
 		}
 	}
 	if (!printedMountPoints)
 	{
 		PrintWatchRootReparsePoints();
 	}
 	puts("#");
 	fflush(stdout);
 	LeaveCriticalSection(&csOutput);
 }

 void AddWatchRoot(const char *path)
 {
 	WatchRoot *watchRoot = (WatchRoot *) malloc(sizeof(WatchRoot));
 	watchRoot->next = NULL;
 	watchRoot->path = _strdup(path);
 	watchRoot->next = firstWatchRoot;
 	firstWatchRoot = watchRoot;
 }

 void FreeWatchRootsList()
 {
 	WatchRoot *pWatchRoot = firstWatchRoot;
 	WatchRoot *pNext;
 	while(pWatchRoot)
 	{
 		pNext = pWatchRoot->next;
 		free(pWatchRoot->path);
 		free(pWatchRoot);
 		pWatchRoot=pNext;
 	}
 	firstWatchRoot = NULL;
 }

 // -- Main - filewatcher protocol ---------------------------------------------

 int _tmain(int argc, _TCHAR* argv[])
 {
 	InitializeCriticalSection(&csOutput);

 	for(int i=0; i<26; i++)
 	{
 		watchRootInfos [i].driveLetter = 'A' + i;
 		watchRootInfos [i].bInitialized = false;
 		watchRootInfos [i].bUsed = false;
 	}

 	char buffer[8192];
 	while(true)
 	{
 		if (!gets_s(buffer, sizeof(buffer)-1))
 			break;

 		if (!strcmp(buffer, "ROOTS"))
 		{
 			MarkAllRootsUnused();
 			FreeWatchRootsList();
 			bool failed = false;
 			while(true)
 			{
 				if (!gets_s(buffer, sizeof(buffer)-1))
 				{
 					failed = true;
 					break;
 				}
 				if (buffer [0] == '#')
 					break;
 				int driveLetterPos = 0;
 				char *pDriveLetter = buffer;
 				if (*pDriveLetter == '|')
 					pDriveLetter++;

 				AddWatchRoot(pDriveLetter);

 				_strupr_s(buffer, sizeof(buffer)-1);
 				char driveLetter = *pDriveLetter;
 				if (driveLetter >= 'A' && driveLetter <= 'Z')
 				{
 					watchRootInfos [driveLetter-'A'].bUsed = true;
 				}
 			}
 			if (failed)
 				break;

 			UpdateRoots();
 		}
 		if (!strcmp(buffer, "EXIT"))
 			break;
 	}

 	MarkAllRootsUnused();
 	UpdateRoots();

 	DeleteCriticalSection(&csOutput);
 }
	/*
	* Copyright 2000-2011 JetBrains s.r.o.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include "stdafx.h"

	struct WatchRootInfo {
	char driveLetter;
	HANDLE hThread;
	HANDLE hStopEvent;
	bool bInitialized;
	bool bUsed;
	bool bFailed;
	};

	struct WatchRoot {
	char *path;
	WatchRoot *next;
	};

	const int ROOT_COUNT = 26;

	WatchRootInfo watchRootInfos[ROOT_COUNT];

	WatchRoot *firstWatchRoot = NULL;

	CRITICAL_SECTION csOutput;

	void NormalizeSlashes(char *path, char slash)
	{
	for(char p=path; p; p++)
	if (p == '\\' \|\| p == '/')
	*p = slash;
	}

	// -- Watchable root checks ---------------------------------------------------

	bool IsNetworkDrive(const char *name)
	{
	const int BUF_SIZE = 1024;
	char buffer[BUF_SIZE];
	UNIVERSAL_NAME_INFO* uni = (UNIVERSAL_NAME_INFO*) buffer;
	DWORD size = BUF_SIZE;

	DWORD result = WNetGetUniversalNameA(
	name, // path for network resource
	UNIVERSAL_NAME_INFO_LEVEL, // level of information
	buffer, // name buffer
	&size // size of buffer
	);

	return result == NO_ERROR;
	}

	bool IsUnwatchableFS(const char *path)
	{
	char volumeName[MAX_PATH];
	char fsName[MAX_PATH];
	DWORD fsFlags;
	DWORD maxComponentLength;
	SetErrorMode(SEM_FAILCRITICALERRORS);
	if (!GetVolumeInformationA(path, volumeName, MAX_PATH-1, NULL, &maxComponentLength, &fsFlags, fsName, MAX_PATH-1))
	return false;
	if (strcmp(fsName, "NTFS") && strcmp(fsName, "FAT") && strcmp(fsName, "FAT32"))
	return true;

	if (!strcmp(fsName, "NTFS") && maxComponentLength != 255 && !(fsFlags & FILE_SUPPORTS_REPARSE_POINTS))
	{
	// SAMBA reports itself as NTFS
	return true;
	}

	return false;
	}

	bool IsWatchable(const char *path)
	{
	if (IsNetworkDrive(path))
	return false;
	if (IsUnwatchableFS(path))
	return false;
	return true;
	}

	// -- Substed drive checks ----------------------------------------------------

	void PrintRemapForSubstDrive(char driveLetter)
	{
	const int BUF_SIZE = 1024;
	char targetPath[BUF_SIZE];

	char rootPath[8];
	sprintf_s(rootPath, 8, "%c:", driveLetter);

	DWORD result = QueryDosDeviceA(rootPath, targetPath, BUF_SIZE);
	if (result == 0) {
	return;
	}
	else
	{
	if (targetPath[0] == '\\' && targetPath[1] == '?' && targetPath[2] == '?' && targetPath[3] == '\\')
	{
	// example path: \??\C:\jetbrains\idea
	NormalizeSlashes(targetPath, '/');
	printf("%c:\n%s\n", driveLetter, targetPath+4);
	}
	}
	}

	void PrintRemapForSubstDrives()
	{
	for(int i=0; i<ROOT_COUNT; i++)
	{
	if (watchRootInfos [i].bUsed)
	{
	PrintRemapForSubstDrive(watchRootInfos [i].driveLetter);
	}
	}
	}

	// -- Mount point enumeration -------------------------------------------------

	const int BUFSIZE = 1024;

	void PrintDirectoryReparsePoint(const char *path)
	{
	int size = strlen(path)+2;
	char directory = (char ) malloc(size);
	strcpy_s(directory, size, path);
	NormalizeSlashes(directory, '\\');
	if (directory [strlen(directory)-1] != '\\')
	strcat_s(directory, size, "\\");

	char volumeName[_MAX_PATH];
	int rc = GetVolumeNameForVolumeMountPointA(directory, volumeName, sizeof(volumeName));
	if (rc)
	{
	char volumePathNames[_MAX_PATH];
	DWORD returnLength;
	rc = GetVolumePathNamesForVolumeNameA(volumeName, volumePathNames, sizeof(volumePathNames), &returnLength);
	if (rc)
	{
	char *p = volumePathNames;
	while(*p)
	{
	if (_stricmp(p, directory)) // if it's not the path we've already found
	{
	NormalizeSlashes(directory, '/');
	NormalizeSlashes(p, '/');
	puts(directory);
	puts(p);
	}
	p += strlen(p)+1;
	}
	}
	}
	free(directory);
	}

	bool PrintMountPointsForVolume(HANDLE hVol, const char* volumePath, char *Buf)
	{
	HANDLE hPt; // handle for mount point scan
	char Path[BUFSIZE]; // string buffer for mount points
	DWORD dwSysFlags; // flags that describe the file system
	char FileSysNameBuf[BUFSIZE];

	// Is this volume NTFS?
	GetVolumeInformationA(Buf, NULL, 0, NULL, NULL, &dwSysFlags, FileSysNameBuf, BUFSIZE);

	// Detect support for reparse points, and therefore for volume
	// mount points, which are implemented using reparse points.

	if (! (dwSysFlags & FILE_SUPPORTS_REPARSE_POINTS)) {
	return true;
	}

	// Start processing mount points on this volume.
	hPt = FindFirstVolumeMountPointA(
	Buf, // root path of volume to be scanned
	Path, // pointer to output string
	BUFSIZE // size of output buffer
	);

	// Shall we error out?
	if (hPt == INVALID_HANDLE_VALUE) {
	return GetLastError() != ERROR_ACCESS_DENIED;
	}

	// Process the volume mount point.
	char *buf = new char[MAX_PATH];
	do {
	strcpy_s(buf, MAX_PATH, volumePath);
	strcat_s(buf, MAX_PATH, Path);
	PrintDirectoryReparsePoint(buf);
	} while (FindNextVolumeMountPointA(hPt, Path, BUFSIZE));

	FindVolumeMountPointClose(hPt);
	return true;
	}

	bool PrintMountPoints(const char *path)
	{
	char volumeUniqueName[128];
	BOOL res = GetVolumeNameForVolumeMountPointA(path, volumeUniqueName, 128);
	if (!res) {
	return false;
	}

	char buf[BUFSIZE]; // buffer for unique volume identifiers
	HANDLE hVol; // handle for the volume scan

	// Open a scan for volumes.
	hVol = FindFirstVolumeA(buf, BUFSIZE );

	// Shall we error out?
	if (hVol == INVALID_HANDLE_VALUE) {
	return false;
	}

	bool success = true;
	do {
	if (!strcmp(buf, volumeUniqueName)) {
	success = PrintMountPointsForVolume(hVol, path, buf);
	if (!success) break;
	}
	} while (FindNextVolumeA(hVol, buf, BUFSIZE));

	FindVolumeClose(hVol);
	return success;
	}

	// -- Searching for mount points in watch roots (fallback) --------------------

	void PrintDirectoryReparsePoints(const char *path)
	{
	char *const buf = _strdup(path);
	while(strchr(buf, '/'))
	{
	DWORD attributes = GetFileAttributesA(buf);
	if (attributes == INVALID_FILE_ATTRIBUTES)
	break;
	if (attributes & FILE_ATTRIBUTE_REPARSE_POINT)
	{
	PrintDirectoryReparsePoint(buf);
	}
	char *pSlash = strrchr(buf, '/');
	if (pSlash)
	{
	*pSlash = '\0';
	}
	}
	free(buf);
	}

	// This is called if we got an ERROR_ACCESS_DENIED when trying to enumerate all mount points for volume.
	// In this case, we walk the directory tree up from each watch root, and look at each parent directory
	// to check whether it's a reparse point.
	void PrintWatchRootReparsePoints()
	{
	WatchRoot *pWatchRoot = firstWatchRoot;
	while(pWatchRoot)
	{
	PrintDirectoryReparsePoints(pWatchRoot->path);
	pWatchRoot = pWatchRoot->next;
	}
	}

	// -- Watcher thread ----------------------------------------------------------

	void PrintChangeInfo(char rootPath, FILE_NOTIFY_INFORMATION info)
	{
	char FileNameBuffer[_MAX_PATH];
	int converted = WideCharToMultiByte(CP_ACP, 0, info->FileName, info->FileNameLength/sizeof(WCHAR), FileNameBuffer, _MAX_PATH-1, NULL, NULL);
	FileNameBuffer[converted] = '\0';
	char *command;
	if (info->Action == FILE_ACTION_ADDED \|\| info->Action == FILE_ACTION_RENAMED_OLD_NAME)
	{
	command = "CREATE";
	}
	else if (info->Action == FILE_ACTION_REMOVED \|\| info->Action == FILE_ACTION_RENAMED_OLD_NAME)
	{
	command = "DELETE";
	}
	else if (info->Action == FILE_ACTION_MODIFIED)
	{
	command = "CHANGE";
	}
	else
	{
	return; // unknown command
	}

	EnterCriticalSection(&csOutput);
	puts(command);
	printf("%s", rootPath);
	puts(FileNameBuffer);
	fflush(stdout);
	LeaveCriticalSection(&csOutput);
	}

	void PrintEverythingChangedUnderRoot(char *rootPath)
	{
	EnterCriticalSection(&csOutput);
	puts("RECDIRTY");
	puts(rootPath);
	fflush(stdout);
	LeaveCriticalSection(&csOutput);
	}

	DWORD WINAPI WatcherThread(void *param)
	{
	WatchRootInfo info = (WatchRootInfo ) param;

	OVERLAPPED overlapped;
	memset(&overlapped, 0, sizeof(overlapped));
	overlapped.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);

	char rootPath[8];
	sprintf_s(rootPath, 8, "%c:\\", info->driveLetter);
	HANDLE hRootDir = CreateFileA(rootPath, GENERIC_READ, FILE_SHARE_READ \| FILE_SHARE_WRITE \| FILE_SHARE_DELETE,
	NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS \| FILE_FLAG_OVERLAPPED, NULL);

	int buffer_size = 10240;
	char *buffer = new char[buffer_size];

	HANDLE handles [2];
	handles [0] = info->hStopEvent;
	handles [1] = overlapped.hEvent;
	while(true)
	{
	int rcDir = ReadDirectoryChangesW(hRootDir, buffer, buffer_size, TRUE,
	FILE_NOTIFY_CHANGE_FILE_NAME \|
	FILE_NOTIFY_CHANGE_DIR_NAME \|
	FILE_NOTIFY_CHANGE_ATTRIBUTES \|
	FILE_NOTIFY_CHANGE_SIZE \|
	FILE_NOTIFY_CHANGE_LAST_WRITE,
	NULL,
	&overlapped,
	NULL);
	if (rcDir == 0)
	{
	info->bFailed = true;
	break;
	}

	int rc = WaitForMultipleObjects(2, handles, FALSE, INFINITE);
	if (rc == WAIT_OBJECT_0)
	{
	break;
	}
	if (rc == WAIT_OBJECT_0+1)
	{
	DWORD dwBytesReturned;
	if(!GetOverlappedResult(hRootDir, &overlapped, &dwBytesReturned, FALSE))
	{
	info->bFailed = true;
	break;
	}

	if (dwBytesReturned == 0)
	{
	// don't send dirty too much, everything is changed anyway
	if (WaitForSingleObject(info->hStopEvent, 500) == WAIT_OBJECT_0)
	break;

	// Got a buffer overflow => current changes lost => send RECDIRTY on root
	PrintEverythingChangedUnderRoot(rootPath);
	} else {
	FILE_NOTIFY_INFORMATION info = (FILE_NOTIFY_INFORMATION ) buffer;
	while(true)
	{
	PrintChangeInfo(rootPath, info);
	if (!info->NextEntryOffset)
	break;
	info = (FILE_NOTIFY_INFORMATION ) ((char ) info + info->NextEntryOffset);
	}
	}
	}
	}
	CloseHandle(overlapped.hEvent);
	CloseHandle(hRootDir);
	delete[] buffer;
	return 0;
	}

	// -- Roots update ------------------------------------------------------------

	void MarkAllRootsUnused()
	{
	for(int i=0; i<ROOT_COUNT; i++)
	{
	watchRootInfos [i].bUsed = false;
	}
	}

	void StartRoot(WatchRootInfo *info)
	{
	info->hStopEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
	info->hThread = CreateThread(NULL, 0, &WatcherThread, info, 0, NULL);
	info->bInitialized = true;
	}

	void StopRoot(WatchRootInfo *info)
	{
	SetEvent(info->hStopEvent);
	WaitForSingleObject(info->hThread, INFINITE);
	CloseHandle(info->hThread);
	CloseHandle(info->hStopEvent);
	info->bInitialized = false;
	}

	void UpdateRoots()
	{
	char infoBuffer [256];
	strcpy_s(infoBuffer, "UNWATCHEABLE\n");
	for(int i=0; i<ROOT_COUNT; i++)
	{
	if (watchRootInfos [i].bInitialized && (!watchRootInfos [i].bUsed \|\| watchRootInfos [i].bFailed))
	{
	StopRoot(&watchRootInfos [i]);
	watchRootInfos [i].bFailed = false;
	}
	if (watchRootInfos [i].bUsed)
	{
	char rootPath[8];
	sprintf_s(rootPath, 8, "%c:\\", watchRootInfos [i].driveLetter);
	if (!IsWatchable(rootPath))
	{
	strcat_s(infoBuffer, rootPath);
	strcat_s(infoBuffer, "\n");
	continue;
	}
	if (!watchRootInfos [i].bInitialized)
	{
	StartRoot(&watchRootInfos [i]);
	}
	}
	}
	EnterCriticalSection(&csOutput);
	fprintf(stdout, "%s", infoBuffer);
	puts("#\nREMAP");
	PrintRemapForSubstDrives();
	bool printedMountPoints = true;
	for(int i=0; i<ROOT_COUNT; i++)
	{
	if (watchRootInfos [i].bUsed)
	{
	char rootPath[8];
	sprintf_s(rootPath, 8, "%c:\\", watchRootInfos [i].driveLetter);
	if (!PrintMountPoints(rootPath))
	printedMountPoints = false;
	}
	}
	if (!printedMountPoints)
	{
	PrintWatchRootReparsePoints();
	}
	puts("#");
	fflush(stdout);
	LeaveCriticalSection(&csOutput);
	}

	void AddWatchRoot(const char *path)
	{
	WatchRoot watchRoot = (WatchRoot ) malloc(sizeof(WatchRoot));
	watchRoot->next = NULL;
	watchRoot->path = _strdup(path);
	watchRoot->next = firstWatchRoot;
	firstWatchRoot = watchRoot;
	}

	void FreeWatchRootsList()
	{
	WatchRoot *pWatchRoot = firstWatchRoot;
	WatchRoot *pNext;
	while(pWatchRoot)
	{
	pNext = pWatchRoot->next;
	free(pWatchRoot->path);
	free(pWatchRoot);
	pWatchRoot=pNext;
	}
	firstWatchRoot = NULL;
	}

	// -- Main - filewatcher protocol ---------------------------------------------

	int _tmain(int argc, _TCHAR* argv[])
	{
	InitializeCriticalSection(&csOutput);

	for(int i=0; i<26; i++)
	{
	watchRootInfos [i].driveLetter = 'A' + i;
	watchRootInfos [i].bInitialized = false;
	watchRootInfos [i].bUsed = false;
	}

	char buffer[8192];
	while(true)
	{
	if (!gets_s(buffer, sizeof(buffer)-1))
	break;

	if (!strcmp(buffer, "ROOTS"))
	{
	MarkAllRootsUnused();
	FreeWatchRootsList();
	bool failed = false;
	while(true)
	{
	if (!gets_s(buffer, sizeof(buffer)-1))
	{
	failed = true;
	break;
	}
	if (buffer [0] == '#')
	break;
	int driveLetterPos = 0;
	char *pDriveLetter = buffer;
	if (*pDriveLetter == '\|')
	pDriveLetter++;

	AddWatchRoot(pDriveLetter);

	_strupr_s(buffer, sizeof(buffer)-1);
	char driveLetter = *pDriveLetter;
	if (driveLetter >= 'A' && driveLetter <= 'Z')
	{
	watchRootInfos [driveLetter-'A'].bUsed = true;
	}
	}
	if (failed)
	break;

	UpdateRoots();
	}
	if (!strcmp(buffer, "EXIT"))
	break;
	}

	MarkAllRootsUnused();
	UpdateRoots();

	DeleteCriticalSection(&csOutput);
	}