wine/dlls/kernel/vxd.c
2004-02-25 01:31:17 +00:00

358 lines
11 KiB
C

/*
* Win32 VxD functions
*
* Copyright 1998 Marcus Meissner
* Copyright 1998 Ulrich Weigand
* Copyright 1998 Patrik Stridvall
*
* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "config.h"
#include "wine/port.h"
#include <stdlib.h>
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "winreg.h"
#include "winerror.h"
#include "file.h"
#include "kernel_private.h"
#include "wine/library.h"
#include "wine/unicode.h"
#include "wine/server.h"
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(vxd);
typedef BOOL (WINAPI *DeviceIoProc)(DWORD, LPVOID, DWORD, LPVOID, DWORD, LPDWORD, LPOVERLAPPED);
typedef DWORD (WINAPI *VxDCallProc)(DWORD, CONTEXT86 *);
struct vxd_module
{
dev_t dev;
ino_t ino;
HANDLE handle;
HMODULE module;
DeviceIoProc proc;
};
struct vxdcall_service
{
WCHAR name[12];
DWORD service;
HMODULE module;
VxDCallProc proc;
};
#define MAX_VXD_MODULES 32
static struct vxd_module vxd_modules[MAX_VXD_MODULES];
static struct vxdcall_service vxd_services[] =
{
{ {'v','m','m','.','v','x','d',0}, 0x0001, NULL, NULL },
{ {'v','w','i','n','3','2','.','v','x','d',0}, 0x002a, NULL, NULL }
};
#define NB_VXD_SERVICES (sizeof(vxd_services)/sizeof(vxd_services[0]))
static CRITICAL_SECTION vxd_section;
static CRITICAL_SECTION_DEBUG critsect_debug =
{
0, 0, &vxd_section,
{ &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
0, 0, { 0, (DWORD)(__FILE__ ": vxd_section") }
};
static CRITICAL_SECTION vxd_section = { &critsect_debug, -1, 0, 0, 0, 0 };
/* create a file handle to represent a VxD, by opening a dummy file in the wineserver directory */
static HANDLE open_vxd_handle( LPCWSTR name )
{
const char *dir = wine_get_server_dir();
char *unix_name;
int len1, len2;
HANDLE ret;
len1 = strlen( dir );
len2 = WideCharToMultiByte( CP_UNIXCP, 0, name, -1, NULL, 0, NULL, NULL);
if (!(unix_name = HeapAlloc( GetProcessHeap(), 0, len1 + len2 + 1 )))
{
SetLastError( ERROR_NOT_ENOUGH_MEMORY );
return 0;
}
strcpy( unix_name, dir );
unix_name[len1] = '/';
WideCharToMultiByte( CP_UNIXCP, 0, name, -1, unix_name + len1 + 1, len2, NULL, NULL);
ret = FILE_CreateFile( unix_name, 0, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL,
OPEN_ALWAYS, 0, 0, TRUE, DRIVE_FIXED );
HeapFree( GetProcessHeap(), 0, unix_name );
return ret;
}
/* retrieve the DeviceIoControl function for a Vxd given a file handle */
static DeviceIoProc get_vxd_proc( HANDLE handle )
{
struct stat st;
DeviceIoProc ret = NULL;
int status, i, fd;
status = wine_server_handle_to_fd( handle, 0, &fd, NULL, NULL );
if (status)
{
SetLastError( RtlNtStatusToDosError(status) );
return NULL;
}
if (fstat( fd, &st ) == -1)
{
wine_server_release_fd( handle, fd );
SetLastError( ERROR_INVALID_HANDLE );
return NULL;
}
wine_server_release_fd( handle, fd );
RtlEnterCriticalSection( &vxd_section );
for (i = 0; i < MAX_VXD_MODULES; i++)
{
if (!vxd_modules[i].module) break;
if (vxd_modules[i].dev == st.st_dev && vxd_modules[i].ino == st.st_ino)
{
if (!(ret = vxd_modules[i].proc)) SetLastError( ERROR_INVALID_FUNCTION );
goto done;
}
}
/* FIXME: Here we could go through the directory to find the VxD name and load it. */
/* Let's wait to find out if there are actually apps out there that try to share */
/* VxD handles between processes, before we go to the trouble of implementing it. */
ERR( "handle %p not found in module list, inherited from another process?\n", handle );
done:
RtlLeaveCriticalSection( &vxd_section );
return ret;
}
/* load a VxD and return a file handle to it */
HANDLE VXD_Open( LPCWSTR filenameW, DWORD access, SECURITY_ATTRIBUTES *sa )
{
static const WCHAR dotVxDW[] = {'.','v','x','d',0};
int i;
HANDLE handle;
HMODULE module;
WCHAR *p, name[16];
if (!(GetVersion() & 0x80000000)) /* there are no VxDs on NT */
{
SetLastError( ERROR_INVALID_PARAMETER );
return 0;
}
/* normalize the filename */
if (strlenW( filenameW ) >= sizeof(name)/sizeof(WCHAR) - 4 ||
strchrW( filenameW, '/' ) || strchrW( filenameW, '\\' ))
{
SetLastError( ERROR_FILE_NOT_FOUND );
return 0;
}
strcpyW( name, filenameW );
strlwrW( name );
p = strchrW( name, '.' );
if (!p) strcatW( name, dotVxDW );
else if (strcmpW( p, dotVxDW )) /* existing extension has to be .vxd */
{
SetLastError( ERROR_FILE_NOT_FOUND );
return 0;
}
/* try to load the module first */
if (!(module = LoadLibraryW( name )))
{
FIXME( "Unknown/unsupported VxD %s. Try setting Windows version to 'nt40' or 'win31'.\n",
debugstr_w(name) );
SetLastError( ERROR_FILE_NOT_FOUND );
return 0;
}
/* register the module in the global list if necessary */
RtlEnterCriticalSection( &vxd_section );
for (i = 0; i < MAX_VXD_MODULES; i++)
{
if (vxd_modules[i].module == module)
{
handle = vxd_modules[i].handle;
goto done; /* already registered */
}
if (!vxd_modules[i].module) /* new one, register it */
{
struct stat st;
int fd;
/* get a file handle to the dummy file */
if (!(handle = open_vxd_handle( name )))
{
FreeLibrary( module );
goto done;
}
wine_server_handle_to_fd( handle, 0, &fd, NULL, NULL );
if (fstat( fd, &st ) != -1)
{
vxd_modules[i].dev = st.st_dev;
vxd_modules[i].ino = st.st_ino;
}
vxd_modules[i].module = module;
vxd_modules[i].handle = handle;
vxd_modules[i].proc = (DeviceIoProc)GetProcAddress( module, "DeviceIoControl" );
wine_server_release_fd( handle, fd );
goto done;
}
}
ERR("too many open VxD modules, please report\n" );
CloseHandle( handle );
FreeLibrary( module );
handle = 0;
done:
RtlLeaveCriticalSection( &vxd_section );
if (!DuplicateHandle( GetCurrentProcess(), handle, GetCurrentProcess(), &handle, 0,
(sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle),
DUP_HANDLE_SAME_ACCESS ))
handle = 0;
return handle;
}
/***********************************************************************
* VxDCall0 (KERNEL32.1)
* VxDCall1 (KERNEL32.2)
* VxDCall2 (KERNEL32.3)
* VxDCall3 (KERNEL32.4)
* VxDCall4 (KERNEL32.5)
* VxDCall5 (KERNEL32.6)
* VxDCall6 (KERNEL32.7)
* VxDCall7 (KERNEL32.8)
* VxDCall8 (KERNEL32.9)
*/
void VxDCall( DWORD service, CONTEXT86 *context )
{
int i;
VxDCallProc proc = NULL;
RtlEnterCriticalSection( &vxd_section );
for (i = 0; i < NB_VXD_SERVICES; i++)
{
if (HIWORD(service) != vxd_services[i].service) continue;
if (!vxd_services[i].module) /* need to load it */
{
if ((vxd_services[i].module = LoadLibraryW( vxd_services[i].name )))
vxd_services[i].proc = (VxDCallProc)GetProcAddress( vxd_services[i].module, "VxDCall" );
}
proc = vxd_services[i].proc;
break;
}
RtlLeaveCriticalSection( &vxd_section );
if (proc) context->Eax = proc( service, context );
else
{
FIXME( "Unknown/unimplemented VxD (%08lx)\n", service);
context->Eax = 0xffffffff; /* FIXME */
}
}
/***********************************************************************
* OpenVxDHandle (KERNEL32.@)
*
* This function is supposed to return the corresponding Ring 0
* ("kernel") handle for a Ring 3 handle in Win9x.
* Evidently, Wine will have problems with this. But we try anyway,
* maybe it helps...
*/
HANDLE WINAPI OpenVxDHandle(HANDLE hHandleRing3)
{
FIXME( "(%p), stub! (returning Ring 3 handle instead of Ring 0)\n", hHandleRing3);
return hHandleRing3;
}
/****************************************************************************
* DeviceIoControl (KERNEL32.@)
* This is one of those big ugly nasty procedure which can do
* a million and one things when it comes to devices. It can also be
* used for VxD communication.
*
* A return value of FALSE indicates that something has gone wrong which
* GetLastError can decipher.
*/
BOOL WINAPI DeviceIoControl(HANDLE hDevice, DWORD dwIoControlCode,
LPVOID lpvInBuffer, DWORD cbInBuffer,
LPVOID lpvOutBuffer, DWORD cbOutBuffer,
LPDWORD lpcbBytesReturned,
LPOVERLAPPED lpOverlapped)
{
NTSTATUS status;
TRACE( "(%p,%lx,%p,%ld,%p,%ld,%p,%p)\n",
hDevice,dwIoControlCode,lpvInBuffer,cbInBuffer,
lpvOutBuffer,cbOutBuffer,lpcbBytesReturned,lpOverlapped );
/* Check if this is a user defined control code for a VxD */
if( HIWORD( dwIoControlCode ) == 0 )
{
DeviceIoProc proc = get_vxd_proc( hDevice );
if (proc) return proc( dwIoControlCode, lpvInBuffer, cbInBuffer,
lpvOutBuffer, cbOutBuffer, lpcbBytesReturned, lpOverlapped );
return FALSE;
}
/* Not a VxD, let ntdll handle it */
if (lpOverlapped)
{
status = NtDeviceIoControlFile(hDevice, lpOverlapped->hEvent,
NULL, NULL, (PIO_STATUS_BLOCK)lpOverlapped,
dwIoControlCode, lpvInBuffer, cbInBuffer,
lpvOutBuffer, cbOutBuffer);
if (lpcbBytesReturned) *lpcbBytesReturned = lpOverlapped->InternalHigh;
}
else
{
IO_STATUS_BLOCK iosb;
status = NtDeviceIoControlFile(hDevice, NULL, NULL, NULL, &iosb,
dwIoControlCode, lpvInBuffer, cbInBuffer,
lpvOutBuffer, cbOutBuffer);
if (lpcbBytesReturned) *lpcbBytesReturned = iosb.Information;
}
if (status) SetLastError( RtlNtStatusToDosError(status) );
return !status;
}