You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
730 lines
20 KiB
730 lines
20 KiB
/*++
|
|
|
|
Copyright (c) 2000 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
EmulateCDFS.cpp
|
|
|
|
Abstract:
|
|
|
|
Removes read only attributes from CD directories: just like Win9x.
|
|
|
|
This shim has gone through several revisions. Originally it was thought
|
|
that win9x simply ignored the ReadOnly, DesiredAccess and ShareMode
|
|
parameters, but after some testing, it turns out that this is only true
|
|
for the CDRom drive.
|
|
|
|
Unfortunately we have to check every file to see if it's on the CD first,
|
|
just in case someone opens with exclusive access and then tries to open
|
|
again.
|
|
|
|
Notes:
|
|
|
|
This is a general purpose shim.
|
|
|
|
History:
|
|
|
|
01/03/2000 a-jamd Created
|
|
12/02/2000 linstev Separated into 2 shims: RemoveReadOnlyAttribute and this one
|
|
Added CreateFile hooks
|
|
02/14/2002 mnikkel Changed InitializeCriticalSection to InitializeCriticalSectionAndSpinCount
|
|
|
|
--*/
|
|
|
|
#include "precomp.h"
|
|
#include "CharVector.h"
|
|
|
|
IMPLEMENT_SHIM_BEGIN(EmulateCDFS)
|
|
#include "ShimHookMacro.h"
|
|
|
|
APIHOOK_ENUM_BEGIN
|
|
APIHOOK_ENUM_ENTRY(OpenFile)
|
|
APIHOOK_ENUM_ENTRY(CreateFileA)
|
|
APIHOOK_ENUM_ENTRY(CreateFileW)
|
|
APIHOOK_ENUM_ENTRY(CreateFileMappingA)
|
|
APIHOOK_ENUM_ENTRY(MapViewOfFile)
|
|
APIHOOK_ENUM_ENTRY(MapViewOfFileEx)
|
|
APIHOOK_ENUM_ENTRY(DuplicateHandle)
|
|
APIHOOK_ENUM_ENTRY(CloseHandle)
|
|
APIHOOK_ENUM_ENTRY(GetFileAttributesW)
|
|
APIHOOK_ENUM_ENTRY(GetFileAttributesA)
|
|
APIHOOK_ENUM_ENTRY(FindFirstFileW)
|
|
APIHOOK_ENUM_ENTRY(FindFirstFileA)
|
|
APIHOOK_ENUM_ENTRY(FindNextFileW)
|
|
APIHOOK_ENUM_ENTRY(FindNextFileA)
|
|
APIHOOK_ENUM_ENTRY(GetFileInformationByHandle)
|
|
APIHOOK_ENUM_ENTRY(GetDiskFreeSpaceA)
|
|
APIHOOK_ENUM_END
|
|
|
|
typedef struct _FINDFILE_HANDLE
|
|
{
|
|
HANDLE DirectoryHandle;
|
|
PVOID FindBufferBase;
|
|
PVOID FindBufferNext;
|
|
ULONG FindBufferLength;
|
|
ULONG FindBufferValidLength;
|
|
RTL_CRITICAL_SECTION FindBufferLock;
|
|
} FINDFILE_HANDLE, *PFINDFILE_HANDLE;
|
|
|
|
|
|
class RO_FileMappingList
|
|
{
|
|
private:
|
|
static VectorT<HANDLE> * g_phROHandles; // File mapping handles that we have forced to Read only
|
|
static RO_FileMappingList * g_RO_Handles;
|
|
static CRITICAL_SECTION critSec;
|
|
|
|
inline int GetIndex(HANDLE handle) const;
|
|
|
|
RO_FileMappingList();
|
|
~RO_FileMappingList();
|
|
|
|
public:
|
|
|
|
static void Add(HANDLE roHandle);
|
|
static void Remove(HANDLE roHandle);
|
|
static BOOL Exist(HANDLE handle);
|
|
static BOOL Initialize();
|
|
};
|
|
|
|
|
|
// A global list of file mapping handles that we have forced to readonly
|
|
RO_FileMappingList * RO_FileMappingList::g_RO_Handles = NULL;
|
|
VectorT<HANDLE> * RO_FileMappingList::g_phROHandles = NULL; // File mapping handles that we have forced to Read only
|
|
CRITICAL_SECTION RO_FileMappingList::critSec;
|
|
|
|
|
|
RO_FileMappingList::RO_FileMappingList()
|
|
{
|
|
}
|
|
|
|
RO_FileMappingList::~RO_FileMappingList()
|
|
{
|
|
DeleteCriticalSection(&critSec);
|
|
}
|
|
|
|
void RO_FileMappingList::Add(HANDLE roHandle)
|
|
{
|
|
if (roHandle != NULL)
|
|
{
|
|
EnterCriticalSection(&critSec);
|
|
int index = g_RO_Handles->GetIndex(roHandle);
|
|
if (index == -1) // not found
|
|
{
|
|
DPFN(eDbgLevelSpew, "[RO_FileMappingList::Add] Handle 0x%08x", roHandle);
|
|
g_phROHandles->Append(roHandle);
|
|
}
|
|
LeaveCriticalSection(&critSec);
|
|
}
|
|
}
|
|
|
|
void RO_FileMappingList::Remove(HANDLE roHandle)
|
|
{
|
|
if (roHandle != NULL)
|
|
{
|
|
EnterCriticalSection(&critSec);
|
|
int index = g_RO_Handles->GetIndex(roHandle);
|
|
if (index >= 0) // found it
|
|
{
|
|
DPFN(eDbgLevelSpew, "[RO_FileMappingList::Remove] Handle 0x%08x", roHandle);
|
|
g_phROHandles->Remove(index);
|
|
}
|
|
LeaveCriticalSection(&critSec);
|
|
}
|
|
}
|
|
|
|
inline int RO_FileMappingList::GetIndex(HANDLE handle) const
|
|
{
|
|
int index = g_phROHandles->Find(handle);
|
|
return index;
|
|
}
|
|
|
|
BOOL RO_FileMappingList::Exist(HANDLE handle)
|
|
{
|
|
EnterCriticalSection(&critSec);
|
|
BOOL bExist = g_RO_Handles->GetIndex(handle) >= 0;
|
|
LeaveCriticalSection(&critSec);
|
|
|
|
return bExist;
|
|
}
|
|
|
|
BOOL RO_FileMappingList::Initialize()
|
|
{
|
|
g_RO_Handles = new RO_FileMappingList;
|
|
g_phROHandles = new VectorT<HANDLE>;
|
|
|
|
if (g_RO_Handles && g_phROHandles)
|
|
{
|
|
return InitializeCriticalSectionAndSpinCount(&(g_RO_Handles->critSec),0x80000000);
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
/*++
|
|
|
|
Remove write attributes for read-only devices.
|
|
|
|
--*/
|
|
|
|
HFILE
|
|
APIHOOK(OpenFile)(
|
|
LPCSTR lpFileName, // file name
|
|
LPOFSTRUCT lpReOpenBuff, // file information
|
|
UINT uStyle // action and attributes
|
|
)
|
|
{
|
|
if ((uStyle & OF_READWRITE) && IsOnCDRomA(lpFileName))
|
|
{
|
|
// Remove the Read/Write bits
|
|
uStyle &= ~OF_READWRITE;
|
|
uStyle |= OF_READ;
|
|
|
|
LOGN(eDbgLevelInfo, "[OpenFile] \"%s\": attributes modified for read-only device", lpFileName);
|
|
}
|
|
|
|
HFILE returnValue = ORIGINAL_API(OpenFile)(lpFileName, lpReOpenBuff, uStyle);
|
|
|
|
return returnValue;
|
|
}
|
|
|
|
/*++
|
|
|
|
Remove write attributes for read-only devices.
|
|
|
|
--*/
|
|
|
|
HANDLE
|
|
APIHOOK(CreateFileA)(
|
|
LPSTR lpFileName,
|
|
DWORD dwDesiredAccess,
|
|
DWORD dwShareMode,
|
|
LPSECURITY_ATTRIBUTES lpSecurityAttributes,
|
|
DWORD dwCreationDisposition,
|
|
DWORD dwFlagsAndAttributes,
|
|
HANDLE hTemplateFile
|
|
)
|
|
{
|
|
if (((dwCreationDisposition == OPEN_EXISTING) ||
|
|
(dwCreationDisposition == OPEN_ALWAYS)) &&
|
|
((dwDesiredAccess & GENERIC_WRITE) ||
|
|
(dwShareMode != FILE_SHARE_READ)) &&
|
|
IsOnCDRomA(lpFileName))
|
|
{
|
|
dwDesiredAccess &= ~GENERIC_WRITE;
|
|
dwShareMode = FILE_SHARE_READ;
|
|
|
|
LOGN(eDbgLevelInfo, "[CreateFileA] \"%s\": attributes modified for read-only device", lpFileName);
|
|
}
|
|
|
|
if (dwFlagsAndAttributes & FILE_FLAG_NO_BUFFERING)
|
|
{
|
|
dwFlagsAndAttributes &= ~FILE_FLAG_NO_BUFFERING;
|
|
LOGN(eDbgLevelInfo, "[CreateFileA] \"%s\": removed NO_BUFFERING flag", lpFileName);
|
|
}
|
|
|
|
HANDLE hRet = ORIGINAL_API(CreateFileA)(
|
|
lpFileName,
|
|
dwDesiredAccess,
|
|
dwShareMode,
|
|
lpSecurityAttributes,
|
|
dwCreationDisposition,
|
|
dwFlagsAndAttributes,
|
|
hTemplateFile);
|
|
|
|
DPFN(eDbgLevelSpew,
|
|
"[CreateFileA] -File: \"%s\" -GENERIC_WRITE:%c -FILE_SHARE_WRITE:%c%s",
|
|
lpFileName,
|
|
(dwDesiredAccess & GENERIC_WRITE) ? 'Y' : 'N',
|
|
(dwShareMode & FILE_SHARE_WRITE) ? 'Y' : 'N',
|
|
(hRet == INVALID_HANDLE_VALUE) ? "\n\t***********Failed***********" : "");
|
|
|
|
return hRet;
|
|
}
|
|
|
|
/*++
|
|
|
|
Remove write attributes for read-only devices.
|
|
|
|
--*/
|
|
|
|
HANDLE
|
|
APIHOOK(CreateFileW)(
|
|
LPWSTR lpFileName,
|
|
DWORD dwDesiredAccess,
|
|
DWORD dwShareMode,
|
|
LPSECURITY_ATTRIBUTES lpSecurityAttributes,
|
|
DWORD dwCreationDisposition,
|
|
DWORD dwFlagsAndAttributes,
|
|
HANDLE hTemplateFile
|
|
)
|
|
{
|
|
if (((dwCreationDisposition == OPEN_EXISTING) ||
|
|
(dwCreationDisposition == OPEN_ALWAYS)) &&
|
|
((dwDesiredAccess & GENERIC_WRITE) ||
|
|
(dwShareMode != FILE_SHARE_READ)) &&
|
|
IsOnCDRomW(lpFileName))
|
|
{
|
|
dwDesiredAccess &= ~GENERIC_WRITE;
|
|
dwShareMode = FILE_SHARE_READ;
|
|
|
|
LOGN(eDbgLevelError, "[CreateFileW] \"%S\": attributes modified for read-only device", lpFileName);
|
|
}
|
|
|
|
if (dwFlagsAndAttributes & FILE_FLAG_NO_BUFFERING)
|
|
{
|
|
dwFlagsAndAttributes &= ~FILE_FLAG_NO_BUFFERING;
|
|
LOGN(eDbgLevelInfo, "[CreateFileW] \"%S\": removed NO_BUFFERING flag", lpFileName);
|
|
}
|
|
|
|
HANDLE hRet = ORIGINAL_API(CreateFileW)(
|
|
lpFileName,
|
|
dwDesiredAccess,
|
|
dwShareMode,
|
|
lpSecurityAttributes,
|
|
dwCreationDisposition,
|
|
dwFlagsAndAttributes,
|
|
hTemplateFile);
|
|
|
|
DPFN(eDbgLevelSpew,
|
|
"[CreateFileW] -File: \"%S\" -GENERIC_WRITE:%c -FILE_SHARE_WRITE:%c%s",
|
|
lpFileName,
|
|
(dwDesiredAccess & GENERIC_WRITE) ? 'Y' : 'N',
|
|
(dwShareMode & FILE_SHARE_WRITE) ? 'Y' : 'N',
|
|
(hRet == INVALID_HANDLE_VALUE) ? "\n\t***********Failed***********" : "");
|
|
|
|
return hRet;
|
|
}
|
|
|
|
HANDLE
|
|
APIHOOK(CreateFileMappingA)(
|
|
HANDLE hFile, // handle to file
|
|
LPSECURITY_ATTRIBUTES lpAttributes, // security
|
|
DWORD flProtect, // protection
|
|
DWORD dwMaximumSizeHigh, // high-order DWORD of size
|
|
DWORD dwMaximumSizeLow, // low-order DWORD of size
|
|
LPCSTR lpName // object name
|
|
)
|
|
{
|
|
BOOL bChangedProtect = FALSE;
|
|
if (!(flProtect & PAGE_READONLY) && IsOnCDRom(hFile))
|
|
{
|
|
// This handle is on a CD-ROM, force the protection to READONLY
|
|
flProtect = PAGE_READONLY;
|
|
bChangedProtect = TRUE;
|
|
|
|
LOGN(eDbgLevelError, "[CreateFileMappingA] Handle 0x%08x: attributes modified for read-only device", hFile);
|
|
}
|
|
|
|
HANDLE hRet = ORIGINAL_API(CreateFileMappingA)(
|
|
hFile,
|
|
lpAttributes,
|
|
flProtect,
|
|
dwMaximumSizeHigh,
|
|
dwMaximumSizeLow,
|
|
lpName);
|
|
|
|
// If the handle is on a CD-ROM, rember it
|
|
if (bChangedProtect)
|
|
{
|
|
RO_FileMappingList::Add(hRet);
|
|
}
|
|
|
|
DPFN(eDbgLevelSpew,
|
|
"[CreateFileMappingA] Handle 0x%08x -PAGE_READWRITE:%c -PAGE_WRITECOPY:%c%s",
|
|
lpName,
|
|
(flProtect & PAGE_READWRITE) ? 'Y' : 'N',
|
|
(flProtect & PAGE_WRITECOPY) ? 'Y' : 'N',
|
|
(hRet == INVALID_HANDLE_VALUE) ? "\n\t***********Failed***********" : "");
|
|
|
|
return hRet;
|
|
}
|
|
|
|
LPVOID
|
|
APIHOOK(MapViewOfFile)(
|
|
HANDLE hFileMappingObject, // handle to file-mapping object
|
|
DWORD dwDesiredAccess, // access mode
|
|
DWORD dwFileOffsetHigh, // high-order DWORD of offset
|
|
DWORD dwFileOffsetLow, // low-order DWORD of offset
|
|
SIZE_T dwNumberOfBytesToMap // number of bytes to map
|
|
)
|
|
{
|
|
//
|
|
// Check to see if we need to force Read access for CD-ROM files
|
|
// Only the FILE_MAP_READ bit may be enabled for CD-ROM access
|
|
//
|
|
if ((dwDesiredAccess != FILE_MAP_READ) &&
|
|
RO_FileMappingList::Exist(hFileMappingObject))
|
|
{
|
|
dwDesiredAccess = FILE_MAP_READ;
|
|
LOGN(eDbgLevelError, "[MapViewOfFile] Handle 0x%08x: attributes modified for read-only device", hFileMappingObject);
|
|
}
|
|
|
|
HANDLE hRet = ORIGINAL_API(MapViewOfFile)(
|
|
hFileMappingObject,
|
|
dwDesiredAccess,
|
|
dwFileOffsetHigh,
|
|
dwFileOffsetLow,
|
|
dwNumberOfBytesToMap);
|
|
|
|
return hRet;
|
|
}
|
|
|
|
LPVOID
|
|
APIHOOK(MapViewOfFileEx)(
|
|
HANDLE hFileMappingObject, // handle to file-mapping object
|
|
DWORD dwDesiredAccess, // access mode
|
|
DWORD dwFileOffsetHigh, // high-order DWORD of offset
|
|
DWORD dwFileOffsetLow, // low-order DWORD of offset
|
|
SIZE_T dwNumberOfBytesToMap, // number of bytes to map
|
|
LPVOID lpBaseAddress // starting addres
|
|
)
|
|
{
|
|
//
|
|
// Check to see if we need to force Read access for CD-ROM files
|
|
// Only the FILE_MAP_READ bit may be enabled for CD-ROM access
|
|
//
|
|
if ((dwDesiredAccess != FILE_MAP_READ) &&
|
|
RO_FileMappingList::Exist(hFileMappingObject))
|
|
{
|
|
dwDesiredAccess = FILE_MAP_READ;
|
|
LOGN(eDbgLevelError,
|
|
"[MapViewOfFile] Handle 0x%08x: attributes modified for read-only device", hFileMappingObject);
|
|
}
|
|
|
|
HANDLE hRet = ORIGINAL_API(MapViewOfFileEx)(
|
|
hFileMappingObject,
|
|
dwDesiredAccess,
|
|
dwFileOffsetHigh,
|
|
dwFileOffsetLow,
|
|
dwNumberOfBytesToMap,
|
|
lpBaseAddress);
|
|
|
|
return hRet;
|
|
}
|
|
|
|
/*++
|
|
|
|
If hSourceHandle has been mucked with, add the duplicated handle to our list
|
|
|
|
--*/
|
|
|
|
BOOL
|
|
APIHOOK(DuplicateHandle)(
|
|
HANDLE hSourceProcessHandle, // handle to source process
|
|
HANDLE hSourceHandle, // handle to duplicate
|
|
HANDLE hTargetProcessHandle, // handle to target process
|
|
LPHANDLE lpTargetHandle, // duplicate handle
|
|
DWORD dwDesiredAccess, // requested access
|
|
BOOL bInheritHandle, // handle inheritance option
|
|
DWORD dwOptions // optional actions
|
|
)
|
|
{
|
|
BOOL retval = ORIGINAL_API(DuplicateHandle)(
|
|
hSourceProcessHandle,
|
|
hSourceHandle,
|
|
hTargetProcessHandle,
|
|
lpTargetHandle,
|
|
dwDesiredAccess,
|
|
bInheritHandle,
|
|
dwOptions);
|
|
|
|
if (retval && RO_FileMappingList::Exist(hSourceHandle))
|
|
{
|
|
RO_FileMappingList::Add(hTargetProcessHandle);
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
/*++
|
|
|
|
If hObject has been mucked with, remove it from the list.
|
|
|
|
--*/
|
|
|
|
BOOL
|
|
APIHOOK(CloseHandle)(
|
|
HANDLE hObject // handle to object
|
|
)
|
|
{
|
|
RO_FileMappingList::Remove(hObject);
|
|
|
|
return ORIGINAL_API(CloseHandle)(hObject);
|
|
}
|
|
|
|
/*++
|
|
|
|
Remove read only attribute if it's a directory
|
|
|
|
--*/
|
|
|
|
DWORD
|
|
APIHOOK(GetFileAttributesA)(LPCSTR lpFileName)
|
|
{
|
|
DWORD dwFileAttributes = ORIGINAL_API(GetFileAttributesA)(lpFileName);
|
|
|
|
// Check for READONLY and DIRECTORY attributes
|
|
if ((dwFileAttributes != INT_PTR(-1)) &&
|
|
(dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
|
|
(dwFileAttributes & FILE_ATTRIBUTE_READONLY) &&
|
|
IsOnCDRomA(lpFileName))
|
|
{
|
|
// Flip the read-only bit.
|
|
LOGN(eDbgLevelWarning, "[GetFileAttributesA] Removing FILE_ATTRIBUTE_READONLY");
|
|
dwFileAttributes ^= FILE_ATTRIBUTE_READONLY;
|
|
}
|
|
|
|
return dwFileAttributes;
|
|
}
|
|
|
|
/*++
|
|
|
|
Remove read only attribute if it's a directory
|
|
|
|
--*/
|
|
|
|
DWORD
|
|
APIHOOK(GetFileAttributesW)(LPCWSTR wcsFileName)
|
|
{
|
|
DWORD dwFileAttributes = ORIGINAL_API(GetFileAttributesW)(wcsFileName);
|
|
|
|
// Check for READONLY and DIRECTORY attributes
|
|
if ((dwFileAttributes != INT_PTR(-1)) &&
|
|
(dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
|
|
(dwFileAttributes & FILE_ATTRIBUTE_READONLY) &&
|
|
IsOnCDRomW(wcsFileName))
|
|
{
|
|
// Flip the read-only bit.
|
|
LOGN(eDbgLevelWarning, "[GetFileAttributesW] Removing FILE_ATTRIBUTE_READONLY");
|
|
dwFileAttributes ^= FILE_ATTRIBUTE_READONLY;
|
|
}
|
|
|
|
return dwFileAttributes;
|
|
}
|
|
|
|
/*++
|
|
|
|
Remove read only attribute if it's a directory
|
|
|
|
--*/
|
|
|
|
HANDLE
|
|
APIHOOK(FindFirstFileA)(
|
|
LPCSTR lpFileName,
|
|
LPWIN32_FIND_DATAA lpFindFileData
|
|
)
|
|
{
|
|
HANDLE hFindFile = ORIGINAL_API(FindFirstFileA)(lpFileName, lpFindFileData);
|
|
|
|
if ((hFindFile != INVALID_HANDLE_VALUE) &&
|
|
(lpFindFileData->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
|
|
(lpFindFileData->dwFileAttributes & FILE_ATTRIBUTE_READONLY) &&
|
|
IsOnCDRom(((PFINDFILE_HANDLE) hFindFile)->DirectoryHandle))
|
|
{
|
|
// Flip the read-only bit
|
|
LOGN(eDbgLevelWarning, "[FindFirstFileA] Removing FILE_ATTRIBUTE_READONLY");
|
|
lpFindFileData->dwFileAttributes ^= FILE_ATTRIBUTE_READONLY;
|
|
}
|
|
|
|
return hFindFile;
|
|
}
|
|
|
|
/*++
|
|
|
|
Remove read only attribute if it's a directory.
|
|
|
|
--*/
|
|
|
|
HANDLE
|
|
APIHOOK(FindFirstFileW)(
|
|
LPCWSTR wcsFileName,
|
|
LPWIN32_FIND_DATAW lpFindFileData
|
|
)
|
|
{
|
|
HANDLE hFindFile = ORIGINAL_API(FindFirstFileW)(wcsFileName, lpFindFileData);
|
|
|
|
if ((hFindFile != INVALID_HANDLE_VALUE) &&
|
|
(lpFindFileData->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
|
|
(lpFindFileData->dwFileAttributes & FILE_ATTRIBUTE_READONLY) &&
|
|
IsOnCDRom(((PFINDFILE_HANDLE) hFindFile)->DirectoryHandle))
|
|
{
|
|
// It's a directory: flip the read-only bit
|
|
LOGN(eDbgLevelInfo, "[FindFirstFileW] Removing FILE_ATTRIBUTE_READONLY");
|
|
lpFindFileData->dwFileAttributes ^= FILE_ATTRIBUTE_READONLY;
|
|
}
|
|
|
|
return hFindFile;
|
|
}
|
|
|
|
/*++
|
|
|
|
Remove read only attribute if it's a directory.
|
|
|
|
--*/
|
|
|
|
BOOL
|
|
APIHOOK(FindNextFileA)(
|
|
HANDLE hFindFile,
|
|
LPWIN32_FIND_DATAA lpFindFileData
|
|
)
|
|
{
|
|
BOOL bRet = ORIGINAL_API(FindNextFileA)(hFindFile, lpFindFileData);
|
|
|
|
if (bRet &&
|
|
(lpFindFileData->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
|
|
(lpFindFileData->dwFileAttributes & FILE_ATTRIBUTE_READONLY) &&
|
|
IsOnCDRom(((PFINDFILE_HANDLE) hFindFile)->DirectoryHandle))
|
|
{
|
|
// Flip the read-only bit.
|
|
LOGN(eDbgLevelWarning, "[FindNextFileA] Removing FILE_ATTRIBUTE_READONLY");
|
|
lpFindFileData->dwFileAttributes ^= FILE_ATTRIBUTE_READONLY;
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
/*++
|
|
|
|
Remove read only attribute if it's a directory.
|
|
|
|
--*/
|
|
|
|
BOOL
|
|
APIHOOK(FindNextFileW)(
|
|
HANDLE hFindFile,
|
|
LPWIN32_FIND_DATAW lpFindFileData
|
|
)
|
|
{
|
|
BOOL bRet = ORIGINAL_API(FindNextFileW)(hFindFile, lpFindFileData);
|
|
|
|
if (bRet &&
|
|
(lpFindFileData->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
|
|
(lpFindFileData->dwFileAttributes & FILE_ATTRIBUTE_READONLY) &&
|
|
IsOnCDRom(((PFINDFILE_HANDLE) hFindFile)->DirectoryHandle))
|
|
{
|
|
// Flip the read-only bit
|
|
LOGN(eDbgLevelWarning, "[FindNextFileW] Removing FILE_ATTRIBUTE_READONLY");
|
|
lpFindFileData->dwFileAttributes ^= FILE_ATTRIBUTE_READONLY;
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
/*++
|
|
|
|
Remove read only attribute if it's a directory.
|
|
|
|
--*/
|
|
|
|
BOOL
|
|
APIHOOK(GetFileInformationByHandle)(
|
|
HANDLE hFile,
|
|
LPBY_HANDLE_FILE_INFORMATION lpFileInformation
|
|
)
|
|
{
|
|
BOOL bRet = ORIGINAL_API(GetFileInformationByHandle)(hFile, lpFileInformation);
|
|
|
|
if (bRet &&
|
|
(lpFileInformation->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
|
|
(lpFileInformation->dwFileAttributes & FILE_ATTRIBUTE_READONLY) &&
|
|
IsOnCDRom(hFile))
|
|
{
|
|
// It's a CDROM: flip the read-only bit.
|
|
LOGN(eDbgLevelWarning, "[GetFileInformationByHandle] Removing FILE_ATTRIBUTE_READONLY");
|
|
lpFileInformation->dwFileAttributes ^= FILE_ATTRIBUTE_READONLY;
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
/*++
|
|
|
|
If the disk is a CDROM, return the same wrong numbers as Win9x
|
|
|
|
--*/
|
|
|
|
BOOL
|
|
APIHOOK(GetDiskFreeSpaceA)(
|
|
LPCSTR lpRootPathName,
|
|
LPDWORD lpSectorsPerCluster,
|
|
LPDWORD lpBytesPerSector,
|
|
LPDWORD lpNumberOfFreeClusters,
|
|
LPDWORD lpTotalNumberOfClusters
|
|
)
|
|
{
|
|
if (IsOnCDRomA(lpRootPathName))
|
|
{
|
|
// Hard code values to match Win9x (wrong) description of CDROM
|
|
*lpSectorsPerCluster = 0x10;
|
|
*lpBytesPerSector = 0x800;
|
|
*lpNumberOfFreeClusters = 0;
|
|
*lpTotalNumberOfClusters = 0x2b7;
|
|
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
// Call the original API
|
|
BOOL lRet = ORIGINAL_API(GetDiskFreeSpaceA)(
|
|
lpRootPathName,
|
|
lpSectorsPerCluster,
|
|
lpBytesPerSector,
|
|
lpNumberOfFreeClusters,
|
|
lpTotalNumberOfClusters);
|
|
|
|
return lRet;
|
|
}
|
|
}
|
|
|
|
/*++
|
|
|
|
Initialize all the registry hooks
|
|
|
|
--*/
|
|
|
|
BOOL
|
|
NOTIFY_FUNCTION(
|
|
DWORD fdwReason
|
|
)
|
|
{
|
|
if (fdwReason == DLL_PROCESS_ATTACH)
|
|
{
|
|
// This forces the allocation of the array:
|
|
return RO_FileMappingList::Initialize();
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*++
|
|
|
|
Register hooked functions
|
|
|
|
--*/
|
|
|
|
HOOK_BEGIN
|
|
|
|
CALL_NOTIFY_FUNCTION
|
|
|
|
APIHOOK_ENTRY(KERNEL32.DLL, OpenFile)
|
|
APIHOOK_ENTRY(KERNEL32.DLL, CreateFileA)
|
|
APIHOOK_ENTRY(KERNEL32.DLL, CreateFileW)
|
|
APIHOOK_ENTRY(KERNEL32.DLL, CreateFileMappingA)
|
|
APIHOOK_ENTRY(KERNEL32.DLL, MapViewOfFile)
|
|
APIHOOK_ENTRY(KERNEL32.DLL, MapViewOfFileEx)
|
|
APIHOOK_ENTRY(KERNEL32.DLL, DuplicateHandle)
|
|
APIHOOK_ENTRY(KERNEL32.DLL, CloseHandle)
|
|
APIHOOK_ENTRY(KERNEL32.DLL, GetFileAttributesA)
|
|
APIHOOK_ENTRY(KERNEL32.DLL, GetFileAttributesW)
|
|
APIHOOK_ENTRY(KERNEL32.DLL, FindFirstFileA)
|
|
APIHOOK_ENTRY(KERNEL32.DLL, FindFirstFileW)
|
|
APIHOOK_ENTRY(KERNEL32.DLL, FindNextFileA)
|
|
APIHOOK_ENTRY(KERNEL32.DLL, FindNextFileW)
|
|
APIHOOK_ENTRY(KERNEL32.DLL, GetFileInformationByHandle)
|
|
APIHOOK_ENTRY(KERNEL32.DLL, GetDiskFreeSpaceA)
|
|
|
|
HOOK_END
|
|
|
|
IMPLEMENT_SHIM_END
|
|
|