static LoadUnloadTestDriverReverseOrder()
{
CFIX_ASSERT_EQUALS_DWORD( ERROR_SUCCESS, LoadReflector() );
CFIX_ASSERT_EQUALS_DWORD( ERROR_SUCCESS, LoadDriver( L"testklib1", L"testklib1.sys" ) );
UnloadDriver( L"cfixkr" );
UnloadDriver( L"testklib1" );
}
void UnloadAllCfixDrivers()
{
if ( IsDriverLoaded( L"cfixkr" ) )
{
UnloadDriver( L"cfixkr" );
}
if ( IsDriverLoaded( L"cfixkr_testklib0" ) )
{
UnloadDriver( L"cfixkr_testklib0" );
}
if ( IsDriverLoaded( L"cfixkr_testklib1" ) )
{
UnloadDriver( L"cfixkr_testklib1" );
}
if ( IsDriverLoaded( L"cfixkr_testklib2" ) )
{
UnloadDriver( L"cfixkr_testklib2" );
}
if ( IsDriverLoaded( L"cfixkr_testklib3" ) )
{
UnloadDriver( L"cfixkr_testklib3" );
}
if ( IsDriverLoaded( L"cfixkr_testklib4" ) )
{
UnloadDriver( L"cfixkr_testklib4" );
}
if ( IsDriverLoaded( L"cfixkr_testklib5" ) )
{
UnloadDriver( L"cfixkr_testklib5" );
}
if ( IsDriverLoaded( L"cfixkr_testklib6" ) )
{
UnloadDriver( L"cfixkr_testklib6" );
}
}
void CProcappDlg::OnOK()
{
// 启动驱动
OnInstallDriver();
// 访问设备
HANDLE hDevice = CreateFile("\\\\.\\proclistdrv",
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
0,
NULL );
if (hDevice == INVALID_HANDLE_VALUE)
return ;
BYTE* Processptr = new BYTE[1024*sizeof(ProcessInfo)];
ProcessInfo* ptr = (ProcessInfo*) (Processptr);
DWORD nb;
DeviceIoControl(hDevice,IOCTL_GETPROC_LIST,NULL,0,Processptr,1024*sizeof(ProcessInfo),&nb,NULL);
CloseHandle(hDevice);
// 卸载驱动
UnloadDriver();
// 解析processptr中数据
ProcessInfo* p;
CString str;
for (p=ptr; p; p=p->next)
{
str.Format("%x %x %s", p->addr, p->pid, p->name);
m_listbox.AddString(str);
}
}
VOID UnloadDevice (IN PDRIVER_OBJECT pDriverObject)
{
KdPrint(("UnloadDevice begin\n"));
//获取设备链表 加载的设备被自动保存在一个链表中
PDEVICE_OBJECT pNextObj = pDriverObject->DeviceObject
,pTmpObj;
//遍历设备链表
while (pNextObj)
{
//获取设备扩展结构
PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)pNextObj->DeviceExtension;
//释放保存设备名的内存
ExFreePool(pDevExt->ustrDeviceName.Buffer);
//删除符号链接
IoDeleteSymbolicLink(&pDevExt->ustrSymLinkName);
//释放保存符号名的内存
ExFreePool(pDevExt->ustrSymLinkName.Buffer);
//获取链表下一节点
pTmpObj= pNextObj->NextDevice;
//删除设备
IoDeleteDevice(pNextObj);
//指向链表下一节点
pNextObj = pTmpObj;
}
UnloadDriver();
KdPrint(("UnloadDevice end\n"));
}
void ListModulesExpectOverflow()
{
HANDLE Dev;
DWORD Cb;
CFIXKR_IOCTL_GET_MODULES Res;
CFIX_ASSERT_EQUALS_DWORD( ERROR_SUCCESS, LoadReflector() );
CFIX_ASSERT_EQUALS_DWORD( ERROR_SUCCESS, LoadDriver( L"testklib1", L"testklib1.sys" ) );
CFIX_ASSERT_EQUALS_DWORD( ERROR_SUCCESS, LoadDriver( L"testklib2", L"testklib2.sys" ) );
__try
{
Dev = CreateFile(
L"\\\\.\\Cfixkr",
GENERIC_READ | GENERIC_WRITE,
0,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL );
CFIX_ASSERT( Dev != INVALID_HANDLE_VALUE );
CFIX_ASSERT( ! DeviceIoControl(
Dev,
CFIXKR_IOCTL_GET_TEST_MODULES,
NULL,
0,
&Res,
sizeof( Res ),
&Cb,
NULL ) );
CFIX_ASSERT_EQUALS_DWORD( ERROR_MORE_DATA, GetLastError() );
CFIX_ASSERT( CloseHandle( Dev ) );
CFIX_ASSERT_EQUALS_DWORD( sizeof( Res ), Cb );
CFIX_ASSERT_EQUALS_DWORD( 2, Res.Count );
CFIX_ASSERT( Res.DriverLoadAddress[ 0 ] & 0x80000000 );
CFIX_ASSERT( ( Res.DriverLoadAddress[ 0 ] & 0x00000FFF ) == 0 );
}
__finally
{
UnloadDriver( L"cfixkr" );
UnloadDriver( L"testklib1" );
UnloadDriver( L"testklib2" );
}
}
/// <summary>
/// Unload driver
/// </summary>
/// <returns>Status code</returns>
NTSTATUS DriverControl::Unload()
{
if (_hDriver != INVALID_HANDLE_VALUE)
{
CloseHandle( _hDriver );
_hDriver = INVALID_HANDLE_VALUE;
}
return UnloadDriver( DRIVER_SVC_NAME );
}
afx_msg VOID CMainDialog::OnClose()
{
if (DriverLoaded)
{
UnloadDriver();
DriverLoaded = FALSE;
}
ExitProcess(0);
}
afx_msg BOOL CMainDialog::OnQueryEndSession()
{
if (DriverLoaded)
{
UnloadDriver();
DriverLoaded = FALSE;
}
ExitProcess(0);
}
/*********************************************
* Destructor. Free resources and unload the driver.
*
********************************************/
TDriver::~TDriver(void)
{
if(driverHandle != NULL)
{
CloseHandle(driverHandle);
driverHandle = NULL;
}
UnloadDriver();
}
VOID CMainDialog::OnShowWindowHandles()
{
CButton *pHideWindowHandlesButton = (CButton *)GetDlgItem(IDHIDEWINDOWHANDLES);
CButton *pShowWindowHandlesButton = (CButton *)GetDlgItem(IDSHOWWINDOWHANDLES);
if (DriverLoaded)
{
UnloadDriver();
DriverLoaded = FALSE;
}
pHideWindowHandlesButton->EnableWindow(TRUE);
pShowWindowHandlesButton->EnableWindow(FALSE);
}
bool CDriverLoader::MyZwUnloadDriver(char * szDrvName, char * szDrvPath)
{
if(!GetLoadDriverPriv())
{
return FALSE;
}
if (szDrvName==NULL)
{
szDrvName=(char*)m_szDrvName.c_str();
}
if (szDrvPath==NULL)
{
szDrvPath=(char*)m_szDrvPath.c_str();
}
if (szDrvName==NULL||szDrvPath==NULL)
{
OutputDebugString("Driver do not Exist!!!\n");
return false;
}
if (strlen(szDrvName)==0)
{
OutputDebugString("Driver do not Exist!!!\n");
return false;
}
HMODULE hNtdll = NULL;
hNtdll = LoadLibrary( "ntdll.dll" );
RtlAnsiStringToUnicodeString = (RTLANSISTRINGTOUNICODESTRING) GetProcAddress( hNtdll, "RtlAnsiStringToUnicodeString");
RtlFreeUnicodeString = (RTLFREEUNICODESTRING) GetProcAddress( hNtdll, "RtlFreeUnicodeString");
ZwUnloadDriver = (ZWLOADDRIVER) GetProcAddress( hNtdll, "ZwUnloadDriver");
if(UnloadDriver(szDrvName, szDrvPath) == false)
{
FreeLibrary(hNtdll);
return false;
}
FreeLibrary(hNtdll);
return true;
}
/*********************************************
* Init the driver class variables
*
********************************************/
DWORD TDriver::InitDriver(LPCTSTR path)
{
//if already initialized, first unload
if(m_binitialized)
{
if(UnloadDriver() != DRV_SUCCESS)
{
return(DRV_ERROR_ALREADY_INITIALIZED);
}
}
CPath objPath ;
objPath = path ;
m_strDriverName = objPath.GetFileTitle();
m_strDriverPath = path;
m_strDriverDosName.Format( _T("\\\\.\\%s"), m_strDriverName);
m_binitialized = TRUE;
return(DRV_SUCCESS);
}
void ListModulesExpectEmptyResponse()
{
HANDLE Dev;
DWORD Cb;
CFIXKR_IOCTL_GET_MODULES Res;
CFIX_ASSERT_EQUALS_DWORD( ERROR_SUCCESS, LoadReflector() );
__try
{
Dev = CreateFile(
L"\\\\.\\Cfixkr",
GENERIC_READ | GENERIC_WRITE,
0,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL );
CFIX_ASSERT( Dev != INVALID_HANDLE_VALUE );
CFIX_ASSERT( DeviceIoControl(
Dev,
CFIXKR_IOCTL_GET_TEST_MODULES,
NULL,
0,
&Res,
sizeof( CFIXKR_IOCTL_GET_MODULES ),
&Cb,
NULL ) );
CFIX_ASSERT( CloseHandle( Dev ) );
CFIX_ASSERT( Cb == sizeof( ULONG ) );
CFIX_ASSERT( Res.Count == 0 );
}
__finally
{
UnloadDriver( L"cfixkr" );
}
}
void ListModulesInvalidRequestSize()
{
HANDLE Dev;
DWORD Cb;
ULONG Req;
CFIXKR_IOCTL_GET_MODULES Res;
CFIX_ASSERT_EQUALS_DWORD( ERROR_SUCCESS, LoadReflector() );
__try
{
Dev = CreateFile(
L"\\\\.\\Cfixkr",
GENERIC_READ | GENERIC_WRITE,
0,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL );
CFIX_ASSERT( Dev != INVALID_HANDLE_VALUE );
CFIX_ASSERT( ! DeviceIoControl(
Dev,
CFIXKR_IOCTL_GET_TEST_MODULES,
&Req,
sizeof( ULONG ), // should be 0.
&Res,
sizeof( CFIXKR_IOCTL_GET_MODULES ),
&Cb,
NULL ) );
CFIX_ASSERT_EQUALS_DWORD( ERROR_INVALID_PARAMETER, GetLastError() );
CFIX_ASSERT( CloseHandle( Dev ) );
}
__finally
{
UnloadDriver( L"cfixkr" );
}
}
NTSTATUS
PtUnload (
__in FLT_FILTER_UNLOAD_FLAGS Flags
)
/*++
Routine Description:
This is the unload routine for this miniFilter driver. This is called
when the minifilter is about to be unloaded. We can fail this unload
request if this is not a mandatory unloaded indicated by the Flags
parameter.
Arguments:
Flags - Indicating if this is a mandatory unload.
Return Value:
Returns the final status of this operation.
--*/
{
UNREFERENCED_PARAMETER( Flags );
PAGED_CODE();
UnloadDriver();
PT_DBG_PRINT( PTDBG_TRACE_ROUTINES,
("PassThrough!PtUnload: Entered\n") );
FltUnregisterFilter( gFilterHandle );
return STATUS_SUCCESS;
}
static void LoadUnloadCfixkr()
{
LoadReflector();
UnloadDriver( L"cfixkr" );
}
//Init the driver class variables
DWORD TDriver::InitDriver(LPCTSTR name, LPCTSTR path, LPCTSTR dosName)
{
//if already initialized, first unload
if(initialized)
{
if(UnloadDriver() != DRV_SUCCESS)
return DRV_ERROR_ALREADY_INITIALIZED;
}
LPTSTR dirBuffer;
//if the user introduced path, first i will ckeck it
if (path != NULL)
{
//if yes, copy in auxiliar buffer and continue
DWORD len = (DWORD)(strlen(name) + strlen(path) + 1);
dirBuffer = (LPTSTR) malloc (len);
if(dirBuffer == NULL)
return DRV_ERROR_MEMORY;
strcpy(dirBuffer, path);
}
else
{
//if the user dont introduced path, i search in curren directory
LPTSTR pathBuffer;
DWORD len = GetCurrentDirectory(0, NULL);
pathBuffer = (LPTSTR) malloc (len);
if(pathBuffer == NULL)
return DRV_ERROR_MEMORY;
if (GetCurrentDirectory(len, pathBuffer) != 0)
{
len = (DWORD)(strlen(pathBuffer) + strlen(name) + 6);
dirBuffer = (LPTSTR) malloc (len);
if(dirBuffer == NULL)
{
free(pathBuffer);
return DRV_ERROR_MEMORY;
}
//complete de total path, currentdirectory\driverName.sys
sprintf(dirBuffer, "%s\\%s.sys", pathBuffer, name);
//exists this file?
if(GetFileAttributes(dirBuffer) == 0xFFFFFFFF)
{
free(pathBuffer);
free(dirBuffer);
//if no, i search in \system32\drivers\
LPCTSTR sysDriver = "\\system32\\Drivers\\";
LPTSTR sysPath;
//i have to get the windows directory
DWORD len = GetWindowsDirectory(NULL, 0);
sysPath = (LPTSTR) malloc (len + strlen(sysDriver));
if(sysPath == NULL)
return DRV_ERROR_MEMORY;
if (GetWindowsDirectory(sysPath, len) == 0)
{
free(sysPath);
return DRV_ERROR_UNKNOWN;
}
//complete the path and check it
strcat(sysPath, sysDriver);
len = (DWORD)(strlen(sysPath) + strlen(name) + 5);
dirBuffer = (LPTSTR) malloc (len);
if(dirBuffer == NULL)
return DRV_ERROR_MEMORY;
sprintf(dirBuffer, "%s%s.sys", sysPath, name);
free(sysPath);
//if the file neither exist, i dont know where is it -> i dont initialize
if(GetFileAttributes(dirBuffer) == 0xFFFFFFFF)
{
free(dirBuffer);
return DRV_ERROR_INVALID_PATH_OR_FILE;
}
}
}
else
{
free(pathBuffer);
return DRV_ERROR_UNKNOWN;
}
}
//Write driver's variables with obtained data
driverPath = dirBuffer;
driverName = (LPTSTR)malloc(strlen(name) + 1);
if(driverName == NULL)
{
free(driverPath);
driverPath = NULL;
return DRV_ERROR_MEMORY;
}
strcpy(driverName, name);
LPCTSTR auxBuffer;
if(dosName != NULL)
auxBuffer = dosName;
else
auxBuffer = name;
//dosName=\\.\driverName
if(auxBuffer[0] != '\\' && auxBuffer[1] != '\\')
{
driverDosName = (LPTSTR) malloc (strlen(auxBuffer) + 5);
if(driverDosName == NULL)
{
free(driverPath);
driverPath = NULL;
free(driverName);
driverName = NULL;
return DRV_ERROR_MEMORY;
}
sprintf(driverDosName, "\\\\.\\%s", auxBuffer);
}
else
{
driverDosName = (LPTSTR) malloc (strlen(auxBuffer));
if(driverDosName == NULL)
{
free(driverPath);
driverPath = NULL;
free(driverName);
driverName = NULL;
return DRV_ERROR_MEMORY;
}
strcpy(driverDosName, auxBuffer);
}
//set the state to initialized
initialized = TRUE;
return DRV_SUCCESS;
}
NTSTATUS
DriverEntry (
__in PDRIVER_OBJECT DriverObject,
__in PUNICODE_STRING RegistryPath
)
/*++
Routine Description:
This is the initialization routine for this miniFilter driver. This
registers with FltMgr and initializes all global data structures.
Arguments:
DriverObject - Pointer to driver object created by the system to
represent this driver.
RegistryPath - Unicode string identifying where the parameters for this
driver are located in the registry.
Return Value:
Returns STATUS_SUCCESS.
--*/
{
NTSTATUS status;
BOOLEAN bInit = FALSE;
PSECURITY_DESCRIPTOR sd;
OBJECT_ATTRIBUTES oa;
UNICODE_STRING uniString;
UNREFERENCED_PARAMETER( RegistryPath );
PT_DBG_PRINT( PTDBG_TRACE_ROUTINES,
("PassThrough!DriverEntry: Entered\n") );
try
{
status = FltRegisterFilter( DriverObject,
&FilterRegistration,
&gFilterHandle );
if (!NT_SUCCESS( status ))
{
leave;
}
#ifdef CV
VirtualizerStart();
#endif
status = InitDriverEntry( DriverObject,RegistryPath);
#ifdef CV
VirtualizerEnd();
#endif
if (!NT_SUCCESS( status ))
{
bInit = FALSE;
leave;
}
bInit = TRUE;
status = FltBuildDefaultSecurityDescriptor( &sd,
FLT_PORT_ALL_ACCESS );
if (!NT_SUCCESS( status ))
{
leave;
}
RtlInitUnicodeString( &uniString, X70FSD_PORT_NAME );
InitializeObjectAttributes( &oa,
&uniString,
OBJ_KERNEL_HANDLE | OBJ_CASE_INSENSITIVE,
NULL,
sd );
status = FltCreateCommunicationPort( gFilterHandle,
&gServerPort,
&oa,
NULL,
PtMiniConnect,
PtMiniDisconnect,
PtMiniMessage,
1 );
FltFreeSecurityDescriptor( sd );
if (!NT_SUCCESS( status ))
{
leave;
}
status = FltStartFiltering( gFilterHandle );
}
finally
{
if (!NT_SUCCESS( status ) )
{
if (NULL != gServerPort)
{
FltCloseCommunicationPort( gServerPort);
}
if (NULL != gFilterHandle)
{
FltUnregisterFilter( gFilterHandle );
}
if(bInit)
{
UnloadDriver();
}
}
}
DbgPrint("status = %x ",status);
return status;
}
//Init the driver class variables
DWORD TDriver::InitDriver(LPCTSTR path)
{
//if already initialized, first unload
if(initialized)
{
if(UnloadDriver() != DRV_SUCCESS)
return DRV_ERROR_ALREADY_INITIALIZED;
}
//if yes, i analized the path to extract driver name
driverPath = (LPTSTR)malloc(strlen(path) + 1);
if(driverPath == NULL)
return DRV_ERROR_MEMORY;
strcpy(driverPath, path);
//first i search the last backslash
LPTSTR sPos1 = strrchr(driverPath, (int)'\\');
//if null, the string havent any backslash
if (sPos1 == NULL)
sPos1 = driverPath;
//now, i search .sys
LPTSTR sPos2 = strrchr(sPos1, (int)'.');
if (sPos2 == NULL || sPos1 > sPos2)
{
free(driverPath);
driverPath = NULL;
return DRV_ERROR_INVALID_PATH_OR_FILE;
}
//extract the driver name
driverName = (LPTSTR) malloc (sPos2 - sPos1);
if(driverName == NULL)
{
free(driverPath);
driverPath = NULL;
return DRV_ERROR_MEMORY;
}
memcpy(driverName, sPos1 + 1, sPos2 - sPos1 - 1);
driverName[sPos2 - sPos1 - 1] = 0;
//driverDosName = \\.\driverName
driverDosName = (LPTSTR) malloc (strlen(driverName) + 5);
if(driverDosName == NULL)
{
free(driverPath);
driverPath = NULL;
free(driverName);
driverName = NULL;
return DRV_ERROR_MEMORY;
}
sprintf(driverDosName, "\\\\.\\%s", driverName);
initialized = TRUE;
return DRV_SUCCESS;
}
/// <summary>
/// Unload driver
/// </summary>
/// <returns>Status code</returns>
NTSTATUS DriverControl::Unload()
{
_hDriver.reset();
return UnloadDriver( DRIVER_SVC_NAME );
}
DWORD MyDriver::IniMyDriver(char * name, char * path, char * dosName)
{
if(initialized)
{
if(UnloadDriver() != DRV_SUCCESS)
return DRV_ERROR_ALREADY_INITIALIZED;
}
char * dirBuffer;
if (path != NULL)
{
DWORD len = (DWORD)(strlen(name) + strlen(path) + 1);
dirBuffer = (char *) malloc (len);
if(dirBuffer == NULL)
return DRV_ERROR_MEMORY;
strcpy(dirBuffer, path);
}
else
{
char * pathBuffer;
DWORD len = GetCurrentDirectory(0, NULL);
pathBuffer = (char *) malloc (len);
if(pathBuffer == NULL)
return DRV_ERROR_MEMORY;
if (GetCurrentDirectoryA(len, pathBuffer) != 0)
{
len = (DWORD)(strlen(pathBuffer) + strlen(name) + 6);
dirBuffer = (char *) malloc (len);
if(dirBuffer == NULL)
{
free(pathBuffer);
return DRV_ERROR_MEMORY;
}
sprintf(dirBuffer, "%s\\%s.sys", pathBuffer, name);
if(GetFileAttributesA(dirBuffer) == 0xFFFFFFFF)
{
free(pathBuffer);
free(dirBuffer);
char * sysDriver = "\\system32\\Drivers\\";
char * sysPath;
DWORD len = GetWindowsDirectory(NULL, 0);
sysPath = (char *) malloc (len + strlen(sysDriver));
if(sysPath == NULL)
return DRV_ERROR_MEMORY;
if (GetWindowsDirectoryA(sysPath, len) == 0)
{
free(sysPath);
return DRV_ERROR_UNKNOWN;
}
strcat(sysPath, sysDriver);
len = (DWORD)(strlen(sysPath) + strlen(name) + 5);
dirBuffer = (char *) malloc (len);
if(dirBuffer == NULL)
return DRV_ERROR_MEMORY;
sprintf(dirBuffer, "%s%s.sys", sysPath, name);
free(sysPath);
if(GetFileAttributesA(dirBuffer) == 0xFFFFFFFF)
{
free(dirBuffer);
return DRV_ERROR_INVALID_PATH_OR_FILE;
}
}
free(pathBuffer);
}
else
{
free(pathBuffer);
return DRV_ERROR_UNKNOWN;
}
}
driverPath = dirBuffer;
driverName = (char *)malloc(strlen(name) + 1);
if(driverName == NULL)
{
free(driverPath);
driverPath = NULL;
return DRV_ERROR_MEMORY;
}
strcpy(driverName, name);
char * auxBuffer;
if(dosName != NULL)
auxBuffer = dosName;
else
auxBuffer = name;
if(auxBuffer[0] != '\\' && auxBuffer[1] != '\\')
{
driverDosName = (char *) malloc (strlen(auxBuffer) + 5);
if(driverDosName == NULL)
{
free(driverPath);
driverPath = NULL;
free(driverName);
driverName = NULL;
return DRV_ERROR_MEMORY;
}
sprintf(driverDosName, "\\\\.\\%s", auxBuffer);
}
else
{
driverDosName = (char *) malloc (strlen(auxBuffer));
if(driverDosName == NULL)
{
free(driverPath);
driverPath = NULL;
free(driverName);
driverName = NULL;
return DRV_ERROR_MEMORY;
}
strcpy(driverDosName, auxBuffer);
}
initialized = TRUE;
return DRV_SUCCESS;
}
DWORD MyDriver::IniMyDriver(char * path)
{
if(initialized)
{
if(UnloadDriver() != DRV_SUCCESS)
return DRV_ERROR_ALREADY_INITIALIZED;
}
driverPath = (char *)malloc(strlen(path) + 1);
if(driverPath == NULL)
return DRV_ERROR_MEMORY;
strcpy(driverPath, path);
char * sPos1 = strrchr(driverPath, (int)'\\');
if (sPos1 == NULL)
sPos1 = driverPath;
char * sPos2 = strrchr(sPos1, (int)'.');
if (sPos2 == NULL || sPos1 > sPos2)
{
free(driverPath);
driverPath = NULL;
return DRV_ERROR_INVALID_PATH_OR_FILE;
}
driverName = (char *) malloc (sPos2 - sPos1);
if(driverName == NULL)
{
free(driverPath);
driverPath = NULL;
return DRV_ERROR_MEMORY;
}
memcpy(driverName, sPos1 + 1, sPos2 - sPos1 - 1);
driverName[sPos2 - sPos1 - 1] = 0;
driverDosName = (char *) malloc (strlen(driverName) + 5);
if(driverDosName == NULL)
{
free(driverPath);
driverPath = NULL;
free(driverName);
driverName = NULL;
return DRV_ERROR_MEMORY;
}
sprintf(driverDosName, "\\\\.\\%s", driverName);
initialized = TRUE;
return DRV_SUCCESS;
}
/*********************************************
* Init the driver class variables
********************************************/
DWORD TDriver::InitDriver(LPCTSTR name, LPCTSTR path, LPCTSTR dosName)
{
//if already initialized, first unload
if(m_binitialized)
{
if(UnloadDriver() != DRV_SUCCESS)
{
return(DRV_ERROR_ALREADY_INITIALIZED);
}
}
CString dirBuffer;
//if the user introduced path, first i will ckeck it
if(path != NULL)
{
dirBuffer = path;
}
else
{
//if the user dont introduced path, i search in curren directory
TCHAR pathBuffer[MAX_PATH +1];
if(GetCurrentDirectory(MAX_PATH+1, pathBuffer) != 0)
{
dirBuffer.Format(_T("%s\\%s.sys"), pathBuffer, name);
//exists this file?
if(GetFileAttributes(dirBuffer) == 0xFFFFFFFF)
{
//if no, i search in \system32\drivers\
CString sysDriver = _T("\\system32\\Drivers\\");
//LPTSTR sysPath;
TCHAR sysPath[MAX_PATH +1];
if(GetWindowsDirectory(sysPath, MAX_PATH+1) == 0)
{
//free(sysPath);
return(DRV_ERROR_UNKNOWN);
}
dirBuffer.Format(_T("%s%s.sys"), sysPath, name);
//if the file neither exist, i dont know where is it -> i dont initialize
if(GetFileAttributes(dirBuffer) == 0xFFFFFFFF)
{
return(DRV_ERROR_INVALID_PATH_OR_FILE);
}
}
}
else
{
return(DRV_ERROR_UNKNOWN);
}
}
//Write driver's variables with obtained data
m_strDriverPath = dirBuffer;
m_strDriverName = name;
LPCTSTR auxBuffer;
if(dosName != NULL)
{
auxBuffer = dosName;
}
else
{
auxBuffer = name;
}
if(auxBuffer[0] != '\\' && auxBuffer[1] != '\\')
{
m_strDriverDosName = auxBuffer; //(LPTSTR) malloc(_tcslen(auxBuffer) + 5);
m_strDriverDosName.Format(_T("\\\\.\\%s"), auxBuffer);
}
else
{
m_strDriverDosName = auxBuffer;
}
//set the state to initialized
m_binitialized = TRUE;
return(DRV_SUCCESS);
}
VOID
main(
// IN ULONG argc,
// IN PCHAR argv[],
// IN PCHAR envp[]
)
/*++
Routine Description:
This is the main routine of the floppy test.
Arguments:
None
Return Value:
None.
--*/
{
CHAR Device[256];
while (1) {
DbgPrint( "Test program for the floppy driver.\n\n\n" );
DbgPrint( " 0 - Exit\n\n" );
DbgPrint( " 1 - Read statistics\n\n" );
DbgPrint( " 2 - Tune FIFO delay\n\n" );
DbgPrint( " 3 - Get supported media types\n\n" );
DbgPrint( " 4 - Format some tracks\n\n" );
DbgPrint( " 5 - Test power failure recovery\n\n" );
DbgPrint( " 6 - Unload driver\n\n" );
DbgPrompt( "Select: ", Buffer, 256 );
if (Buffer[0] == '0') {
break;
}
switch(Buffer[0]) {
case '1':
GetStatistics();
break;
case '2':
TuneFifoDelay();
break;
case '3':
GetMediaTypes( NULL );
break;
case '4':
Device[0] = '\0';
DbgPrompt( "Enter device id (1 = \\A:, 2 = \\B:): ",
&(Device[0]), 256);
if (Device[0] != '\0') {
FormatSomeTracks( Device[0] );
}
break;
case '5':
PowerTest();
break;
case '6':
UnloadDriver();
break;
default:
break;
}
}
}
VOID CMainDialog::OnHideWindowHandles()
{
CHAR ProcessName[MAX_PATH];
CEdit *pProcessName = (CEdit *)GetDlgItem(IDC_PROCESSNAME);
CButton *pHideWindowHandlesButton = (CButton *)GetDlgItem(IDHIDEWINDOWHANDLES);
CButton *pShowWindowHandlesButton = (CButton *)GetDlgItem(IDSHOWWINDOWHANDLES);
pProcessName->GetWindowText(ProcessName, sizeof(ProcessName));
strcat(ProcessName, ".exe");
DWORD HiddenWindowHandleProcessId;
LPVOID pHiddenWindowHandleProcessId = &HiddenWindowHandleProcessId;
if(FALSE != (HiddenWindowHandleProcessId = GetProcessID(ProcessName)))
{
pHideWindowHandlesButton->EnableWindow(FALSE);
pShowWindowHandlesButton->EnableWindow(TRUE);
}
else
{
MessageBox("Process Does Not Exist!", "Error", MB_ICONERROR);
return;
}
if (DriverLoaded)
{
UnloadDriver();
DriverLoaded = FALSE;
}
LoadDriver();
DriverLoaded = TRUE;
CommDevice = CreateFile("\\\\.\\ShadowTableHookDriver", GENERIC_READ | GENERIC_WRITE,
0, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if(CommDevice == INVALID_HANDLE_VALUE)
{
int error = GetLastError();
FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL,
GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &lpMsgBuf,
0, NULL);
MessageBox((LPTSTR)lpMsgBuf, "GetLastError", MB_OK|MB_ICONINFORMATION);
return;
}
if(CommDevice)
{
DWORD dwReturn;
if (0 == (DeviceIoControl(CommDevice, IO_SEND_HIDDEN_PROCESS_ID,
pHiddenWindowHandleProcessId, sizeof(HiddenWindowHandleProcessId),
NULL, 0, &dwReturn, NULL)))
{
int error = GetLastError();
FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL,
GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &lpMsgBuf,
0, NULL);
MessageBox((LPCSTR)lpMsgBuf, "GetLastError", MB_OK|MB_ICONINFORMATION);
return;
}
}
if(CommDevice)
{
DWORD dwReturn;
IsGUIThread(TRUE);
if (0 == (DeviceIoControl(CommDevice, IO_HOOK_SYSTEM_SERVICES, NULL, 0,
NULL, 0, &dwReturn, NULL)))
{
int error = GetLastError();
FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL,
GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &lpMsgBuf,
0, NULL);
MessageBox((LPCSTR)lpMsgBuf, "GetLastError", MB_OK|MB_ICONINFORMATION);
return;
}
}
}
