mirror of https://github.com/tongzx/nt5src
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.
1768 lines
36 KiB
1768 lines
36 KiB
/*++
|
|
|
|
Copyright (c) 2000-2001 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
Common.cpp
|
|
|
|
Abstract:
|
|
|
|
Common functions for all modules
|
|
|
|
Notes:
|
|
|
|
None
|
|
|
|
History:
|
|
|
|
12/15/1999 linstev Created
|
|
01/10/2000 linstev Format to new style
|
|
03/14/2000 robkenny Added StringWiden and StringNWiden,
|
|
StringSubstituteRoutine[A|W] was not using the proper compare routine
|
|
when calling recursively.
|
|
07/06/2000 t-adams Added IsImage16Bit
|
|
10/18/2000 a-larrsh Move PatternMatch to common removing redundent code in shims.
|
|
10/25/2000 linstev Cleaned up
|
|
08/14/2001 robkenny Moved code inside the ShimLib namespace.
|
|
09/11/2001 mnikkel Modified DebugPrintfList, DebugPrintf, ShimLogList and ShimLog to retain LastError
|
|
09/25/2001 rparsons Modified logging code to use NT calls. Added critical section.
|
|
10/18/2001 rparsons Removed critical section, added mutex for logging.
|
|
|
|
--*/
|
|
|
|
#include "ShimHook.h"
|
|
#include "ShimLib.h"
|
|
#include "ShimHookMacro.h"
|
|
#include <stdio.h>
|
|
|
|
|
|
|
|
namespace ShimLib
|
|
{
|
|
|
|
BOOL g_bFileLogEnabled = FALSE; // enable/disable file logging
|
|
WCHAR g_wszFileLog[MAX_PATH]; // name of the log file
|
|
HANDLE g_hMemoryHeap = INVALID_HANDLE_VALUE;
|
|
BOOL g_bDebugLevelInitialized = FALSE;
|
|
DEBUGLEVEL g_DebugLevel = eDbgLevelBase;
|
|
|
|
inline HANDLE GetHeap()
|
|
{
|
|
if (g_hMemoryHeap == INVALID_HANDLE_VALUE)
|
|
{
|
|
g_hMemoryHeap = HeapCreate(0, 0, 0);
|
|
}
|
|
|
|
return g_hMemoryHeap;
|
|
}
|
|
|
|
void * __cdecl ShimMalloc(size_t size)
|
|
{
|
|
HANDLE heap = GetHeap();
|
|
|
|
void* memory = HeapAlloc(heap, HEAP_ZERO_MEMORY, size);
|
|
|
|
return memory;
|
|
}
|
|
|
|
void __cdecl ShimFree(void * memory)
|
|
{
|
|
HANDLE heap = GetHeap();
|
|
HeapFree(heap, 0, memory);
|
|
}
|
|
|
|
void * __cdecl ShimCalloc( size_t num, size_t size )
|
|
{
|
|
size_t nBytes = size * num;
|
|
void * callocMemory = ShimMalloc(nBytes);
|
|
ZeroMemory(callocMemory, nBytes);
|
|
|
|
return callocMemory;
|
|
}
|
|
|
|
void * __cdecl ShimRealloc(void * memory, size_t size)
|
|
{
|
|
if (memory == NULL)
|
|
return ShimMalloc(size);
|
|
|
|
HANDLE heap = GetHeap();
|
|
void * reallocMemory = HeapReAlloc(heap, 0, memory, size);
|
|
|
|
return reallocMemory;
|
|
}
|
|
|
|
|
|
DEBUGLEVEL GetDebugLevel()
|
|
{
|
|
CHAR cEnv[MAX_PATH];
|
|
|
|
if (g_bDebugLevelInitialized) {
|
|
return g_DebugLevel;
|
|
}
|
|
|
|
g_DebugLevel = eDbgLevelBase;
|
|
|
|
if (GetEnvironmentVariableA(
|
|
szDebugEnvironmentVariable,
|
|
cEnv,
|
|
MAX_PATH)) {
|
|
|
|
CHAR c = cEnv[0];
|
|
|
|
if ((c >= '0') || (c <= '9')) {
|
|
g_DebugLevel = (DEBUGLEVEL)((int)(c - '0'));
|
|
}
|
|
}
|
|
|
|
g_bDebugLevelInitialized = TRUE;
|
|
|
|
return g_DebugLevel;
|
|
}
|
|
|
|
/*++
|
|
|
|
Function Description:
|
|
|
|
Assert that prints file and line number.
|
|
|
|
Arguments:
|
|
|
|
IN dwDetail - Detail level above which no print will occur
|
|
IN pszFmt - Format string
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
History:
|
|
|
|
11/01/1999 markder Created
|
|
|
|
--*/
|
|
|
|
#if DBG
|
|
VOID
|
|
DebugAssert(
|
|
LPCSTR szFile,
|
|
DWORD dwLine,
|
|
BOOL bAssert,
|
|
LPCSTR szHelpString
|
|
)
|
|
{
|
|
if (!bAssert )
|
|
{
|
|
DPF("ShimLib", eDbgLevelError, "\n");
|
|
DPF("ShimLib", eDbgLevelError, "ASSERT: %s\n", szHelpString);
|
|
DPF("ShimLib", eDbgLevelError, "FILE: %s\n", szFile);
|
|
DPF("ShimLib", eDbgLevelError, "LINE: %d\n", dwLine);
|
|
DPF("ShimLib", eDbgLevelError, "\n");
|
|
|
|
DebugBreak();
|
|
}
|
|
}
|
|
|
|
/*++
|
|
|
|
Function Description:
|
|
|
|
Print a formatted string using DebugOutputString.
|
|
|
|
Arguments:
|
|
|
|
IN dwDetail - Detail level above which no print will occur
|
|
IN pszFmt - Format string
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
History:
|
|
|
|
11/01/1999 markder Created
|
|
|
|
--*/
|
|
|
|
|
|
VOID
|
|
DebugPrintfList(
|
|
LPCSTR szShimName,
|
|
DEBUGLEVEL dwDetail,
|
|
LPCSTR pszFmt,
|
|
va_list vaArgList
|
|
)
|
|
{
|
|
// This must be the first line of this routine to preserve LastError.
|
|
DWORD dwLastError = GetLastError();
|
|
|
|
extern DEBUGLEVEL GetDebugLevel();
|
|
|
|
char szT[1024];
|
|
|
|
szT[1022] = '\0';
|
|
_vsnprintf(szT, 1022, pszFmt, vaArgList);
|
|
|
|
// make sure we have a '\n' at the end of the string
|
|
|
|
int len = lstrlen(szT);
|
|
|
|
if (szT[len-1] != '\n')
|
|
{
|
|
lstrcpy(&szT[len], "\n");
|
|
}
|
|
|
|
|
|
if (dwDetail <= GetDebugLevel())
|
|
{
|
|
switch (dwDetail)
|
|
{
|
|
case eDbgLevelError:
|
|
OutputDebugStringA ("[FAIL] ");
|
|
break;
|
|
case eDbgLevelWarning:
|
|
OutputDebugStringA ("[WARN] ");
|
|
break;
|
|
case eDbgLevelInfo:
|
|
OutputDebugStringA ("[INFO] ");
|
|
break;
|
|
}
|
|
|
|
OutputDebugStringA(szShimName);
|
|
|
|
OutputDebugStringA(" - ");
|
|
|
|
OutputDebugStringA(szT);
|
|
}
|
|
|
|
// This must be the last line of this routine to preserve LastError.
|
|
SetLastError(dwLastError);
|
|
}
|
|
|
|
VOID
|
|
DebugPrintf(
|
|
LPCSTR szShimName,
|
|
DEBUGLEVEL dwDetail,
|
|
LPCSTR pszFmt,
|
|
...
|
|
)
|
|
{
|
|
// This must be the first line of this routine to preserve LastError.
|
|
DWORD dwLastError = GetLastError();
|
|
|
|
va_list vaArgList;
|
|
va_start(vaArgList, pszFmt);
|
|
|
|
DebugPrintfList(szShimName, dwDetail, pszFmt, vaArgList);
|
|
|
|
va_end(vaArgList);
|
|
|
|
// This must be the last line of this routine to preserve LastError.
|
|
SetLastError(dwLastError); }
|
|
|
|
#endif // DBG
|
|
|
|
/*++
|
|
|
|
Function Description:
|
|
|
|
Prints a log in the log file if logging is enabled
|
|
|
|
Arguments:
|
|
|
|
IN pszFmt - Format string
|
|
|
|
Return Value:
|
|
|
|
none
|
|
|
|
History:
|
|
|
|
03/03/2000 clupu Created
|
|
|
|
--*/
|
|
|
|
#define MAX_LOG_LENGTH 1024
|
|
|
|
char g_szLog[MAX_LOG_LENGTH];
|
|
|
|
|
|
/*++
|
|
|
|
Function Description:
|
|
|
|
Prints a log in the log file if logging is enabled
|
|
|
|
Arguments:
|
|
|
|
IN wszShimName - Name of shim that string originates from
|
|
IN dwDetail - Detail level above which no print will occur
|
|
IN pszFmt - Format string
|
|
|
|
Return Value:
|
|
|
|
none
|
|
|
|
History:
|
|
|
|
03/03/2000 clupu Created
|
|
09/25/2001 rparsons Converted to NT calls
|
|
|
|
--*/
|
|
|
|
void
|
|
ShimLogList(
|
|
LPCSTR szShimName,
|
|
DEBUGLEVEL dwDbgLevel,
|
|
LPCSTR pszFmt,
|
|
va_list arglist
|
|
)
|
|
{
|
|
//
|
|
// This must be the first line of this routine to preserve LastError.
|
|
//
|
|
DWORD dwLastError = GetLastError();
|
|
|
|
int nLen = 0;
|
|
NTSTATUS status;
|
|
SYSTEMTIME lt;
|
|
|
|
|
|
UNICODE_STRING strLogFile = {0};
|
|
OBJECT_ATTRIBUTES ObjectAttributes;
|
|
IO_STATUS_BLOCK IoStatusBlock;
|
|
LARGE_INTEGER liOffset;
|
|
char szNewLine[] = "\r\n";
|
|
DWORD dwWaitResult;
|
|
HANDLE hFile = INVALID_HANDLE_VALUE;
|
|
HANDLE hLogMutex;
|
|
|
|
//
|
|
// Convert the path to the log file from DOS to NT.
|
|
//
|
|
RtlInitUnicodeString(&strLogFile, g_wszFileLog);
|
|
|
|
status = RtlDosPathNameToNtPathName_U(strLogFile.Buffer, &strLogFile, NULL, NULL);
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
DPF("ShimLib", eDbgLevelError,
|
|
"[ShimLogList] 0x%X Failed to convert log file '%ls' to NT path",
|
|
status, g_wszFileLog);
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Attempt to get a handle to our log file.
|
|
//
|
|
InitializeObjectAttributes(&ObjectAttributes,
|
|
&strLogFile,
|
|
OBJ_CASE_INSENSITIVE,
|
|
NULL,
|
|
NULL);
|
|
|
|
status = NtCreateFile(&hFile,
|
|
FILE_APPEND_DATA | SYNCHRONIZE,
|
|
&ObjectAttributes,
|
|
&IoStatusBlock,
|
|
NULL,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
0,
|
|
FILE_OPEN,
|
|
FILE_NON_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT,
|
|
NULL,
|
|
0);
|
|
|
|
RtlFreeUnicodeString(&strLogFile);
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
DPF("ShimLib", eDbgLevelError, "[ShimLogList] 0x%X Failed to open log file %ls",
|
|
status, g_wszFileLog);
|
|
return;
|
|
}
|
|
|
|
SetFilePointer(hFile, 0, NULL, FILE_END);
|
|
|
|
//
|
|
// Print a header consisting of data, time, app name, and shim name.
|
|
//
|
|
GetLocalTime(<);
|
|
|
|
sprintf(g_szLog, "%02d/%02d/%04d %02d:%02d:%02d %s %d - ",
|
|
lt.wMonth, lt.wDay, lt.wYear,
|
|
lt.wHour, lt.wMinute, lt.wSecond,
|
|
szShimName,
|
|
dwDbgLevel);
|
|
|
|
nLen = lstrlen(g_szLog);
|
|
|
|
//
|
|
// Write the header out to the file.
|
|
//
|
|
IoStatusBlock.Status = 0;
|
|
IoStatusBlock.Information = 0;
|
|
|
|
liOffset.LowPart = 0;
|
|
liOffset.HighPart = 0;
|
|
|
|
//
|
|
// Get a handle to the mutex and attempt to get ownership.
|
|
//
|
|
hLogMutex = OpenMutex(MUTEX_ALL_ACCESS, FALSE, "SHIMLIB_LOG_MUTEX");
|
|
|
|
if (!hLogMutex) {
|
|
DPF("ShimLib", eDbgLevelError, "[ShimLogList] %lu Failed to open logging mutex", GetLastError());
|
|
goto exit;
|
|
}
|
|
|
|
dwWaitResult = WaitForSingleObject(hLogMutex, 500);
|
|
|
|
if (WAIT_OBJECT_0 == dwWaitResult) {
|
|
//
|
|
// Write the header to the log file.
|
|
//
|
|
status = NtWriteFile(hFile,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
&IoStatusBlock,
|
|
(PVOID)g_szLog,
|
|
(ULONG)nLen,
|
|
&liOffset,
|
|
NULL);
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
DPF("ShimLib", eDbgLevelError, "[ShimLogList] 0x%X Failed to write header to log file",
|
|
status);
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// Format our string using the specifiers passed.
|
|
//
|
|
_vsnprintf(g_szLog, MAX_LOG_LENGTH - 1, pszFmt, arglist);
|
|
g_szLog[MAX_LOG_LENGTH - 1] = 0;
|
|
|
|
//
|
|
// Write the actual data out to the file.
|
|
//
|
|
IoStatusBlock.Status = 0;
|
|
IoStatusBlock.Information = 0;
|
|
|
|
liOffset.LowPart = 0;
|
|
liOffset.HighPart = 0;
|
|
|
|
nLen = lstrlen(g_szLog);
|
|
|
|
status = NtWriteFile(hFile,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
&IoStatusBlock,
|
|
(PVOID)g_szLog,
|
|
(ULONG)nLen,
|
|
&liOffset,
|
|
NULL);
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
DPF("ShimLib", eDbgLevelError, "[ShimLogList] 0x%X Failed to make entry in log file",
|
|
status);
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// Now write a new line to the log file.
|
|
//
|
|
IoStatusBlock.Status = 0;
|
|
IoStatusBlock.Information = 0;
|
|
|
|
liOffset.LowPart = 0;
|
|
liOffset.HighPart = 0;
|
|
|
|
nLen = lstrlen(szNewLine);
|
|
|
|
status = NtWriteFile(hFile,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
&IoStatusBlock,
|
|
(PVOID)szNewLine,
|
|
(ULONG)nLen,
|
|
&liOffset,
|
|
NULL);
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
DPF("ShimLib", eDbgLevelError, "[ShimLogList] 0x%X Failed to write new line to log file",
|
|
status);
|
|
goto exit;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Dump it out to the debugger on checked builds.
|
|
//
|
|
#if DBG
|
|
DebugPrintf(szShimName, dwDbgLevel, g_szLog);
|
|
DebugPrintf(szShimName, dwDbgLevel, "\n");
|
|
#endif // DBG
|
|
|
|
exit:
|
|
|
|
if (INVALID_HANDLE_VALUE != hFile) {
|
|
NtClose(hFile);
|
|
hFile = INVALID_HANDLE_VALUE;
|
|
}
|
|
|
|
if (hLogMutex) {
|
|
ReleaseMutex(hLogMutex);
|
|
}
|
|
|
|
//
|
|
// This must be the last line of this routine to preserve LastError.
|
|
//
|
|
SetLastError(dwLastError);
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Function Description:
|
|
|
|
Initializes the support for file logging.
|
|
|
|
Arguments:
|
|
|
|
IN pszShim - the name of the shim DLL
|
|
|
|
Return Value:
|
|
|
|
TRUE if successful, FALSE if failed
|
|
|
|
History:
|
|
|
|
03/03/2000 clupu Created
|
|
|
|
--*/
|
|
|
|
BOOL
|
|
InitFileLogSupport(
|
|
char *pszShim
|
|
)
|
|
{
|
|
BOOL fReturn = FALSE;
|
|
WCHAR wszAppPatch[MAX_PATH];
|
|
WCHAR* pwsz = NULL;
|
|
HANDLE hFile = INVALID_HANDLE_VALUE;
|
|
HANDLE hLogMutex = NULL;
|
|
DWORD dwLen = 0;
|
|
NTSTATUS status;
|
|
UNICODE_STRING strLogFile = {0};
|
|
OBJECT_ATTRIBUTES ObjectAttributes;
|
|
IO_STATUS_BLOCK IoStatusBlock;
|
|
|
|
//
|
|
// Attempt to create a mutex. If the mutex already exists,
|
|
// we don't need to go any further as the log file has
|
|
// already been created.
|
|
//
|
|
hLogMutex = CreateMutex(NULL, TRUE, "SHIMLIB_LOG_MUTEX");
|
|
|
|
if (!hLogMutex) {
|
|
DPF("ShimLib", eDbgLevelError, "[InitFileLogSupport] Failed to create logging mutex");
|
|
return FALSE;
|
|
}
|
|
|
|
DWORD dwLastError = GetLastError();
|
|
|
|
if (ERROR_ALREADY_EXISTS == dwLastError) {
|
|
fReturn = TRUE;
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// We'll create the log file in %windir%\AppPatch.
|
|
//
|
|
if (!GetSystemWindowsDirectoryW(g_wszFileLog, MAX_PATH)) {
|
|
DPF("ShimLib", eDbgLevelError, "[InitFileLogSupport] Failed to get windir path");
|
|
goto exit;
|
|
}
|
|
|
|
lstrcatW(g_wszFileLog, L"\\AppPatch\\");
|
|
|
|
dwLen = lstrlenW(g_wszFileLog);
|
|
pwsz = g_wszFileLog + dwLen;
|
|
|
|
//
|
|
// Query the environment variable and get the name of our log file.
|
|
//
|
|
if (!GetEnvironmentVariableW(wszFileLogEnvironmentVariable,
|
|
pwsz,
|
|
(MAX_PATH - dwLen) * sizeof(WCHAR))) {
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// Convert the path to the log file from DOS to NT.
|
|
//
|
|
RtlInitUnicodeString(&strLogFile, g_wszFileLog);
|
|
|
|
status = RtlDosPathNameToNtPathName_U(strLogFile.Buffer, &strLogFile, NULL, NULL);
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
DPF("ShimLib", eDbgLevelError,
|
|
"[InitFileLogSupport] 0x%X Failed to convert log file '%ls' to NT path",
|
|
status, g_wszFileLog);
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// Attempt to create the log file. If it exists, the contents will be cleared.
|
|
//
|
|
InitializeObjectAttributes(&ObjectAttributes,
|
|
&strLogFile,
|
|
OBJ_CASE_INSENSITIVE,
|
|
NULL,
|
|
NULL);
|
|
|
|
status = NtCreateFile(&hFile,
|
|
GENERIC_WRITE | SYNCHRONIZE,
|
|
&ObjectAttributes,
|
|
&IoStatusBlock,
|
|
NULL,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
0,
|
|
FILE_OPEN_IF,
|
|
FILE_NON_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT,
|
|
NULL,
|
|
0);
|
|
|
|
RtlFreeUnicodeString(&strLogFile);
|
|
|
|
if (!NT_SUCCESS(status)) {
|
|
DPF("ShimLib", eDbgLevelError, "[InitFileLogSupport] 0x%X Failed to open log file %ls",
|
|
status, g_wszFileLog);
|
|
goto exit;
|
|
}
|
|
|
|
NtClose(hFile);
|
|
|
|
//
|
|
// Turn on the flag that tells everyone that logging is enabled.
|
|
// Release the mutex so that others can use it.
|
|
//
|
|
g_bFileLogEnabled = TRUE;
|
|
|
|
|
|
fReturn = TRUE;
|
|
|
|
exit:
|
|
|
|
ReleaseMutex(hLogMutex);
|
|
|
|
return fReturn;
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Function Description:
|
|
|
|
Determine the drive type a file resides on.
|
|
|
|
Arguments:
|
|
|
|
IN lpFileName - Filename or relative filename
|
|
|
|
Return Value:
|
|
|
|
See GetDriveType in MSDN
|
|
|
|
History:
|
|
|
|
10/25/2000 linstev Created
|
|
|
|
--*/
|
|
|
|
UINT
|
|
GetDriveTypeFromFileNameA(LPCSTR lpFileName, char *lpDriveLetter)
|
|
{
|
|
WCHAR * lpwszFileName = ToUnicode(lpFileName);
|
|
if (lpwszFileName)
|
|
{
|
|
WCHAR szDrive;
|
|
UINT uType = GetDriveTypeFromFileNameW(lpwszFileName, &szDrive);
|
|
|
|
if (lpDriveLetter)
|
|
{
|
|
*lpDriveLetter = (char) szDrive;
|
|
}
|
|
|
|
free(lpwszFileName);
|
|
|
|
return uType;
|
|
}
|
|
else
|
|
{
|
|
return DRIVE_UNKNOWN;
|
|
}
|
|
}
|
|
|
|
/*++
|
|
|
|
Function Description:
|
|
|
|
Determine the drive type a file resides on.
|
|
|
|
Arguments:
|
|
|
|
IN lpFileName - Filename or relative filename
|
|
|
|
Return Value:
|
|
|
|
See GetDriveType in MSDN
|
|
|
|
History:
|
|
|
|
10/25/2000 linstev Created
|
|
|
|
--*/
|
|
|
|
UINT
|
|
GetDriveTypeFromFileNameW(LPCWSTR lpFileName, WCHAR *lpDriveLetter)
|
|
{
|
|
if (lpFileName && (lpFileName[0] == L'\\') && (lpFileName[1] == L'\\'))
|
|
{
|
|
// UNC naming - always network
|
|
if (lpDriveLetter)
|
|
{
|
|
*lpDriveLetter = L'\0';
|
|
}
|
|
return DRIVE_REMOTE;
|
|
}
|
|
|
|
WCHAR cDrive;
|
|
|
|
if (lpFileName && lpFileName[0] && (lpFileName[1] == L':'))
|
|
{
|
|
// Format is Drive:Path\File, so just take the drive
|
|
cDrive = lpFileName[0];
|
|
}
|
|
else
|
|
{
|
|
// Must be a relative path
|
|
cDrive = 0;
|
|
|
|
WCHAR *wzCurDir = NULL;
|
|
DWORD dwCurDirSize = GetCurrentDirectoryW(0, wzCurDir);
|
|
|
|
if (!dwCurDirSize)
|
|
{
|
|
goto EXIT;
|
|
}
|
|
|
|
wzCurDir = (LPWSTR) LocalAlloc(LPTR, dwCurDirSize * sizeof(WCHAR));
|
|
if (!wzCurDir)
|
|
{
|
|
goto EXIT;
|
|
}
|
|
|
|
dwCurDirSize = GetCurrentDirectoryW(dwCurDirSize, wzCurDir);
|
|
if (!dwCurDirSize || wzCurDir[0] == L'\\')
|
|
{
|
|
goto EXIT;
|
|
}
|
|
|
|
cDrive = wzCurDir[0];
|
|
|
|
EXIT:
|
|
if (wzCurDir)
|
|
{
|
|
LocalFree(wzCurDir);
|
|
}
|
|
}
|
|
|
|
if (lpDriveLetter)
|
|
{
|
|
*lpDriveLetter = L'\0';
|
|
}
|
|
|
|
if (cDrive)
|
|
{
|
|
WCHAR wzDrive[4];
|
|
wzDrive[0] = cDrive;
|
|
wzDrive[1] = L':';
|
|
wzDrive[2] = L'\\';
|
|
wzDrive[3] = L'\0';
|
|
if (lpDriveLetter)
|
|
{
|
|
*lpDriveLetter = (WCHAR)cDrive;
|
|
}
|
|
|
|
return GetDriveTypeW(wzDrive);
|
|
}
|
|
else
|
|
{
|
|
return DRIVE_UNKNOWN;
|
|
}
|
|
}
|
|
|
|
/*++
|
|
|
|
Function Description:
|
|
|
|
Widen and duplicate a string into malloc memory.
|
|
|
|
Arguments:
|
|
|
|
IN strToCopy - String to copy
|
|
|
|
Return Value:
|
|
|
|
String in malloc memory
|
|
|
|
History:
|
|
|
|
03/07/2000 robkenny Created
|
|
05/16/2000 robkenny Moved MassagePath (shim specific) routines out of here.
|
|
|
|
--*/
|
|
|
|
WCHAR *
|
|
ToUnicode(const char *strToCopy)
|
|
{
|
|
if (strToCopy == NULL)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
// Get the number of characters in the resulting string, includes NULL at end
|
|
int nChars = MultiByteToWideChar(CP_ACP, 0, strToCopy, -1, NULL, 0);
|
|
WCHAR *lpwsz = (WCHAR *) malloc(nChars * sizeof(WCHAR));
|
|
if (lpwsz)
|
|
{
|
|
nChars = MultiByteToWideChar(CP_ACP, 0, strToCopy, -1, lpwsz, nChars);
|
|
// If MultibyteToWideChar failed, return NULL
|
|
if (nChars == 0)
|
|
{
|
|
free(lpwsz);
|
|
lpwsz = NULL;
|
|
}
|
|
}
|
|
|
|
return lpwsz;
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Function Description:
|
|
|
|
Convert a WCHAR string to a char string
|
|
|
|
Arguments:
|
|
|
|
IN lpOld - String to convert to char
|
|
|
|
Return Value:
|
|
|
|
char string in malloc memory
|
|
|
|
History:
|
|
|
|
06/19/2000 robkenny Created
|
|
|
|
--*/
|
|
|
|
char *
|
|
ToAnsi(const WCHAR *lpOld)
|
|
{
|
|
if (lpOld == NULL)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
// Get the number of bytes necessary for the WCHAR string
|
|
int nBytes = WideCharToMultiByte(CP_ACP, 0, lpOld, -1, NULL, 0, NULL, NULL);
|
|
char *lpsz = (char *) malloc(nBytes);
|
|
if (lpsz)
|
|
{
|
|
nBytes = WideCharToMultiByte(CP_ACP, 0, lpOld, -1, lpsz, nBytes, NULL, NULL);
|
|
// If WideCharToMultibyte failed, return NULL
|
|
if (nBytes == 0)
|
|
{
|
|
free(lpsz);
|
|
lpsz = NULL;
|
|
}
|
|
}
|
|
|
|
return lpsz;
|
|
}
|
|
|
|
/*++
|
|
|
|
Function Description:
|
|
|
|
Duplicate the first nChars of strToCopy string into malloc memory.
|
|
|
|
Arguments:
|
|
|
|
IN strToCopy - String to copy
|
|
IN nChar - Number of chars to duplicate, does not count NULL at end.
|
|
|
|
Return Value:
|
|
|
|
String in malloc memory
|
|
|
|
History:
|
|
|
|
06/02/2000 robkenny Created
|
|
|
|
--*/
|
|
|
|
char *
|
|
StringNDuplicateA(const char *strToCopy, int nChars)
|
|
{
|
|
if (strToCopy == NULL)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
size_t nBytes = (nChars + 1) * sizeof(strToCopy[0]);
|
|
|
|
char *strDuplicate = (char *) malloc(nBytes);
|
|
if (strDuplicate)
|
|
{
|
|
memcpy(strDuplicate, strToCopy, nBytes);
|
|
strDuplicate[nChars] = 0;
|
|
}
|
|
|
|
return strDuplicate;
|
|
}
|
|
|
|
/*++
|
|
|
|
Function Description:
|
|
|
|
Duplicate a string into malloc memory.
|
|
|
|
Arguments:
|
|
|
|
IN strToCopy - String to copy
|
|
|
|
Return Value:
|
|
|
|
String in malloc memory
|
|
|
|
History:
|
|
|
|
01/10/2000 linstev Updated
|
|
02/14/2000 robkenny Converted from VirtualAlloc to malloc
|
|
06/02/2000 robkenny Use StringNDuplicateA
|
|
|
|
--*/
|
|
|
|
char *
|
|
StringDuplicateA(const char *strToCopy)
|
|
{
|
|
if (strToCopy == NULL)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
char *strDuplicate = StringNDuplicateA(strToCopy, strlen(strToCopy));
|
|
return strDuplicate;
|
|
}
|
|
|
|
/*++
|
|
|
|
Function Description:
|
|
|
|
Duplicate the first nChars of strToCopy string into malloc memory.
|
|
|
|
Arguments:
|
|
|
|
IN strToCopy - String to copy
|
|
IN nChar - Number of chars to duplicate, does not count NULL at end.
|
|
|
|
Return Value:
|
|
|
|
String in malloc memory
|
|
|
|
History:
|
|
|
|
06/02/2000 robkenny Created
|
|
|
|
--*/
|
|
|
|
WCHAR *
|
|
StringNDuplicateW(const WCHAR *strToCopy, int nChars)
|
|
{
|
|
if (strToCopy == NULL)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
size_t nBytes = (nChars + 1) * sizeof(strToCopy[0]);
|
|
|
|
WCHAR *strDuplicate = (WCHAR *) malloc(nBytes);
|
|
if (strDuplicate)
|
|
{
|
|
memcpy(strDuplicate, strToCopy, nBytes);
|
|
strDuplicate[nChars] = 0;
|
|
}
|
|
|
|
return strDuplicate;
|
|
}
|
|
|
|
/*++
|
|
|
|
Function Description:
|
|
|
|
Duplicate a string into malloc memory.
|
|
|
|
Arguments:
|
|
|
|
IN strToCopy - String to copy
|
|
|
|
Return Value:
|
|
|
|
String in malloc memory
|
|
|
|
History:
|
|
|
|
01/10/2000 linstev Updated
|
|
02/14/2000 robkenny Converted from VirtualAlloc to malloc
|
|
06/02/2000 robkenny Use StringNDuplicateW
|
|
|
|
--*/
|
|
|
|
WCHAR *
|
|
StringDuplicateW(const WCHAR *strToCopy)
|
|
{
|
|
if (strToCopy == NULL)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
WCHAR *wstrDuplicate = StringNDuplicateW(strToCopy, wcslen(strToCopy));
|
|
return wstrDuplicate;
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Function Description:
|
|
|
|
Skip leading whitespace
|
|
|
|
Arguments:
|
|
|
|
IN str - String to scan
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
History:
|
|
|
|
01/10/2000 linstev Updated
|
|
|
|
--*/
|
|
|
|
VOID
|
|
SkipBlanksW(const WCHAR *& str)
|
|
{
|
|
if (str)
|
|
{
|
|
// Skip leading whitespace
|
|
static const WCHAR *WhiteSpaceString = L" \t";
|
|
str += wcsspn(str, WhiteSpaceString);
|
|
}
|
|
}
|
|
|
|
/*++
|
|
|
|
Function Description:
|
|
|
|
Find the first occurance of strCharSet in string
|
|
Case insensitive
|
|
|
|
Arguments:
|
|
|
|
IN string - String to search
|
|
IN strCharSet - String to search for
|
|
|
|
Return Value:
|
|
|
|
First occurance or NULL
|
|
|
|
History:
|
|
|
|
12/01/1999 robkenny Created
|
|
12/15/1999 linstev Reformatted
|
|
|
|
--*/
|
|
|
|
char*
|
|
__cdecl
|
|
stristr(
|
|
IN const char* string,
|
|
IN const char* strCharSet
|
|
)
|
|
{
|
|
char *pszRet = NULL;
|
|
|
|
long nstringLen = strlen(string) + 1;
|
|
long nstrCharSetLen = strlen(strCharSet) + 1;
|
|
|
|
char *szTemp_string = (char *) malloc(nstringLen);
|
|
char *szTemp_strCharSet = (char *) malloc(nstrCharSetLen);
|
|
|
|
if ((!szTemp_string) || (!szTemp_strCharSet))
|
|
{
|
|
goto Fail;
|
|
}
|
|
|
|
strcpy(szTemp_string, string);
|
|
strcpy(szTemp_strCharSet, strCharSet);
|
|
_strlwr(szTemp_string);
|
|
_strlwr(szTemp_strCharSet);
|
|
|
|
pszRet = strstr(szTemp_string, szTemp_strCharSet);
|
|
|
|
if (pszRet)
|
|
{
|
|
pszRet = ((char *) string) + (pszRet - szTemp_string);
|
|
}
|
|
|
|
Fail:
|
|
if (szTemp_string)
|
|
{
|
|
free(szTemp_string);
|
|
}
|
|
|
|
if (szTemp_strCharSet)
|
|
{
|
|
free(szTemp_strCharSet);
|
|
}
|
|
|
|
return pszRet;
|
|
}
|
|
|
|
/*++
|
|
|
|
Function Description:
|
|
|
|
Find the first occurance of strCharSet in string
|
|
Case insensitive
|
|
|
|
Arguments:
|
|
|
|
IN string - String to search
|
|
IN strCharSet - String to search for
|
|
|
|
Return Value:
|
|
|
|
First occurance or NULL
|
|
|
|
History:
|
|
|
|
12/01/1999 robkenny Created
|
|
12/15/1999 linstev Reformatted
|
|
05/04/2001 maonis Changed to use more efficient implementation.
|
|
|
|
--*/
|
|
|
|
#define _UPPER 0x1 /* upper case letter */
|
|
#define iswupper(_c) (iswctype(_c,_UPPER))
|
|
|
|
WCHAR*
|
|
__cdecl
|
|
wcsistr(
|
|
IN const WCHAR* wcs1,
|
|
IN const WCHAR* wcs2
|
|
)
|
|
{
|
|
wchar_t *cp = (wchar_t *) wcs1;
|
|
wchar_t *s1, *s2;
|
|
wchar_t cs1, cs2;
|
|
|
|
while (*cp)
|
|
{
|
|
s1 = cp;
|
|
s2 = (wchar_t *) wcs2;
|
|
|
|
cs1 = *s1;
|
|
cs2 = *s2;
|
|
|
|
if (iswupper(cs1))
|
|
cs1 = towlower(cs1);
|
|
|
|
if (iswupper(cs2))
|
|
cs2 = towlower(cs2);
|
|
|
|
|
|
while ( *s1 && *s2 && !(cs1-cs2) ) {
|
|
|
|
s1++, s2++;
|
|
|
|
cs1 = *s1;
|
|
cs2 = *s2;
|
|
|
|
if (iswupper(cs1))
|
|
cs1 = towlower(cs1);
|
|
|
|
if (iswupper(cs2))
|
|
cs2 = towlower(cs2);
|
|
}
|
|
|
|
if (!*s2)
|
|
return(cp);
|
|
|
|
cp++;
|
|
}
|
|
|
|
return(NULL);
|
|
}
|
|
|
|
/*++
|
|
|
|
Function Description:
|
|
|
|
Find the next token in a string. See strtok in MSDN.
|
|
Implemented here so we don't need CRT.
|
|
|
|
Arguments:
|
|
|
|
OUT strToken - string containing token(s)
|
|
IN strDelimit - token list
|
|
|
|
Return Value:
|
|
|
|
Return a pointer to the next token found.
|
|
|
|
History:
|
|
|
|
04/19/2000 linstev Created
|
|
|
|
--*/
|
|
|
|
char *
|
|
__cdecl
|
|
_strtok(
|
|
char *strToken,
|
|
const char *strDelimit
|
|
)
|
|
{
|
|
unsigned char *str = (unsigned char *)strToken;
|
|
const unsigned char *ctrl = (const unsigned char *)strDelimit;
|
|
|
|
unsigned char map[32];
|
|
int count;
|
|
char *token;
|
|
|
|
static char *nextoken;
|
|
|
|
// Clear strDelimit map
|
|
for (count = 0; count < 32; count++)
|
|
{
|
|
map[count] = 0;
|
|
}
|
|
|
|
// Set bits in delimiter table
|
|
do
|
|
{
|
|
map[*ctrl >> 3] |= (1 << (*ctrl & 7));
|
|
} while (*ctrl++);
|
|
|
|
// If strToken==NULL, continue with previous strToken
|
|
if (!str)
|
|
{
|
|
str = (unsigned char *)nextoken;
|
|
}
|
|
|
|
// Find beginning of token (skip over leading delimiters). Note that
|
|
// there is no token iff this loop sets strToken to point to the terminal
|
|
// null (*strToken == '\0')
|
|
while ((map[*str >> 3] & (1 << (*str & 7))) && *str)
|
|
{
|
|
str++;
|
|
}
|
|
|
|
token = (char *)str;
|
|
|
|
// Find the end of the token. If it is not the end of the strToken,
|
|
// put a null there.
|
|
for (; *str; str++)
|
|
{
|
|
if (map[*str >> 3] & (1 << (*str & 7)))
|
|
{
|
|
*str++ = '\0';
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Update nextoken (or the corresponding field in the per-thread data
|
|
// structure
|
|
nextoken = (char *)str;
|
|
|
|
// Determine if a token has been found
|
|
if (token == (char *)str)
|
|
{
|
|
return NULL;
|
|
}
|
|
else
|
|
{
|
|
return token;
|
|
}
|
|
}
|
|
|
|
/*++
|
|
|
|
Function Description:
|
|
|
|
Copy lpSrc into lpDest without overflowing the buffer
|
|
|
|
Arguments:
|
|
|
|
OUT lpDest Destination string
|
|
IN nDestChars Size in chars of lpDest
|
|
IN lpSrc Original string
|
|
IN nSrcChars Number of chars to copy
|
|
|
|
Return Value:
|
|
|
|
Returns the number of chars copied into lpDest
|
|
|
|
History:
|
|
|
|
04/19/2000 Robkenny Created
|
|
|
|
--*/
|
|
|
|
int
|
|
SafeStringCopyW(
|
|
WCHAR *lpDest,
|
|
DWORD nDestChars,
|
|
const WCHAR *lpSrc,
|
|
DWORD nSrcChars
|
|
)
|
|
{
|
|
size_t nCharsToCopy = __min(nSrcChars, nDestChars);
|
|
if (nCharsToCopy > 0)
|
|
{
|
|
memcpy(lpDest, lpSrc, nCharsToCopy*sizeof(WCHAR));
|
|
|
|
// Make sure string is properly terminated
|
|
if (lpSrc[nSrcChars-1] == 0)
|
|
{
|
|
lpDest[nCharsToCopy-1] = 0;
|
|
}
|
|
}
|
|
|
|
return nCharsToCopy;
|
|
}
|
|
|
|
|
|
/*++
|
|
|
|
Function Description:
|
|
|
|
Tests whether an executable is 16-Bit.
|
|
|
|
Arguments:
|
|
|
|
IN szImageName - The name of the executable image.
|
|
|
|
Return Value:
|
|
|
|
TRUE if executable image is found to be 16-bit, FALSE otherwise.
|
|
|
|
History:
|
|
|
|
07/06/2000 t-adams Created
|
|
|
|
--*/
|
|
|
|
BOOL
|
|
IsImage16BitA(LPCSTR lpApplicationName)
|
|
{
|
|
DWORD dwBinaryType;
|
|
|
|
if (GetBinaryTypeA(lpApplicationName, &dwBinaryType))
|
|
{
|
|
return (dwBinaryType == SCS_WOW_BINARY);
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
/*++
|
|
|
|
Function Description:
|
|
|
|
Tests whether an executable is 16-Bit.
|
|
|
|
Arguments:
|
|
|
|
IN wstrImageName - The name of the executable image.
|
|
|
|
Return Value:
|
|
|
|
TRUE if executable image is found to be 16-bit, FALSE otherwise.
|
|
|
|
History:
|
|
|
|
07/06/2000 t-adams Created
|
|
|
|
--*/
|
|
|
|
BOOL
|
|
IsImage16BitW(LPCWSTR lpApplicationName)
|
|
{
|
|
DWORD dwBinaryType;
|
|
|
|
if (GetBinaryTypeW(lpApplicationName, &dwBinaryType))
|
|
{
|
|
return (dwBinaryType == SCS_WOW_BINARY);
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
/*++
|
|
|
|
Function Description:
|
|
|
|
Match these two strings, with wildcards.
|
|
? matches a single character
|
|
* matches 0 or more characters
|
|
The compare is case in-sensitive
|
|
|
|
Arguments:
|
|
|
|
IN pszPattern - Pattern for matching.
|
|
IN pszTestString - String to match against.
|
|
|
|
Return Value:
|
|
|
|
TRUE if pszTestString matches pszPattern.
|
|
|
|
History:
|
|
|
|
01/09/2001 markder Replaced non-straightforward version.
|
|
|
|
--*/
|
|
|
|
BOOL
|
|
PatternMatchW(
|
|
IN LPCWSTR pszPattern,
|
|
IN LPCWSTR pszTestString)
|
|
{
|
|
//
|
|
// March through pszTestString. Each time through the loop,
|
|
// pszTestString is advanced one character.
|
|
//
|
|
BOOL bDone = TRUE;
|
|
while (bDone) {
|
|
|
|
//
|
|
// If pszPattern and pszTestString are both sitting on a NULL,
|
|
// then they reached the end at the same time and the strings
|
|
// must be equal.
|
|
//
|
|
if (*pszPattern == L'\0' && *pszTestString == L'\0') {
|
|
return TRUE;
|
|
}
|
|
|
|
if (*pszPattern != L'*') {
|
|
|
|
//
|
|
// Non-asterisk mode. Look for a match on this character.
|
|
//
|
|
|
|
switch (*(pszPattern)) {
|
|
|
|
case L'?':
|
|
//
|
|
// Match on any character, don't bother comparing.
|
|
//
|
|
pszPattern++;
|
|
break;
|
|
|
|
case L'\\':
|
|
//
|
|
// Backslash indicates to take the next character
|
|
// verbatim. Advance the pointer before making a
|
|
// comparison.
|
|
//
|
|
pszPattern++;
|
|
|
|
default:
|
|
//
|
|
// Compare the characters. If equal, continue traversing.
|
|
// Otherwise, the strings cannot be equal so return FALSE.
|
|
//
|
|
if (towupper(*pszPattern) == towupper(*pszTestString)) {
|
|
pszPattern++;
|
|
} else {
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
} else {
|
|
|
|
//
|
|
// Asterisk mode. Look for a match on the character directly
|
|
// after the asterisk.
|
|
//
|
|
|
|
switch (*(pszPattern + 1)) {
|
|
|
|
case L'*':
|
|
//
|
|
// Asterisks exist side by side. Advance the pattern pointer
|
|
// and go through loop again.
|
|
//
|
|
pszPattern++;
|
|
continue;
|
|
|
|
case L'\0':
|
|
//
|
|
// Asterisk exists at the end of the pattern string. Any
|
|
// remaining part of pszTestString matches so we can
|
|
// immediately return TRUE.
|
|
//
|
|
return TRUE;
|
|
|
|
case L'?':
|
|
//
|
|
// Match on any character. If the remaining parts of
|
|
// pszPattern and pszTestString match, then the entire
|
|
// string matches. Otherwise, keep advancing the
|
|
// pszTestString pointer.
|
|
//
|
|
if (PatternMatchW(pszPattern + 1, pszTestString)) {
|
|
return TRUE;
|
|
}
|
|
break;
|
|
|
|
case L'\\':
|
|
//
|
|
// Backslash indicates to take the next character
|
|
// verbatim. Advance the pointer before making a
|
|
// comparison.
|
|
//
|
|
pszPattern++;
|
|
break;
|
|
}
|
|
|
|
if (towupper(*(pszPattern + 1)) == towupper(*pszTestString)) {
|
|
//
|
|
// Characters match. If the remaining parts of
|
|
// pszPattern and pszTestString match, then the entire
|
|
// string matches. Otherwise, keep advancing the
|
|
// pszTestString pointer.
|
|
//
|
|
if (PatternMatchW(pszPattern + 1, pszTestString)) {
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// No more pszTestString left. Must not be a match.
|
|
//
|
|
if (!*pszTestString) {
|
|
return FALSE;
|
|
}
|
|
|
|
pszTestString++;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
/*++
|
|
|
|
Function Description:
|
|
|
|
Determine if the current process is a SafeDisc process. We do this by
|
|
simply by testing if both an .EXE and .ICD extension exist for the
|
|
process name.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
TRUE if Safedisc 1.x is detected.
|
|
|
|
History:
|
|
|
|
01/23/2001 linstev Created
|
|
|
|
--*/
|
|
|
|
BOOL
|
|
bIsSafeDisc1()
|
|
{
|
|
BOOL bRet = FALSE;
|
|
WCHAR szFileName[MAX_PATH+1];
|
|
|
|
if (GetModuleFileNameW(NULL, szFileName, MAX_PATH)) {
|
|
//
|
|
// Find the extension: first '.' after '\'
|
|
//
|
|
|
|
WCHAR *lpExtension = wcsrchr(szFileName, L'.');
|
|
if (lpExtension && (lpExtension > wcsrchr(szFileName, L'\\'))) {
|
|
|
|
//
|
|
// Detect SafeDisc 1.X, just look for an .ICD file with the same
|
|
// name
|
|
//
|
|
|
|
if (_wcsicmp(lpExtension, L".EXE") == 0) {
|
|
// Current file is .EXE, check for corresponding .ICD
|
|
wcscpy(lpExtension, L".ICD");
|
|
bRet = GetFileAttributesW(szFileName) != 0xFFFFFFFF;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bRet) {
|
|
DPF("ShimLib", eDbgLevelInfo, "SafeDisc detected: %S", szFileName);
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
/*++
|
|
|
|
Function Description:
|
|
|
|
Determine if the current process is a SafeDisc process. We do this running the
|
|
image header and looking for a particular signature.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
TRUE if Safedisc 2 is detected.
|
|
|
|
History:
|
|
|
|
07/28/2001 linstev Created
|
|
|
|
--*/
|
|
|
|
BOOL
|
|
bIsSafeDisc2()
|
|
{
|
|
PPEB Peb = NtCurrentPeb();
|
|
PLIST_ENTRY LdrHead;
|
|
PLIST_ENTRY LdrNext;
|
|
DWORD dwCnt = 0;
|
|
|
|
//
|
|
// Use the try-except in case the module list changes while we're looking at it
|
|
//
|
|
__try {
|
|
//
|
|
// Loop through the loaded modules. We use a count to make sure we
|
|
// aren't looping infinitely
|
|
//
|
|
LdrHead = &Peb->Ldr->InMemoryOrderModuleList;
|
|
|
|
LdrNext = LdrHead->Flink;
|
|
|
|
while ((LdrNext != LdrHead) && (dwCnt < 256)) {
|
|
|
|
PLDR_DATA_TABLE_ENTRY LdrEntry;
|
|
|
|
LdrEntry = CONTAINING_RECORD(LdrNext, LDR_DATA_TABLE_ENTRY, InMemoryOrderLinks);
|
|
|
|
if ((SSIZE_T)LdrEntry->DllBase > 0) {
|
|
//
|
|
// A user mode dll, now check for temp name
|
|
//
|
|
WCHAR *wzName = LdrEntry->BaseDllName.Buffer;
|
|
DWORD dwLen;
|
|
|
|
if (wzName && (dwLen = wcslen(wzName)) && (dwLen > 4) && (_wcsicmp(wzName + dwLen - 4, L".tmp") == 0)) {
|
|
//
|
|
// Name ends in .tmp, so detect SafeDisc
|
|
//
|
|
DWORD_PTR hMod = (DWORD_PTR) LdrEntry->DllBase;
|
|
PIMAGE_DOS_HEADER pIDH = (PIMAGE_DOS_HEADER) hMod;
|
|
PIMAGE_NT_HEADERS pINTH = (PIMAGE_NT_HEADERS)(hMod + pIDH->e_lfanew);
|
|
PIMAGE_EXPORT_DIRECTORY pExport = (PIMAGE_EXPORT_DIRECTORY) (hMod + pINTH->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress);
|
|
LPSTR pName = (LPSTR)(hMod + pExport->Name);
|
|
|
|
if (_stricmp(pName, "SecServ.dll") == 0) {
|
|
//
|
|
// Export name says this is SafeDisc
|
|
//
|
|
DPF("ShimLib", eDbgLevelInfo, "SafeDisc 2 detected");
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
dwCnt++;
|
|
LdrNext = LdrEntry->InMemoryOrderLinks.Flink;
|
|
}
|
|
} __except(EXCEPTION_EXECUTE_HANDLER) {
|
|
DPF("ShimLib", eDbgLevelError, "Exception encounterd while detecting SafeDisc 2");
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/*++
|
|
|
|
Function Description:
|
|
|
|
Determine if the current process is NTVDM.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
TRUE if NTVDM is detected.
|
|
|
|
History:
|
|
|
|
01/14/2002 clupu Created
|
|
|
|
--*/
|
|
|
|
BOOL
|
|
IsNTVDM(
|
|
void
|
|
)
|
|
{
|
|
PLDR_DATA_TABLE_ENTRY Entry;
|
|
PLIST_ENTRY Head;
|
|
PPEB Peb = NtCurrentPeb();
|
|
|
|
Head = &Peb->Ldr->InLoadOrderModuleList;
|
|
Head = Head->Flink;
|
|
|
|
Entry = CONTAINING_RECORD(Head, LDR_DATA_TABLE_ENTRY, InLoadOrderLinks);
|
|
|
|
if (_wcsicmp(Entry->FullDllName.Buffer, L"ntvdm.exe") == 0) {
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
}; // end of namespace ShimLib
|