341 lines
12 KiB
C
341 lines
12 KiB
C
/*
|
|
* Service process to load a kernel driver
|
|
*
|
|
* Copyright 2007 Alexandre Julliard
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#include "config.h"
|
|
#include "wine/port.h"
|
|
|
|
#include <stdarg.h>
|
|
|
|
#include "ntstatus.h"
|
|
#define WIN32_NO_STATUS
|
|
#include "windef.h"
|
|
#include "winbase.h"
|
|
#include "winternl.h"
|
|
#include "winreg.h"
|
|
#include "winnls.h"
|
|
#include "winsvc.h"
|
|
#include "ddk/wdm.h"
|
|
#include "wine/unicode.h"
|
|
#include "wine/debug.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(winedevice);
|
|
WINE_DECLARE_DEBUG_CHANNEL(relay);
|
|
|
|
extern NTSTATUS CDECL wine_ntoskrnl_main_loop( HANDLE stop_event );
|
|
|
|
static WCHAR *driver_name;
|
|
static SERVICE_STATUS_HANDLE service_handle;
|
|
static HKEY driver_hkey;
|
|
static HANDLE stop_event;
|
|
static DRIVER_OBJECT driver_obj;
|
|
static DRIVER_EXTENSION driver_extension;
|
|
|
|
/* find the LDR_MODULE corresponding to the driver module */
|
|
static LDR_MODULE *find_ldr_module( HMODULE module )
|
|
{
|
|
LIST_ENTRY *entry, *list = &NtCurrentTeb()->Peb->LdrData->InMemoryOrderModuleList;
|
|
|
|
for (entry = list->Flink; entry != list; entry = entry->Flink)
|
|
{
|
|
LDR_MODULE *ldr = CONTAINING_RECORD(entry, LDR_MODULE, InMemoryOrderModuleList);
|
|
if (ldr->BaseAddress == module) return ldr;
|
|
if (ldr->BaseAddress > (void *)module) break;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/* load the driver module file */
|
|
static HMODULE load_driver_module( const WCHAR *name )
|
|
{
|
|
IMAGE_NT_HEADERS *nt;
|
|
const IMAGE_IMPORT_DESCRIPTOR *imports;
|
|
size_t page_size = getpagesize();
|
|
int i;
|
|
INT_PTR delta;
|
|
ULONG size;
|
|
HMODULE module = LoadLibraryW( name );
|
|
|
|
if (!module) return NULL;
|
|
nt = RtlImageNtHeader( module );
|
|
|
|
if (!(delta = (char *)module - (char *)nt->OptionalHeader.ImageBase)) return module;
|
|
|
|
/* the loader does not apply relocations to non page-aligned binaries or executables,
|
|
* we have to do it ourselves */
|
|
|
|
if (nt->OptionalHeader.SectionAlignment < page_size ||
|
|
!(nt->FileHeader.Characteristics & IMAGE_FILE_DLL))
|
|
{
|
|
DWORD old;
|
|
IMAGE_BASE_RELOCATION *rel, *end;
|
|
|
|
if ((rel = RtlImageDirectoryEntryToData( module, TRUE, IMAGE_DIRECTORY_ENTRY_BASERELOC, &size )))
|
|
{
|
|
WINE_TRACE( "%s: relocating from %p to %p\n",
|
|
wine_dbgstr_w(name), (char *)module - delta, module );
|
|
end = (IMAGE_BASE_RELOCATION *)((char *)rel + size);
|
|
while (rel < end && rel->SizeOfBlock)
|
|
{
|
|
void *page = (char *)module + rel->VirtualAddress;
|
|
VirtualProtect( page, page_size, PAGE_EXECUTE_READWRITE, &old );
|
|
rel = LdrProcessRelocationBlock( page, (rel->SizeOfBlock - sizeof(*rel)) / sizeof(USHORT),
|
|
(USHORT *)(rel + 1), delta );
|
|
if (old != PAGE_EXECUTE_READWRITE) VirtualProtect( page, page_size, old, NULL );
|
|
if (!rel) goto error;
|
|
}
|
|
/* make sure we don't try again */
|
|
size = FIELD_OFFSET( IMAGE_NT_HEADERS, OptionalHeader ) + nt->FileHeader.SizeOfOptionalHeader;
|
|
VirtualProtect( nt, size, PAGE_READWRITE, &old );
|
|
nt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress = 0;
|
|
VirtualProtect( nt, size, old, NULL );
|
|
}
|
|
}
|
|
|
|
/* make sure imports are relocated too */
|
|
|
|
if ((imports = RtlImageDirectoryEntryToData( module, TRUE, IMAGE_DIRECTORY_ENTRY_IMPORT, &size )))
|
|
{
|
|
for (i = 0; imports[i].Name && imports[i].FirstThunk; i++)
|
|
{
|
|
char *name = (char *)module + imports[i].Name;
|
|
WCHAR buffer[32], *p = buffer;
|
|
|
|
while (p < buffer + 32) if (!(*p++ = *name++)) break;
|
|
if (p <= buffer + 32) FreeLibrary( load_driver_module( buffer ) );
|
|
}
|
|
}
|
|
|
|
return module;
|
|
|
|
error:
|
|
FreeLibrary( module );
|
|
return NULL;
|
|
}
|
|
|
|
/* call the driver init entry point */
|
|
static NTSTATUS init_driver( HMODULE module, UNICODE_STRING *keyname )
|
|
{
|
|
unsigned int i;
|
|
NTSTATUS status;
|
|
const IMAGE_NT_HEADERS *nt = RtlImageNtHeader( module );
|
|
|
|
if (!nt->OptionalHeader.AddressOfEntryPoint) return STATUS_SUCCESS;
|
|
|
|
driver_obj.Size = sizeof(driver_obj);
|
|
driver_obj.DriverSection = find_ldr_module( module );
|
|
driver_obj.DriverInit = (PDRIVER_INITIALIZE)((char *)module + nt->OptionalHeader.AddressOfEntryPoint);
|
|
driver_obj.DriverExtension = &driver_extension;
|
|
|
|
driver_extension.DriverObject = &driver_obj;
|
|
driver_extension.ServiceKeyName = *keyname;
|
|
|
|
if (WINE_TRACE_ON(relay))
|
|
WINE_DPRINTF( "%04x:Call driver init %p (obj=%p,str=%s)\n", GetCurrentThreadId(),
|
|
driver_obj.DriverInit, &driver_obj, wine_dbgstr_w(keyname->Buffer) );
|
|
|
|
status = driver_obj.DriverInit( &driver_obj, keyname );
|
|
|
|
if (WINE_TRACE_ON(relay))
|
|
WINE_DPRINTF( "%04x:Ret driver init %p (obj=%p,str=%s) retval=%08x\n", GetCurrentThreadId(),
|
|
driver_obj.DriverInit, &driver_obj, wine_dbgstr_w(keyname->Buffer), status );
|
|
|
|
WINE_TRACE( "init done for %s obj %p\n", wine_dbgstr_w(driver_name), &driver_obj );
|
|
WINE_TRACE( "- DriverInit = %p\n", driver_obj.DriverInit );
|
|
WINE_TRACE( "- DriverStartIo = %p\n", driver_obj.DriverStartIo );
|
|
WINE_TRACE( "- DriverUnload = %p\n", driver_obj.DriverUnload );
|
|
for (i = 0; i <= IRP_MJ_MAXIMUM_FUNCTION; i++)
|
|
WINE_TRACE( "- MajorFunction[%d] = %p\n", i, driver_obj.MajorFunction[i] );
|
|
|
|
return status;
|
|
}
|
|
|
|
/* load the .sys module for a device driver */
|
|
static BOOL load_driver(void)
|
|
{
|
|
static const WCHAR driversW[] = {'\\','d','r','i','v','e','r','s','\\',0};
|
|
static const WCHAR systemrootW[] = {'\\','S','y','s','t','e','m','R','o','o','t','\\',0};
|
|
static const WCHAR postfixW[] = {'.','s','y','s',0};
|
|
static const WCHAR ntprefixW[] = {'\\','?','?','\\',0};
|
|
static const WCHAR ImagePathW[] = {'I','m','a','g','e','P','a','t','h',0};
|
|
static const WCHAR servicesW[] = {'\\','R','e','g','i','s','t','r','y',
|
|
'\\','M','a','c','h','i','n','e',
|
|
'\\','S','y','s','t','e','m',
|
|
'\\','C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t',
|
|
'\\','S','e','r','v','i','c','e','s','\\',0};
|
|
|
|
UNICODE_STRING keypath;
|
|
HMODULE module;
|
|
LPWSTR path = NULL, str;
|
|
DWORD type, size;
|
|
|
|
str = HeapAlloc( GetProcessHeap(), 0, sizeof(servicesW) + strlenW(driver_name)*sizeof(WCHAR) );
|
|
lstrcpyW( str, servicesW );
|
|
lstrcatW( str, driver_name );
|
|
|
|
if (RegOpenKeyW( HKEY_LOCAL_MACHINE, str + 18 /* skip \registry\machine */, &driver_hkey ))
|
|
{
|
|
WINE_ERR( "cannot open key %s, err=%u\n", wine_dbgstr_w(str), GetLastError() );
|
|
HeapFree( GetProcessHeap(), 0, str);
|
|
return FALSE;
|
|
}
|
|
RtlInitUnicodeString( &keypath, str );
|
|
|
|
/* read the executable path from memory */
|
|
size = 0;
|
|
if (!RegQueryValueExW( driver_hkey, ImagePathW, NULL, &type, NULL, &size ))
|
|
{
|
|
str = HeapAlloc( GetProcessHeap(), 0, size );
|
|
if (!RegQueryValueExW( driver_hkey, ImagePathW, NULL, &type, (LPBYTE)str, &size ))
|
|
{
|
|
size = ExpandEnvironmentStringsW(str,NULL,0);
|
|
path = HeapAlloc(GetProcessHeap(),0,size*sizeof(WCHAR));
|
|
ExpandEnvironmentStringsW(str,path,size);
|
|
}
|
|
HeapFree( GetProcessHeap(), 0, str );
|
|
if (!path) return FALSE;
|
|
|
|
if (!strncmpiW( path, systemrootW, 12 ))
|
|
{
|
|
WCHAR buffer[MAX_PATH];
|
|
|
|
GetWindowsDirectoryW(buffer, MAX_PATH);
|
|
|
|
str = HeapAlloc(GetProcessHeap(), 0, (size -11 + strlenW(buffer))
|
|
* sizeof(WCHAR));
|
|
lstrcpyW(str, buffer);
|
|
lstrcatW(str, path + 11);
|
|
HeapFree( GetProcessHeap(), 0, path );
|
|
path = str;
|
|
}
|
|
else if (!strncmpW( path, ntprefixW, 4 ))
|
|
str = path + 4;
|
|
else
|
|
str = path;
|
|
}
|
|
else
|
|
{
|
|
/* default is to use the driver name + ".sys" */
|
|
WCHAR buffer[MAX_PATH];
|
|
GetSystemDirectoryW(buffer, MAX_PATH);
|
|
path = HeapAlloc(GetProcessHeap(),0,
|
|
(strlenW(buffer) + strlenW(driversW) + strlenW(driver_name) + strlenW(postfixW) + 1)
|
|
*sizeof(WCHAR));
|
|
lstrcpyW(path, buffer);
|
|
lstrcatW(path, driversW);
|
|
lstrcatW(path, driver_name);
|
|
lstrcatW(path, postfixW);
|
|
str = path;
|
|
}
|
|
|
|
WINE_TRACE( "loading driver %s\n", wine_dbgstr_w(str) );
|
|
|
|
module = load_driver_module( str );
|
|
HeapFree( GetProcessHeap(), 0, path );
|
|
if (!module) return FALSE;
|
|
|
|
init_driver( module, &keypath );
|
|
return TRUE;
|
|
}
|
|
|
|
static DWORD WINAPI service_handler( DWORD ctrl, DWORD event_type, LPVOID event_data, LPVOID context )
|
|
{
|
|
SERVICE_STATUS status;
|
|
|
|
status.dwServiceType = SERVICE_WIN32;
|
|
status.dwControlsAccepted = SERVICE_ACCEPT_STOP;
|
|
status.dwWin32ExitCode = 0;
|
|
status.dwServiceSpecificExitCode = 0;
|
|
status.dwCheckPoint = 0;
|
|
status.dwWaitHint = 0;
|
|
|
|
switch(ctrl)
|
|
{
|
|
case SERVICE_CONTROL_STOP:
|
|
case SERVICE_CONTROL_SHUTDOWN:
|
|
WINE_TRACE( "shutting down %s\n", wine_dbgstr_w(driver_name) );
|
|
status.dwCurrentState = SERVICE_STOP_PENDING;
|
|
status.dwControlsAccepted = 0;
|
|
SetServiceStatus( service_handle, &status );
|
|
SetEvent( stop_event );
|
|
return NO_ERROR;
|
|
default:
|
|
WINE_FIXME( "got service ctrl %x for %s\n", ctrl, wine_dbgstr_w(driver_name) );
|
|
status.dwCurrentState = SERVICE_RUNNING;
|
|
SetServiceStatus( service_handle, &status );
|
|
return NO_ERROR;
|
|
}
|
|
}
|
|
|
|
static void WINAPI ServiceMain( DWORD argc, LPWSTR *argv )
|
|
{
|
|
SERVICE_STATUS status;
|
|
|
|
WINE_TRACE( "starting service %s\n", wine_dbgstr_w(driver_name) );
|
|
|
|
stop_event = CreateEventW( NULL, TRUE, FALSE, NULL );
|
|
|
|
service_handle = RegisterServiceCtrlHandlerExW( driver_name, service_handler, NULL );
|
|
if (!service_handle)
|
|
return;
|
|
|
|
status.dwServiceType = SERVICE_WIN32;
|
|
status.dwCurrentState = SERVICE_START_PENDING;
|
|
status.dwControlsAccepted = 0;
|
|
status.dwWin32ExitCode = 0;
|
|
status.dwServiceSpecificExitCode = 0;
|
|
status.dwCheckPoint = 0;
|
|
status.dwWaitHint = 10000;
|
|
SetServiceStatus( service_handle, &status );
|
|
|
|
if (load_driver())
|
|
{
|
|
status.dwCurrentState = SERVICE_RUNNING;
|
|
status.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN;
|
|
SetServiceStatus( service_handle, &status );
|
|
|
|
wine_ntoskrnl_main_loop( stop_event );
|
|
}
|
|
else WINE_ERR( "driver %s failed to load\n", wine_dbgstr_w(driver_name) );
|
|
|
|
status.dwCurrentState = SERVICE_STOPPED;
|
|
status.dwControlsAccepted = 0;
|
|
SetServiceStatus( service_handle, &status );
|
|
WINE_TRACE( "service %s stopped\n", wine_dbgstr_w(driver_name) );
|
|
}
|
|
|
|
int wmain( int argc, WCHAR *argv[] )
|
|
{
|
|
SERVICE_TABLE_ENTRYW service_table[2];
|
|
|
|
if (!(driver_name = argv[1]))
|
|
{
|
|
WINE_ERR( "missing device name, winedevice isn't supposed to be run manually\n" );
|
|
return 1;
|
|
}
|
|
|
|
service_table[0].lpServiceName = argv[1];
|
|
service_table[0].lpServiceProc = ServiceMain;
|
|
service_table[1].lpServiceName = NULL;
|
|
service_table[1].lpServiceProc = NULL;
|
|
|
|
StartServiceCtrlDispatcherW( service_table );
|
|
return 0;
|
|
}
|