dlls/krnl386.exe16/vxd.c

   1 /*
   2  * Win32 VxD functions
   3  *
   4  * Copyright 1998 Marcus Meissner
   5  * Copyright 1998 Ulrich Weigand
   6  * Copyright 1998 Patrik Stridvall
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include "config.h"
  24 #include "wine/port.h"
  25
  26 #include <stdlib.h>
  27 #ifdef HAVE_UNISTD_H
  28 # include <unistd.h>
  29 #endif
  30 #include <sys/types.h>
  31 #ifdef HAVE_SYS_STAT_H
  32 # include <sys/stat.h>
  33 #endif
  34 #include <string.h>
  35 #include <stdarg.h>
  36
  37 #include "windef.h"
  38 #include "winbase.h"
  39 #include "winerror.h"
  40 #include "winternl.h"
  41 #include "winioctl.h"
  42 #include "kernel16_private.h"
  43 #include "wine/library.h"
  44 #include "wine/unicode.h"
  45 #include "wine/server.h"
  46 #include "wine/debug.h"
  47
  48 WINE_DEFAULT_DEBUG_CHANNEL(vxd);
  49
  50 typedef DWORD (WINAPI *VxDCallProc)(DWORD, CONTEXT86 *);
  51 typedef BOOL (WINAPI *DeviceIoProc)(DWORD, LPVOID, DWORD, LPVOID, DWORD, LPDWORD, LPOVERLAPPED);
  52
  53 struct vxd_module
  54 {
  55     LARGE_INTEGER index;
  56     HANDLE        handle;
  57     HMODULE       module;
  58     DeviceIoProc  proc;
  59 };
  60
  61 struct vxdcall_service
  62 {
  63     WCHAR       name[12];
  64     DWORD       service;
  65     HMODULE     module;
  66     VxDCallProc proc;
  67 };
  68
  69 #define MAX_VXD_MODULES 32
  70
  71 static struct vxd_module vxd_modules[MAX_VXD_MODULES];
  72
  73 static struct vxdcall_service vxd_services[] =
  74 {
  75     { {'v','m','m','.','v','x','d',0},             0x0001, NULL, NULL },
  76     { {'v','w','i','n','3','2','.','v','x','d',0}, 0x002a, NULL, NULL }
  77 };
  78
  79 #define NB_VXD_SERVICES  (sizeof(vxd_services)/sizeof(vxd_services[0]))
  80
  81 static CRITICAL_SECTION vxd_section;
  82 static CRITICAL_SECTION_DEBUG critsect_debug =
  83 {
  84     0, 0, &vxd_section,
  85     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
  86       0, 0, { (DWORD_PTR)(__FILE__ ": vxd_section") }
  87 };
  88 static CRITICAL_SECTION vxd_section = { &critsect_debug, -1, 0, 0, 0, 0 };
  89
  90
  91 /* create a file handle to represent a VxD, by opening a dummy file in the wineserver directory */
  92 static HANDLE open_vxd_handle( LPCWSTR name )
  93 {
  94     static const WCHAR prefixW[] = {'\\','?','?','\\','u','n','i','x'};
  95     const char *dir = wine_get_server_dir();
  96     int len;
  97     HANDLE ret;
  98     NTSTATUS status;
  99     OBJECT_ATTRIBUTES attr;
 100     UNICODE_STRING nameW;
 101     IO_STATUS_BLOCK io;
 102
 103     len = MultiByteToWideChar( CP_UNIXCP, 0, dir, -1, NULL, 0 );
 104     nameW.Length = sizeof(prefixW) + (len + strlenW( name )) * sizeof(WCHAR);
 105     nameW.MaximumLength = nameW.Length + sizeof(WCHAR);
 106     if (!(nameW.Buffer = HeapAlloc( GetProcessHeap(), 0, nameW.MaximumLength )))
 107     {
 108         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
 109         return 0;
 110     }
 111     memcpy( nameW.Buffer, prefixW, sizeof(prefixW) );
 112     MultiByteToWideChar( CP_UNIXCP, 0, dir, -1, nameW.Buffer + sizeof(prefixW)/sizeof(WCHAR), len );
 113     len += sizeof(prefixW) / sizeof(WCHAR);
 114     nameW.Buffer[len-1] = '/';
 115     strcpyW( nameW.Buffer + len, name );
 116
 117     attr.Length = sizeof(attr);
 118     attr.RootDirectory = 0;
 119     attr.Attributes = 0;
 120     attr.ObjectName = &nameW;
 121     attr.SecurityDescriptor = NULL;
 122     attr.SecurityQualityOfService = NULL;
 123
 124     status = NtCreateFile( &ret, 0, &attr, &io, NULL, 0,
 125                            FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_OPEN_IF,
 126                            FILE_SYNCHRONOUS_IO_ALERT, NULL, 0 );
 127     if (status)
 128     {
 129         ret = 0;
 130         SetLastError( RtlNtStatusToDosError(status) );
 131     }
 132     RtlFreeUnicodeString( &nameW );
 133     return ret;
 134 }
 135
 136 /* retrieve the DeviceIoControl function for a Vxd given a file handle */
 137 DeviceIoProc __wine_vxd_get_proc( HANDLE handle )
 138 {
 139     DeviceIoProc ret = NULL;
 140     int status, i;
 141     IO_STATUS_BLOCK io;
 142     FILE_INTERNAL_INFORMATION info;
 143
 144     status = NtQueryInformationFile( handle, &io, &info, sizeof(info), FileInternalInformation );
 145     if (status)
 146     {
 147         SetLastError( RtlNtStatusToDosError(status) );
 148         return NULL;
 149     }
 150
 151     RtlEnterCriticalSection( &vxd_section );
 152
 153     for (i = 0; i < MAX_VXD_MODULES; i++)
 154     {
 155         if (!vxd_modules[i].module) break;
 156         if (vxd_modules[i].index.QuadPart == info.IndexNumber.QuadPart)
 157         {
 158             if (!(ret = vxd_modules[i].proc)) SetLastError( ERROR_INVALID_FUNCTION );
 159             goto done;
 160         }
 161     }
 162     /* FIXME: Here we could go through the directory to find the VxD name and load it. */
 163     /* Let's wait to find out if there are actually apps out there that try to share   */
 164     /* VxD handles between processes, before we go to the trouble of implementing it.  */
 165     ERR( "handle %p not found in module list, inherited from another process?\n", handle );
 166
 167 done:
 168     RtlLeaveCriticalSection( &vxd_section );
 169     return ret;
 170 }
 171
 172
 173 /* load a VxD and return a file handle to it */
 174 HANDLE __wine_vxd_open( LPCWSTR filenameW, DWORD access, SECURITY_ATTRIBUTES *sa )
 175 {
 176     static const WCHAR dotVxDW[] = {'.','v','x','d',0};
 177     int i;
 178     HANDLE handle;
 179     HMODULE module;
 180     WCHAR *p, name[16];
 181
 182     /* normalize the filename */
 183
 184     if (strlenW( filenameW ) >= sizeof(name)/sizeof(WCHAR) - 4 ||
 185         strchrW( filenameW, '/' ) || strchrW( filenameW, '\\' ))
 186     {
 187         SetLastError( ERROR_FILE_NOT_FOUND );
 188         return 0;
 189     }
 190     strcpyW( name, filenameW );
 191     strlwrW( name );
 192     p = strchrW( name, '.' );
 193     if (!p) strcatW( name, dotVxDW );
 194     else if (strcmpiW( p, dotVxDW ))  /* existing extension has to be .vxd */
 195     {
 196         SetLastError( ERROR_FILE_NOT_FOUND );
 197         return 0;
 198     }
 199
 200     /* try to load the module first */
 201
 202     if (!(module = LoadLibraryW( name )))
 203     {
 204         FIXME( "Unknown/unsupported VxD %s. Try setting Windows version to 'nt40' or 'win31'.\n",
 205                debugstr_w(name) );
 206         SetLastError( ERROR_FILE_NOT_FOUND );
 207         return 0;
 208     }
 209
 210     /* register the module in the global list if necessary */
 211
 212     RtlEnterCriticalSection( &vxd_section );
 213
 214     for (i = 0; i < MAX_VXD_MODULES; i++)
 215     {
 216         if (vxd_modules[i].module == module)
 217         {
 218             handle = vxd_modules[i].handle;
 219             goto done;  /* already registered */
 220         }
 221         if (!vxd_modules[i].module)  /* new one, register it */
 222         {
 223             IO_STATUS_BLOCK io;
 224             FILE_INTERNAL_INFORMATION info;
 225
 226             /* get a file handle to the dummy file */
 227             if (!(handle = open_vxd_handle( name )))
 228             {
 229                 FreeLibrary( module );
 230                 goto done;
 231             }
 232             if (!NtQueryInformationFile( handle, &io, &info, sizeof(info), FileInternalInformation ))
 233                 vxd_modules[i].index = info.IndexNumber;
 234
 235             vxd_modules[i].module = module;
 236             vxd_modules[i].handle = handle;
 237             vxd_modules[i].proc = (DeviceIoProc)GetProcAddress( module, "DeviceIoControl" );
 238             goto done;
 239         }
 240     }
 241
 242     ERR("too many open VxD modules, please report\n" );
 243     FreeLibrary( module );
 244     handle = 0;
 245
 246 done:
 247     RtlLeaveCriticalSection( &vxd_section );
 248     if (!DuplicateHandle( GetCurrentProcess(), handle, GetCurrentProcess(), &handle, 0,
 249                           (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle),
 250                           DUP_HANDLE_SAME_ACCESS ))
 251         handle = 0;
 252     return handle;
 253 }
 254
 255
 256 /***********************************************************************
 257  *              VxDCall0 (KERNEL32.1)
 258  *              VxDCall1 (KERNEL32.2)
 259  *              VxDCall2 (KERNEL32.3)
 260  *              VxDCall3 (KERNEL32.4)
 261  *              VxDCall4 (KERNEL32.5)
 262  *              VxDCall5 (KERNEL32.6)
 263  *              VxDCall6 (KERNEL32.7)
 264  *              VxDCall7 (KERNEL32.8)
 265  *              VxDCall8 (KERNEL32.9)
 266  */
 267 void WINAPI __regs_VxDCall( DWORD service, CONTEXT86 *context )
 268 {
 269     unsigned int i;
 270     VxDCallProc proc = NULL;
 271
 272     RtlEnterCriticalSection( &vxd_section );
 273     for (i = 0; i < NB_VXD_SERVICES; i++)
 274     {
 275         if (HIWORD(service) != vxd_services[i].service) continue;
 276         if (!vxd_services[i].module)  /* need to load it */
 277         {
 278             if ((vxd_services[i].module = LoadLibraryW( vxd_services[i].name )))
 279                 vxd_services[i].proc = (VxDCallProc)GetProcAddress( vxd_services[i].module, "VxDCall" );
 280         }
 281         proc = vxd_services[i].proc;
 282         break;
 283     }
 284     RtlLeaveCriticalSection( &vxd_section );
 285
 286     if (proc) context->Eax = proc( service, context );
 287     else
 288     {
 289         FIXME( "Unknown/unimplemented VxD (%08x)\n", service);
 290         context->Eax = 0xffffffff; /* FIXME */
 291     }
 292 }
 293 #ifdef DEFINE_REGS_ENTRYPOINT
 294 DEFINE_REGS_ENTRYPOINT( VxDCall, 1 )
 295 #endif