win32/device.c

   1 /*
   2  * Win32 device 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 #include <string.h>
  32 #include <stdarg.h>
  33 #include <time.h>
  34
  35 #include "windef.h"
  36 #include "winbase.h"
  37 #include "winreg.h"
  38 #include "winerror.h"
  39 #include "file.h"
  40 #include "winioctl.h"
  41 #include "winnt.h"
  42 #include "msdos.h"
  43 #include "miscemu.h"
  44 #include "stackframe.h"
  45 #include "wine/server.h"
  46 #include "wine/debug.h"
  47
  48 /* int 13 stuff */
  49 #ifdef HAVE_SYS_IOCTL_H
  50 # include <sys/ioctl.h>
  51 #endif
  52 #include <fcntl.h>
  53 #ifdef linux
  54 # include <linux/fd.h>
  55 #endif
  56 #include "drive.h"
  57
  58 WINE_DEFAULT_DEBUG_CHANNEL(file);
  59
  60
  61 static BOOL DeviceIo_VTDAPI(DWORD dwIoControlCode,
  62                               LPVOID lpvInBuffer, DWORD cbInBuffer,
  63                               LPVOID lpvOutBuffer, DWORD cbOutBuffer,
  64                               LPDWORD lpcbBytesReturned,
  65                               LPOVERLAPPED lpOverlapped);
  66 static BOOL DeviceIo_MONODEBG(DWORD dwIoControlCode,
  67                               LPVOID lpvInBuffer, DWORD cbInBuffer,
  68                               LPVOID lpvOutBuffer, DWORD cbOutBuffer,
  69                               LPDWORD lpcbBytesReturned,
  70                               LPOVERLAPPED lpOverlapped);
  71 static BOOL DeviceIo_MMDEVLDR(DWORD dwIoControlCode,
  72                               LPVOID lpvInBuffer, DWORD cbInBuffer,
  73                               LPVOID lpvOutBuffer, DWORD cbOutBuffer,
  74                               LPDWORD lpcbBytesReturned,
  75                               LPOVERLAPPED lpOverlapped);
  76
  77 static DWORD VxDCall_VMM( DWORD service, CONTEXT86 *context );
  78
  79 static BOOL DeviceIo_IFSMgr(DWORD dwIoControlCode,
  80                               LPVOID lpvInBuffer, DWORD cbInBuffer,
  81                               LPVOID lpvOutBuffer, DWORD cbOutBuffer,
  82                               LPDWORD lpcbBytesReturned,
  83                               LPOVERLAPPED lpOverlapped);
  84
  85 static BOOL DeviceIo_VCD(DWORD dwIoControlCode,
  86                               LPVOID lpvInBuffer, DWORD cbInBuffer,
  87                               LPVOID lpvOutBuffer, DWORD cbOutBuffer,
  88                               LPDWORD lpcbBytesReturned,
  89                               LPOVERLAPPED lpOverlapped);
  90
  91 static DWORD VxDCall_VWin32( DWORD service, CONTEXT86 *context );
  92
  93 static BOOL DeviceIo_VWin32(DWORD dwIoControlCode,
  94                               LPVOID lpvInBuffer, DWORD cbInBuffer,
  95                               LPVOID lpvOutBuffer, DWORD cbOutBuffer,
  96                               LPDWORD lpcbBytesReturned,
  97                               LPOVERLAPPED lpOverlapped);
  98
  99 static BOOL DeviceIo_PCCARD (DWORD dwIoControlCode,
 100                               LPVOID lpvInBuffer, DWORD cbInBuffer,
 101                               LPVOID lpvOutBuffer, DWORD cbOutBuffer,
 102                               LPDWORD lpcbBytesReturned,
 103                               LPOVERLAPPED lpOverlapped);
 104
 105 static BOOL DeviceIo_HASP (DWORD dwIoControlCode,
 106                               LPVOID lpvInBuffer, DWORD cbInBuffer,
 107                               LPVOID lpvOutBuffer, DWORD cbOutBuffer,
 108                               LPDWORD lpcbBytesReturned,
 109                               LPOVERLAPPED lpOverlapped);
 110 /*
 111  * VxD names are taken from the Win95 DDK
 112  */
 113
 114 struct VxDInfo
 115 {
 116     LPCSTR  name;
 117     WORD    id;
 118     DWORD (*vxdcall)(DWORD, CONTEXT86 *);
 119     BOOL  (*deviceio)(DWORD, LPVOID, DWORD,
 120                         LPVOID, DWORD, LPDWORD, LPOVERLAPPED);
 121 };
 122
 123 static const struct VxDInfo VxDList[] =
 124 {
 125     /* Standard VxD IDs */
 126     { "VMM",      0x0001, VxDCall_VMM, NULL },
 127     { "DEBUG",    0x0002, NULL, NULL },
 128     { "VPICD",    0x0003, NULL, NULL },
 129     { "VDMAD",    0x0004, NULL, NULL },
 130     { "VTD",      0x0005, NULL, NULL },
 131     { "V86MMGR",  0x0006, NULL, NULL },
 132     { "PAGESWAP", 0x0007, NULL, NULL },
 133     { "PARITY",   0x0008, NULL, NULL },
 134     { "REBOOT",   0x0009, NULL, NULL },
 135     { "VDD",      0x000A, NULL, NULL },
 136     { "VSD",      0x000B, NULL, NULL },
 137     { "VMD",      0x000C, NULL, NULL },
 138     { "VKD",      0x000D, NULL, NULL },
 139     { "VCD",      0x000E, NULL, DeviceIo_VCD },
 140     { "VPD",      0x000F, NULL, NULL },
 141     { "BLOCKDEV", 0x0010, NULL, NULL },
 142     { "VMCPD",    0x0011, NULL, NULL },
 143     { "EBIOS",    0x0012, NULL, NULL },
 144     { "BIOSXLAT", 0x0013, NULL, NULL },
 145     { "VNETBIOS", 0x0014, NULL, NULL },
 146     { "DOSMGR",   0x0015, NULL, NULL },
 147     { "WINLOAD",  0x0016, NULL, NULL },
 148     { "SHELL",    0x0017, NULL, NULL },
 149     { "VMPOLL",   0x0018, NULL, NULL },
 150     { "VPROD",    0x0019, NULL, NULL },
 151     { "DOSNET",   0x001A, NULL, NULL },
 152     { "VFD",      0x001B, NULL, NULL },
 153     { "VDD2",     0x001C, NULL, NULL },
 154     { "WINDEBUG", 0x001D, NULL, NULL },
 155     { "TSRLOAD",  0x001E, NULL, NULL },
 156     { "BIOSHOOK", 0x001F, NULL, NULL },
 157     { "INT13",    0x0020, NULL, NULL },
 158     { "PAGEFILE", 0x0021, NULL, NULL },
 159     { "SCSI",     0x0022, NULL, NULL },
 160     { "MCA_POS",  0x0023, NULL, NULL },
 161     { "SCSIFD",   0x0024, NULL, NULL },
 162     { "VPEND",    0x0025, NULL, NULL },
 163     { "VPOWERD",  0x0026, NULL, NULL },
 164     { "VXDLDR",   0x0027, NULL, NULL },
 165     { "NDIS",     0x0028, NULL, NULL },
 166     { "BIOS_EXT", 0x0029, NULL, NULL },
 167     { "VWIN32",   0x002A, VxDCall_VWin32, DeviceIo_VWin32 },
 168     { "VCOMM",    0x002B, NULL, NULL },
 169     { "SPOOLER",  0x002C, NULL, NULL },
 170     { "WIN32S",   0x002D, NULL, NULL },
 171     { "DEBUGCMD", 0x002E, NULL, NULL },
 172
 173     { "VNB",      0x0031, NULL, NULL },
 174     { "SERVER",   0x0032, NULL, NULL },
 175     { "CONFIGMG", 0x0033, NULL, NULL },
 176     { "DWCFGMG",  0x0034, NULL, NULL },
 177     { "SCSIPORT", 0x0035, NULL, NULL },
 178     { "VFBACKUP", 0x0036, NULL, NULL },
 179     { "ENABLE",   0x0037, NULL, NULL },
 180     { "VCOND",    0x0038, NULL, NULL },
 181
 182     { "EFAX",     0x003A, NULL, NULL },
 183     { "DSVXD",    0x003B, NULL, NULL },
 184     { "ISAPNP",   0x003C, NULL, NULL },
 185     { "BIOS",     0x003D, NULL, NULL },
 186     { "WINSOCK",  0x003E, NULL, NULL },
 187     { "WSOCK",    0x003E, NULL, NULL },
 188     { "WSIPX",    0x003F, NULL, NULL },
 189     { "IFSMgr",   0x0040, NULL, DeviceIo_IFSMgr },
 190     { "VCDFSD",   0x0041, NULL, NULL },
 191     { "MRCI2",    0x0042, NULL, NULL },
 192     { "PCI",      0x0043, NULL, NULL },
 193     { "PELOADER", 0x0044, NULL, NULL },
 194     { "EISA",     0x0045, NULL, NULL },
 195     { "DRAGCLI",  0x0046, NULL, NULL },
 196     { "DRAGSRV",  0x0047, NULL, NULL },
 197     { "PERF",     0x0048, NULL, NULL },
 198     { "AWREDIR",  0x0049, NULL, NULL },
 199
 200     /* Far East support */
 201     { "ETEN",     0x0060, NULL, NULL },
 202     { "CHBIOS",   0x0061, NULL, NULL },
 203     { "VMSGD",    0x0062, NULL, NULL },
 204     { "VPPID",    0x0063, NULL, NULL },
 205     { "VIME",     0x0064, NULL, NULL },
 206     { "VHBIOSD",  0x0065, NULL, NULL },
 207
 208     /* Multimedia OEM IDs */
 209     { "VTDAPI",   0x0442, NULL, DeviceIo_VTDAPI },
 210     { "MMDEVLDR", 0x044A, NULL, DeviceIo_MMDEVLDR },
 211
 212     /* Network Device IDs */
 213     { "VNetSup",  0x0480, NULL, NULL },
 214     { "VRedir",   0x0481, NULL, NULL },
 215     { "VBrowse",  0x0482, NULL, NULL },
 216     { "VSHARE",   0x0483, NULL, NULL },
 217     { "IFSMgr",   0x0484, NULL, NULL },
 218     { "MEMPROBE", 0x0485, NULL, NULL },
 219     { "VFAT",     0x0486, NULL, NULL },
 220     { "NWLINK",   0x0487, NULL, NULL },
 221     { "VNWLINK",  0x0487, NULL, NULL },
 222     { "NWSUP",    0x0487, NULL, NULL },
 223     { "VTDI",     0x0488, NULL, NULL },
 224     { "VIP",      0x0489, NULL, NULL },
 225     { "VTCP",     0x048A, NULL, NULL },
 226     { "VCache",   0x048B, NULL, NULL },
 227     { "VUDP",     0x048C, NULL, NULL },
 228     { "VAsync",   0x048D, NULL, NULL },
 229     { "NWREDIR",  0x048E, NULL, NULL },
 230     { "STAT80",   0x048F, NULL, NULL },
 231     { "SCSIPORT", 0x0490, NULL, NULL },
 232     { "FILESEC",  0x0491, NULL, NULL },
 233     { "NWSERVER", 0x0492, NULL, NULL },
 234     { "SECPROV",  0x0493, NULL, NULL },
 235     { "NSCL",     0x0494, NULL, NULL },
 236     { "WSTCP",    0x0495, NULL, NULL },
 237     { "NDIS2SUP", 0x0496, NULL, NULL },
 238     { "MSODISUP", 0x0497, NULL, NULL },
 239     { "Splitter", 0x0498, NULL, NULL },
 240     { "PPP",      0x0499, NULL, NULL },
 241     { "VDHCP",    0x049A, NULL, NULL },
 242     { "VNBT",     0x049B, NULL, NULL },
 243     { "LOGGER",   0x049D, NULL, NULL },
 244     { "EFILTER",  0x049E, NULL, NULL },
 245     { "FFILTER",  0x049F, NULL, NULL },
 246     { "TFILTER",  0x04A0, NULL, NULL },
 247     { "AFILTER",  0x04A1, NULL, NULL },
 248     { "IRLAMP",   0x04A2, NULL, NULL },
 249
 250     { "PCCARD",   0x097C, NULL, DeviceIo_PCCARD },
 251     { "HASP95",   0x3721, NULL, DeviceIo_HASP },
 252
 253     /* WINE additions, ids unknown */
 254     { "MONODEBG.VXD", 0x4242, NULL, DeviceIo_MONODEBG },
 255
 256     { NULL,       0,      NULL, NULL }
 257 };
 258
 259 /*
 260  * VMM VxDCall service names are (mostly) taken from Stan Mitchell's
 261  * "Inside the Windows 95 File System"
 262  */
 263
 264 #define N_VMM_SERVICE 41
 265
 266 LPCSTR VMM_Service_Name[N_VMM_SERVICE] =
 267 {
 268     "PageReserve",            /* 0x0000 */
 269     "PageCommit",             /* 0x0001 */
 270     "PageDecommit",           /* 0x0002 */
 271     "PagerRegister",          /* 0x0003 */
 272     "PagerQuery",             /* 0x0004 */
 273     "HeapAllocate",           /* 0x0005 */
 274     "ContextCreate",          /* 0x0006 */
 275     "ContextDestroy",         /* 0x0007 */
 276     "PageAttach",             /* 0x0008 */
 277     "PageFlush",              /* 0x0009 */
 278     "PageFree",               /* 0x000A */
 279     "ContextSwitch",          /* 0x000B */
 280     "HeapReAllocate",         /* 0x000C */
 281     "PageModifyPermissions",  /* 0x000D */
 282     "PageQuery",              /* 0x000E */
 283     "GetCurrentContext",      /* 0x000F */
 284     "HeapFree",               /* 0x0010 */
 285     "RegOpenKey",             /* 0x0011 */
 286     "RegCreateKey",           /* 0x0012 */
 287     "RegCloseKey",            /* 0x0013 */
 288     "RegDeleteKey",           /* 0x0014 */
 289     "RegSetValue",            /* 0x0015 */
 290     "RegDeleteValue",         /* 0x0016 */
 291     "RegQueryValue",          /* 0x0017 */
 292     "RegEnumKey",             /* 0x0018 */
 293     "RegEnumValue",           /* 0x0019 */
 294     "RegQueryValueEx",        /* 0x001A */
 295     "RegSetValueEx",          /* 0x001B */
 296     "RegFlushKey",            /* 0x001C */
 297     "RegQueryInfoKey",        /* 0x001D */
 298     "GetDemandPageInfo",      /* 0x001E */
 299     "BlockOnID",              /* 0x001F */
 300     "SignalID",               /* 0x0020 */
 301     "RegLoadKey",             /* 0x0021 */
 302     "RegUnLoadKey",           /* 0x0022 */
 303     "RegSaveKey",             /* 0x0023 */
 304     "RegRemapPreDefKey",      /* 0x0024 */
 305     "PageChangePager",        /* 0x0025 */
 306     "RegQueryMultipleValues", /* 0x0026 */
 307     "RegReplaceKey",          /* 0x0027 */
 308     "<KERNEL32.101>"          /* 0x0028 -- What does this do??? */
 309 };
 310
 311 /* PageReserve arena values */
 312 #define PR_PRIVATE  0x80000400  /* anywhere in private arena */
 313 #define PR_SHARED   0x80060000  /* anywhere in shared arena */
 314 #define PR_SYSTEM   0x80080000  /* anywhere in system arena */
 315
 316 /* PageReserve flags */
 317 #define PR_FIXED    0x00000008  /* don't move during PageReAllocate */
 318 #define PR_4MEG     0x00000001  /* allocate on 4mb boundary */
 319 #define PR_STATIC   0x00000010  /* see PageReserve documentation */
 320
 321 /* PageCommit default pager handle values */
 322 #define PD_ZEROINIT 0x00000001  /* swappable zero-initialized pages */
 323 #define PD_NOINIT   0x00000002  /* swappable uninitialized pages */
 324 #define PD_FIXEDZERO    0x00000003  /* fixed zero-initialized pages */
 325 #define PD_FIXED    0x00000004  /* fixed uninitialized pages */
 326
 327 /* PageCommit flags */
 328 #define PC_FIXED    0x00000008  /* pages are permanently locked */
 329 #define PC_LOCKED   0x00000080  /* pages are made present and locked */
 330 #define PC_LOCKEDIFDP   0x00000100  /* pages are locked if swap via DOS */
 331 #define PC_WRITEABLE    0x00020000  /* make the pages writeable */
 332 #define PC_USER     0x00040000  /* make the pages ring 3 accessible */
 333 #define PC_INCR     0x40000000  /* increment "pagerdata" each page */
 334 #define PC_PRESENT  0x80000000  /* make pages initially present */
 335 #define PC_STATIC   0x20000000  /* allow commit in PR_STATIC object */
 336 #define PC_DIRTY    0x08000000  /* make pages initially dirty */
 337 #define PC_CACHEDIS 0x00100000  /* Allocate uncached pages - new for WDM */
 338 #define PC_CACHEWT  0x00080000  /* Allocate write through cache pages - new for WDM */
 339 #define PC_PAGEFLUSH 0x00008000 /* Touch device mapped pages on alloc - new for WDM */
 340
 341 /* PageCommitContig additional flags */
 342 #define PCC_ZEROINIT    0x00000001  /* zero-initialize new pages */
 343 #define PCC_NOLIN   0x10000000  /* don't map to any linear address */
 344
 345
 346
 347 HANDLE DEVICE_Open( LPCSTR filename, DWORD access, LPSECURITY_ATTRIBUTES sa )
 348 {
 349     const struct VxDInfo *info;
 350
 351     for (info = VxDList; info->name; info++)
 352         if (!strncasecmp( info->name, filename, strlen(info->name) ))
 353             return FILE_CreateDevice( info->id | 0x10000, access, sa );
 354
 355     FIXME( "Unknown/unsupported VxD %s. Try setting Windows version to 'nt40' or 'win31'.\n",
 356            filename);
 357     SetLastError( ERROR_FILE_NOT_FOUND );
 358     return 0;
 359 }
 360
 361 static DWORD DEVICE_GetClientID( HANDLE handle )
 362 {
 363     DWORD       ret = 0;
 364     SERVER_START_REQ( get_file_info )
 365     {
 366         req->handle = handle;
 367         if (!wine_server_call( req ) && (reply->type == FILE_TYPE_UNKNOWN))
 368             ret = reply->attr;
 369     }
 370     SERVER_END_REQ;
 371     return ret;
 372 }
 373
 374 static const struct VxDInfo *DEVICE_GetInfo( DWORD clientID )
 375 {
 376     const struct VxDInfo *info = NULL;
 377
 378     if (clientID & 0x10000)
 379     {
 380         for (info = VxDList; info->name; info++)
 381             if (info->id == LOWORD(clientID)) break;
 382     }
 383     return info;
 384 }
 385
 386 /****************************************************************************
 387  *              DeviceIoControl (KERNEL32.@)
 388  * This is one of those big ugly nasty procedure which can do
 389  * a million and one things when it comes to devices. It can also be
 390  * used for VxD communication.
 391  *
 392  * A return value of FALSE indicates that something has gone wrong which
 393  * GetLastError can decipher.
 394  */
 395 BOOL WINAPI DeviceIoControl(HANDLE hDevice, DWORD dwIoControlCode,
 396                               LPVOID lpvInBuffer, DWORD cbInBuffer,
 397                               LPVOID lpvOutBuffer, DWORD cbOutBuffer,
 398                               LPDWORD lpcbBytesReturned,
 399                               LPOVERLAPPED lpOverlapped)
 400 {
 401         DWORD clientID;
 402
 403         TRACE( "(%d,%ld,%p,%ld,%p,%ld,%p,%p)\n",
 404                hDevice,dwIoControlCode,lpvInBuffer,cbInBuffer,
 405                lpvOutBuffer,cbOutBuffer,lpcbBytesReturned,lpOverlapped  );
 406
 407         if (!(clientID = DEVICE_GetClientID( hDevice )))
 408         {
 409                 SetLastError( ERROR_INVALID_PARAMETER );
 410                 return FALSE;
 411         }
 412
 413         /* Check if this is a user defined control code for a VxD */
 414         if( HIWORD( dwIoControlCode ) == 0 )
 415         {
 416                 const struct VxDInfo *info;
 417                 if (!(info = DEVICE_GetInfo( clientID )))
 418                 {
 419                         FIXME( "No device found for id %lx\n", clientID);
 420                 }
 421                 else if ( info->deviceio )
 422                 {
 423                         return info->deviceio( dwIoControlCode,
 424                                         lpvInBuffer, cbInBuffer,
 425                                         lpvOutBuffer, cbOutBuffer,
 426                                         lpcbBytesReturned, lpOverlapped );
 427                 }
 428                 else
 429                 {
 430                         FIXME( "Unimplemented control %ld for VxD device %s\n",
 431                                dwIoControlCode, info->name ? info->name : "???" );
 432                         /* FIXME: this is for invalid calls on W98SE,
 433                          * but maybe we should use ERROR_CALL_NOT_IMPLEMENTED
 434                          * instead ? */
 435                         SetLastError( ERROR_INVALID_FUNCTION );
 436                 }
 437         }
 438         else
 439         {
 440                 char str[3];
 441
 442                 strcpy(str,  "A:");
 443                 str[0] += LOBYTE(clientID);
 444                 if (GetDriveTypeA(str) == DRIVE_CDROM)
 445                     return CDROM_DeviceIoControl(clientID, hDevice, dwIoControlCode, lpvInBuffer, cbInBuffer,
 446                                                  lpvOutBuffer, cbOutBuffer, lpcbBytesReturned,
 447                                                  lpOverlapped);
 448                 else switch( dwIoControlCode )
 449                 {
 450                 case FSCTL_DELETE_REPARSE_POINT:
 451                 case FSCTL_DISMOUNT_VOLUME:
 452                 case FSCTL_GET_COMPRESSION:
 453                 case FSCTL_GET_REPARSE_POINT:
 454                 case FSCTL_LOCK_VOLUME:
 455                 case FSCTL_QUERY_ALLOCATED_RANGES:
 456                 case FSCTL_SET_COMPRESSION:
 457                 case FSCTL_SET_REPARSE_POINT:
 458                 case FSCTL_SET_SPARSE:
 459                 case FSCTL_SET_ZERO_DATA:
 460                 case FSCTL_UNLOCK_VOLUME:
 461                 case IOCTL_DISK_CHECK_VERIFY:
 462                 case IOCTL_DISK_EJECT_MEDIA:
 463                 case IOCTL_DISK_FORMAT_TRACKS:
 464                 case IOCTL_DISK_GET_DRIVE_GEOMETRY:
 465                 case IOCTL_DISK_GET_DRIVE_LAYOUT:
 466                 case IOCTL_DISK_GET_MEDIA_TYPES:
 467                 case IOCTL_DISK_GET_PARTITION_INFO:
 468                 case IOCTL_DISK_LOAD_MEDIA:
 469                 case IOCTL_DISK_MEDIA_REMOVAL:
 470                 case IOCTL_DISK_PERFORMANCE:
 471                 case IOCTL_DISK_REASSIGN_BLOCKS:
 472                 case IOCTL_DISK_SET_DRIVE_LAYOUT:
 473                 case IOCTL_DISK_SET_PARTITION_INFO:
 474                 case IOCTL_DISK_VERIFY:
 475                 case IOCTL_SERIAL_LSRMST_INSERT:
 476                 case IOCTL_STORAGE_CHECK_VERIFY:
 477                 case IOCTL_STORAGE_EJECT_MEDIA:
 478                 case IOCTL_STORAGE_GET_MEDIA_TYPES:
 479                 case IOCTL_STORAGE_LOAD_MEDIA:
 480                 case IOCTL_STORAGE_MEDIA_REMOVAL:
 481                         FIXME( "unimplemented dwIoControlCode=%08lx\n", dwIoControlCode);
 482                         SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 483                         return FALSE;
 484                         break;
 485                 default:
 486                         FIXME( "ignored dwIoControlCode=%08lx\n",dwIoControlCode);
 487                         SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 488                         return FALSE;
 489                         break;
 490                 }
 491         }
 492         return FALSE;
 493 }
 494
 495 /***********************************************************************
 496  *           DeviceIo_VTDAPI
 497  */
 498 static BOOL DeviceIo_VTDAPI(DWORD dwIoControlCode, LPVOID lpvInBuffer, DWORD cbInBuffer,
 499                               LPVOID lpvOutBuffer, DWORD cbOutBuffer,
 500                               LPDWORD lpcbBytesReturned,
 501                               LPOVERLAPPED lpOverlapped)
 502 {
 503     BOOL retv = TRUE;
 504
 505     switch (dwIoControlCode)
 506     {
 507     case 5:
 508         if (lpvOutBuffer && (cbOutBuffer>=4))
 509             *(DWORD*)lpvOutBuffer = GetTickCount();
 510
 511         if (lpcbBytesReturned)
 512             *lpcbBytesReturned = 4;
 513
 514         break;
 515
 516     default:
 517         FIXME( "Control %ld not implemented\n", dwIoControlCode);
 518         retv = FALSE;
 519         break;
 520     }
 521
 522     return retv;
 523 }
 524
 525 /***********************************************************************
 526  *              VxDCall0 (KERNEL32.1)
 527  *              VxDCall1 (KERNEL32.2)
 528  *              VxDCall2 (KERNEL32.3)
 529  *              VxDCall3 (KERNEL32.4)
 530  *              VxDCall4 (KERNEL32.5)
 531  *              VxDCall5 (KERNEL32.6)
 532  *              VxDCall6 (KERNEL32.7)
 533  *              VxDCall7 (KERNEL32.8)
 534  *              VxDCall8 (KERNEL32.9)
 535  */
 536 void VxDCall( DWORD service, CONTEXT86 *context )
 537 {
 538     DWORD ret = 0xffffffff; /* FIXME */
 539     int i;
 540
 541     TRACE( "(%08lx, ...)\n", service);
 542
 543     for (i = 0; VxDList[i].name; i++)
 544         if (VxDList[i].id == HIWORD(service))
 545             break;
 546
 547     if (!VxDList[i].name)
 548         FIXME( "Unknown VxD (%08lx)\n", service);
 549     else if (!VxDList[i].vxdcall)
 550         FIXME( "Unimplemented VxD (%08lx)\n", service);
 551     else
 552         ret = VxDList[i].vxdcall( service, context );
 553
 554     context->Eax = ret;
 555 }
 556
 557
 558 /***********************************************************************
 559  *           VxDCall_VMM
 560  */
 561 static DWORD VxDCall_VMM( DWORD service, CONTEXT86 *context )
 562 {
 563     switch ( LOWORD(service) )
 564     {
 565     case 0x0011:  /* RegOpenKey */
 566     {
 567         HKEY    hkey       = (HKEY)  stack32_pop( context );
 568         LPCSTR  lpszSubKey = (LPCSTR)stack32_pop( context );
 569         LPHKEY  retkey     = (LPHKEY)stack32_pop( context );
 570         return RegOpenKeyA( hkey, lpszSubKey, retkey );
 571     }
 572
 573     case 0x0012:  /* RegCreateKey */
 574     {
 575         HKEY    hkey       = (HKEY)  stack32_pop( context );
 576         LPCSTR  lpszSubKey = (LPCSTR)stack32_pop( context );
 577         LPHKEY  retkey     = (LPHKEY)stack32_pop( context );
 578         return RegCreateKeyA( hkey, lpszSubKey, retkey );
 579     }
 580
 581     case 0x0013:  /* RegCloseKey */
 582     {
 583         HKEY    hkey       = (HKEY)stack32_pop( context );
 584         return RegCloseKey( hkey );
 585     }
 586
 587     case 0x0014:  /* RegDeleteKey */
 588     {
 589         HKEY    hkey       = (HKEY)  stack32_pop( context );
 590         LPCSTR  lpszSubKey = (LPCSTR)stack32_pop( context );
 591         return RegDeleteKeyA( hkey, lpszSubKey );
 592     }
 593
 594     case 0x0015:  /* RegSetValue */
 595     {
 596         HKEY    hkey       = (HKEY)  stack32_pop( context );
 597         LPCSTR  lpszSubKey = (LPCSTR)stack32_pop( context );
 598         DWORD   dwType     = (DWORD) stack32_pop( context );
 599         LPCSTR  lpszData   = (LPCSTR)stack32_pop( context );
 600         DWORD   cbData     = (DWORD) stack32_pop( context );
 601         return RegSetValueA( hkey, lpszSubKey, dwType, lpszData, cbData );
 602     }
 603
 604     case 0x0016:  /* RegDeleteValue */
 605     {
 606         HKEY    hkey       = (HKEY) stack32_pop( context );
 607         LPSTR   lpszValue  = (LPSTR)stack32_pop( context );
 608         return RegDeleteValueA( hkey, lpszValue );
 609     }
 610
 611     case 0x0017:  /* RegQueryValue */
 612     {
 613         HKEY    hkey       = (HKEY)   stack32_pop( context );
 614         LPSTR   lpszSubKey = (LPSTR)  stack32_pop( context );
 615         LPSTR   lpszData   = (LPSTR)  stack32_pop( context );
 616         LPDWORD lpcbData   = (LPDWORD)stack32_pop( context );
 617         return RegQueryValueA( hkey, lpszSubKey, lpszData, lpcbData );
 618     }
 619
 620     case 0x0018:  /* RegEnumKey */
 621     {
 622         HKEY    hkey       = (HKEY) stack32_pop( context );
 623         DWORD   iSubkey    = (DWORD)stack32_pop( context );
 624         LPSTR   lpszName   = (LPSTR)stack32_pop( context );
 625         DWORD   lpcchName  = (DWORD)stack32_pop( context );
 626         return RegEnumKeyA( hkey, iSubkey, lpszName, lpcchName );
 627     }
 628
 629     case 0x0019:  /* RegEnumValue */
 630     {
 631         HKEY    hkey       = (HKEY)   stack32_pop( context );
 632         DWORD   iValue     = (DWORD)  stack32_pop( context );
 633         LPSTR   lpszValue  = (LPSTR)  stack32_pop( context );
 634         LPDWORD lpcchValue = (LPDWORD)stack32_pop( context );
 635         LPDWORD lpReserved = (LPDWORD)stack32_pop( context );
 636         LPDWORD lpdwType   = (LPDWORD)stack32_pop( context );
 637         LPBYTE  lpbData    = (LPBYTE) stack32_pop( context );
 638         LPDWORD lpcbData   = (LPDWORD)stack32_pop( context );
 639         return RegEnumValueA( hkey, iValue, lpszValue, lpcchValue,
 640                               lpReserved, lpdwType, lpbData, lpcbData );
 641     }
 642
 643     case 0x001A:  /* RegQueryValueEx */
 644     {
 645         HKEY    hkey       = (HKEY)   stack32_pop( context );
 646         LPSTR   lpszValue  = (LPSTR)  stack32_pop( context );
 647         LPDWORD lpReserved = (LPDWORD)stack32_pop( context );
 648         LPDWORD lpdwType   = (LPDWORD)stack32_pop( context );
 649         LPBYTE  lpbData    = (LPBYTE) stack32_pop( context );
 650         LPDWORD lpcbData   = (LPDWORD)stack32_pop( context );
 651         return RegQueryValueExA( hkey, lpszValue, lpReserved,
 652                                  lpdwType, lpbData, lpcbData );
 653     }
 654
 655     case 0x001B:  /* RegSetValueEx */
 656     {
 657         HKEY    hkey       = (HKEY)  stack32_pop( context );
 658         LPSTR   lpszValue  = (LPSTR) stack32_pop( context );
 659         DWORD   dwReserved = (DWORD) stack32_pop( context );
 660         DWORD   dwType     = (DWORD) stack32_pop( context );
 661         LPBYTE  lpbData    = (LPBYTE)stack32_pop( context );
 662         DWORD   cbData     = (DWORD) stack32_pop( context );
 663         return RegSetValueExA( hkey, lpszValue, dwReserved,
 664                                dwType, lpbData, cbData );
 665     }
 666
 667     case 0x001C:  /* RegFlushKey */
 668     {
 669         HKEY    hkey       = (HKEY)stack32_pop( context );
 670         return RegFlushKey( hkey );
 671     }
 672
 673     case 0x001D:  /* RegQueryInfoKey */
 674     {
 675         /* NOTE: This VxDCall takes only a subset of the parameters that the
 676                  corresponding Win32 API call does. The implementation in Win95
 677                  ADVAPI32 sets all output parameters not mentioned here to zero. */
 678
 679         HKEY    hkey              = (HKEY)   stack32_pop( context );
 680         LPDWORD lpcSubKeys        = (LPDWORD)stack32_pop( context );
 681         LPDWORD lpcchMaxSubKey    = (LPDWORD)stack32_pop( context );
 682         LPDWORD lpcValues         = (LPDWORD)stack32_pop( context );
 683         LPDWORD lpcchMaxValueName = (LPDWORD)stack32_pop( context );
 684         LPDWORD lpcchMaxValueData = (LPDWORD)stack32_pop( context );
 685         return RegQueryInfoKeyA( hkey, NULL, NULL, NULL, lpcSubKeys, lpcchMaxSubKey,
 686                                  NULL, lpcValues, lpcchMaxValueName, lpcchMaxValueData,
 687                                  NULL, NULL );
 688     }
 689
 690     case 0x0021:  /* RegLoadKey */
 691     {
 692         HKEY    hkey       = (HKEY)  stack32_pop( context );
 693         LPCSTR  lpszSubKey = (LPCSTR)stack32_pop( context );
 694         LPCSTR  lpszFile   = (LPCSTR)stack32_pop( context );
 695         return RegLoadKeyA( hkey, lpszSubKey, lpszFile );
 696     }
 697
 698     case 0x0022:  /* RegUnLoadKey */
 699     {
 700         HKEY    hkey       = (HKEY)  stack32_pop( context );
 701         LPCSTR  lpszSubKey = (LPCSTR)stack32_pop( context );
 702         return RegUnLoadKeyA( hkey, lpszSubKey );
 703     }
 704
 705     case 0x0023:  /* RegSaveKey */
 706     {
 707         HKEY    hkey       = (HKEY)  stack32_pop( context );
 708         LPCSTR  lpszFile   = (LPCSTR)stack32_pop( context );
 709         LPSECURITY_ATTRIBUTES sa = (LPSECURITY_ATTRIBUTES)stack32_pop( context );
 710         return RegSaveKeyA( hkey, lpszFile, sa );
 711     }
 712
 713 #if 0 /* Functions are not yet implemented in misc/registry.c */
 714     case 0x0024:  /* RegRemapPreDefKey */
 715     case 0x0026:  /* RegQueryMultipleValues */
 716 #endif
 717
 718     case 0x0027:  /* RegReplaceKey */
 719     {
 720         HKEY    hkey       = (HKEY)  stack32_pop( context );
 721         LPCSTR  lpszSubKey = (LPCSTR)stack32_pop( context );
 722         LPCSTR  lpszNewFile= (LPCSTR)stack32_pop( context );
 723         LPCSTR  lpszOldFile= (LPCSTR)stack32_pop( context );
 724         return RegReplaceKeyA( hkey, lpszSubKey, lpszNewFile, lpszOldFile );
 725     }
 726     case 0x0000: /* PageReserve */
 727       {
 728         LPVOID address;
 729         LPVOID ret;
 730         DWORD psize = getpagesize();
 731         ULONG page   = (ULONG) stack32_pop( context );
 732         ULONG npages = (ULONG) stack32_pop( context );
 733         ULONG flags  = (ULONG) stack32_pop( context );
 734
 735         TRACE("PageReserve: page: %08lx, npages: %08lx, flags: %08lx partial stub!\n",
 736               page, npages, flags );
 737
 738         if ( page == PR_SYSTEM ) {
 739           ERR("Can't reserve ring 1 memory\n");
 740           return -1;
 741         }
 742         /* FIXME: This has to be handled separately for the separate
 743            address-spaces we now have */
 744         if ( page == PR_PRIVATE || page == PR_SHARED ) page = 0;
 745         /* FIXME: Handle flags in some way */
 746         address = (LPVOID )(page * psize);
 747         ret = VirtualAlloc ( address, ( npages * psize ), MEM_RESERVE, 0 );
 748         TRACE("PageReserve: returning: %08lx\n", (DWORD )ret );
 749         if ( ret == NULL )
 750           return -1;
 751         else
 752           return (DWORD )ret;
 753       }
 754
 755     case 0x0001: /* PageCommit */
 756       {
 757         LPVOID address;
 758         LPVOID ret;
 759         DWORD virt_perm;
 760         DWORD psize = getpagesize();
 761         ULONG page   = (ULONG) stack32_pop( context );
 762         ULONG npages = (ULONG) stack32_pop( context );
 763         ULONG hpd  = (ULONG) stack32_pop( context );
 764         ULONG pagerdata   = (ULONG) stack32_pop( context );
 765         ULONG flags  = (ULONG) stack32_pop( context );
 766
 767         TRACE("PageCommit: page: %08lx, npages: %08lx, hpd: %08lx pagerdata: "
 768               "%08lx, flags: %08lx partial stub\n",
 769               page, npages, hpd, pagerdata, flags );
 770
 771         if ( flags & PC_USER )
 772           if ( flags & PC_WRITEABLE )
 773             virt_perm = PAGE_EXECUTE_READWRITE;
 774           else
 775             virt_perm = PAGE_EXECUTE_READ;
 776         else
 777           virt_perm = PAGE_NOACCESS;
 778
 779         address = (LPVOID )(page * psize);
 780         ret = VirtualAlloc ( address, ( npages * psize ), MEM_COMMIT, virt_perm );
 781         TRACE("PageCommit: Returning: %08lx\n", (DWORD )ret );
 782         return (DWORD )ret;
 783
 784       }
 785     case 0x0002: /* PageDecommit */
 786       {
 787         LPVOID address;
 788         BOOL ret;
 789         DWORD psize = getpagesize();
 790         ULONG page = (ULONG) stack32_pop( context );
 791         ULONG npages = (ULONG) stack32_pop( context );
 792         ULONG flags = (ULONG) stack32_pop( context );
 793
 794         TRACE("PageDecommit: page: %08lx, npages: %08lx, flags: %08lx partial stub\n",
 795               page, npages, flags );
 796         address = (LPVOID )( page * psize );
 797         ret = VirtualFree ( address, ( npages * psize ), MEM_DECOMMIT );
 798         TRACE("PageDecommit: Returning: %s\n", ret ? "TRUE" : "FALSE" );
 799         return ret;
 800       }
 801     case 0x000d: /* PageModifyPermissions */
 802       {
 803         DWORD pg_old_perm;
 804         DWORD pg_new_perm;
 805         DWORD virt_old_perm;
 806         DWORD virt_new_perm;
 807         MEMORY_BASIC_INFORMATION mbi;
 808         LPVOID address;
 809         DWORD psize = getpagesize();
 810         ULONG page = stack32_pop ( context );
 811         ULONG npages = stack32_pop ( context );
 812         ULONG permand = stack32_pop ( context );
 813         ULONG permor = stack32_pop ( context );
 814
 815         TRACE("PageModifyPermissions %08lx %08lx %08lx %08lx partial stub\n",
 816               page, npages, permand, permor );
 817         address = (LPVOID )( page * psize );
 818
 819         VirtualQuery ( address, &mbi, sizeof ( MEMORY_BASIC_INFORMATION ));
 820         virt_old_perm = mbi.Protect;
 821
 822         switch ( virt_old_perm & mbi.Protect ) {
 823         case PAGE_READONLY:
 824         case PAGE_EXECUTE:
 825         case PAGE_EXECUTE_READ:
 826           pg_old_perm = PC_USER;
 827           break;
 828         case PAGE_READWRITE:
 829         case PAGE_WRITECOPY:
 830         case PAGE_EXECUTE_READWRITE:
 831         case PAGE_EXECUTE_WRITECOPY:
 832           pg_old_perm = PC_USER | PC_WRITEABLE;
 833           break;
 834         case PAGE_NOACCESS:
 835         default:
 836           pg_old_perm = 0;
 837           break;
 838         }
 839         pg_new_perm = pg_old_perm;
 840         pg_new_perm &= permand & ~PC_STATIC;
 841         pg_new_perm |= permor  & ~PC_STATIC;
 842
 843         virt_new_perm = ( virt_old_perm )  & ~0xff;
 844         if ( pg_new_perm & PC_USER )
 845         {
 846           if ( pg_new_perm & PC_WRITEABLE )
 847             virt_new_perm |= PAGE_EXECUTE_READWRITE;
 848           else
 849             virt_new_perm |= PAGE_EXECUTE_READ;
 850         }
 851
 852         if ( ! VirtualProtect ( address, ( npages * psize ), virt_new_perm, &virt_old_perm ) ) {
 853           ERR("Can't change page permissions for %08lx\n", (DWORD )address );
 854           return 0xffffffff;
 855         }
 856         TRACE("Returning: %08lx\n", pg_old_perm );
 857         return pg_old_perm;
 858       }
 859     case 0x000a: /* PageFree */
 860       {
 861         BOOL ret;
 862         LPVOID hmem = (LPVOID) stack32_pop( context );
 863         DWORD flags = (DWORD ) stack32_pop( context );
 864
 865         TRACE("PageFree: hmem: %08lx, flags: %08lx partial stub\n",
 866               (DWORD )hmem, flags );
 867
 868         ret = VirtualFree ( hmem, 0, MEM_RELEASE );
 869         context->Eax = ret;
 870         TRACE("Returning: %d\n", ret );
 871
 872         return 0;
 873       }
 874     case 0x001e: /* GetDemandPageInfo */
 875       {
 876          DWORD dinfo = (DWORD)stack32_pop( context );
 877          DWORD flags = (DWORD)stack32_pop( context );
 878
 879          /* GetDemandPageInfo is supposed to fill out the struct at
 880           * "dinfo" with various low-level memory management information.
 881           * Apps are certainly not supposed to call this, although it's
 882           * demoed and documented by Pietrek on pages 441-443 of "Windows
 883           * 95 System Programming Secrets" if any program needs a real
 884           * implementation of this.
 885           */
 886
 887          FIXME("GetDemandPageInfo(%08lx %08lx): stub!\n", dinfo, flags);
 888
 889          return 0;
 890       }
 891     default:
 892         if (LOWORD(service) < N_VMM_SERVICE)
 893             FIXME( "Unimplemented service %s (%08lx)\n",
 894                           VMM_Service_Name[LOWORD(service)], service);
 895         else
 896             FIXME( "Unknown service %08lx\n", service);
 897         break;
 898     }
 899
 900     return 0xffffffff;  /* FIXME */
 901 }
 902
 903 /***********************************************************************
 904  *           DeviceIo_IFSMgr
 905  * NOTES
 906  *   These ioctls are used by 'MSNET32.DLL'.
 907  *
 908  *   I have been unable to uncover any documentation about the ioctls so
 909  *   the implementation of the cases IFS_IOCTL_21 and IFS_IOCTL_2F are
 910  *   based on reasonable guesses on information found in the Windows 95 DDK.
 911  *
 912  */
 913
 914 /*
 915  * IFSMgr DeviceIO service
 916  */
 917
 918 #define IFS_IOCTL_21                100
 919 #define IFS_IOCTL_2F                101
 920 #define IFS_IOCTL_GET_RES           102
 921 #define IFS_IOCTL_GET_NETPRO_NAME_A 103
 922
 923 struct win32apireq {
 924         unsigned long   ar_proid;
 925         unsigned long   ar_eax;
 926         unsigned long   ar_ebx;
 927         unsigned long   ar_ecx;
 928         unsigned long   ar_edx;
 929         unsigned long   ar_esi;
 930         unsigned long   ar_edi;
 931         unsigned long   ar_ebp;
 932         unsigned short  ar_error;
 933         unsigned short  ar_pad;
 934 };
 935
 936 static void win32apieq_2_CONTEXT(struct win32apireq *pIn,CONTEXT86 *pCxt)
 937 {
 938         memset(pCxt,0,sizeof(*pCxt));
 939
 940         pCxt->ContextFlags=CONTEXT86_INTEGER|CONTEXT86_CONTROL;
 941         pCxt->Eax = pIn->ar_eax;
 942         pCxt->Ebx = pIn->ar_ebx;
 943         pCxt->Ecx = pIn->ar_ecx;
 944         pCxt->Edx = pIn->ar_edx;
 945         pCxt->Esi = pIn->ar_esi;
 946         pCxt->Edi = pIn->ar_edi;
 947
 948         /* FIXME: Only partial CONTEXT86_CONTROL */
 949         pCxt->Ebp = pIn->ar_ebp;
 950
 951         /* FIXME: pIn->ar_proid ignored */
 952         /* FIXME: pIn->ar_error ignored */
 953         /* FIXME: pIn->ar_pad ignored */
 954 }
 955
 956 static void CONTEXT_2_win32apieq(CONTEXT86 *pCxt,struct win32apireq *pOut)
 957 {
 958         memset(pOut,0,sizeof(struct win32apireq));
 959
 960         pOut->ar_eax = pCxt->Eax;
 961         pOut->ar_ebx = pCxt->Ebx;
 962         pOut->ar_ecx = pCxt->Ecx;
 963         pOut->ar_edx = pCxt->Edx;
 964         pOut->ar_esi = pCxt->Esi;
 965         pOut->ar_edi = pCxt->Edi;
 966
 967         /* FIXME: Only partial CONTEXT86_CONTROL */
 968         pOut->ar_ebp = pCxt->Ebp;
 969
 970         /* FIXME: pOut->ar_proid ignored */
 971         /* FIXME: pOut->ar_error ignored */
 972         /* FIXME: pOut->ar_pad ignored */
 973 }
 974
 975 static BOOL DeviceIo_IFSMgr(DWORD dwIoControlCode, LPVOID lpvInBuffer, DWORD cbInBuffer,
 976                               LPVOID lpvOutBuffer, DWORD cbOutBuffer,
 977                               LPDWORD lpcbBytesReturned,
 978                               LPOVERLAPPED lpOverlapped)
 979 {
 980     BOOL retv = TRUE;
 981         TRACE("(%ld,%p,%ld,%p,%ld,%p,%p): stub\n",
 982                         dwIoControlCode,
 983                         lpvInBuffer,cbInBuffer,
 984                         lpvOutBuffer,cbOutBuffer,
 985                         lpcbBytesReturned,
 986                         lpOverlapped);
 987
 988     switch (dwIoControlCode)
 989     {
 990         case IFS_IOCTL_21:
 991         case IFS_IOCTL_2F:{
 992                 CONTEXT86 cxt;
 993                 struct win32apireq *pIn=(struct win32apireq *) lpvInBuffer;
 994                 struct win32apireq *pOut=(struct win32apireq *) lpvOutBuffer;
 995
 996                 TRACE(
 997                         "Control '%s': "
 998                         "proid=0x%08lx, eax=0x%08lx, ebx=0x%08lx, ecx=0x%08lx, "
 999                         "edx=0x%08lx, esi=0x%08lx, edi=0x%08lx, ebp=0x%08lx, "
1000                         "error=0x%04x, pad=0x%04x\n",
1001                         (dwIoControlCode==IFS_IOCTL_21)?"IFS_IOCTL_21":"IFS_IOCTL_2F",
1002                         pIn->ar_proid, pIn->ar_eax, pIn->ar_ebx, pIn->ar_ecx,
1003                         pIn->ar_edx, pIn->ar_esi, pIn->ar_edi, pIn->ar_ebp,
1004                         pIn->ar_error, pIn->ar_pad
1005                 );
1006
1007                 win32apieq_2_CONTEXT(pIn,&cxt);
1008
1009                 if(dwIoControlCode==IFS_IOCTL_21)
1010                 {
1011                         DOS3Call(&cxt); /* Call int 21h */
1012                 } else {
1013                         INT_Int2fHandler(&cxt); /* Call int 2Fh */
1014                 }
1015
1016                 CONTEXT_2_win32apieq(&cxt,pOut);
1017
1018         retv = TRUE;
1019         } break;
1020         case IFS_IOCTL_GET_RES:{
1021         FIXME( "Control 'IFS_IOCTL_GET_RES' not implemented\n");
1022         retv = FALSE;
1023         } break;
1024         case IFS_IOCTL_GET_NETPRO_NAME_A:{
1025         FIXME( "Control 'IFS_IOCTL_GET_NETPRO_NAME_A' not implemented\n");
1026         retv = FALSE;
1027         } break;
1028     default:
1029         FIXME( "Control %ld not implemented\n", dwIoControlCode);
1030         retv = FALSE;
1031     }
1032
1033     return retv;
1034 }
1035
1036 /********************************************************************************
1037  *      VxDCall_VWin32
1038  *
1039  *  Service numbers taken from page 448 of Pietrek's "Windows 95 System
1040  *  Programming Secrets".  Parameters from experimentation on real Win98.
1041  *
1042  */
1043
1044 static DWORD VxDCall_VWin32( DWORD service, CONTEXT86 *context )
1045 {
1046   switch ( LOWORD(service) )
1047     {
1048     case 0x0000: /* GetVersion */
1049     {
1050         DWORD vers = GetVersion();
1051         return (LOBYTE(vers) << 8) | HIBYTE(vers);
1052     }
1053     break;
1054
1055     case 0x0020: /* Get VMCPD Version */
1056     {
1057         DWORD parm = (DWORD) stack32_pop(context);
1058
1059         FIXME("Get VMCPD Version(%08lx): partial stub!\n", parm);
1060
1061         /* FIXME: This is what Win98 returns, it may
1062          *        not be correct in all situations.
1063          *        It makes Bleem! happy though.
1064          */
1065
1066         return 0x0405;
1067     }
1068
1069     case 0x0029: /* Int31/DPMI dispatch */
1070     {
1071         DWORD callnum = (DWORD) stack32_pop(context);
1072         DWORD parm    = (DWORD) stack32_pop(context);
1073
1074         TRACE("Int31/DPMI dispatch(%08lx)\n", callnum);
1075
1076         AX_reg(context) = callnum;
1077         CX_reg(context) = parm;
1078         INT_Int31Handler(context);
1079
1080         return LOWORD(context->Eax);
1081     }
1082     break;
1083
1084     case 0x002a: /* Int41 dispatch - parm = int41 service number */
1085     {
1086         DWORD callnum = (DWORD) stack32_pop(context);
1087
1088         return callnum; /* FIXME: should really call INT_Int41Handler() */
1089     }
1090     break;
1091
1092     default:
1093       FIXME("Unknown VWin32 service %08lx\n", service);
1094       break;
1095     }
1096
1097   return 0xffffffff;
1098 }
1099
1100
1101 /***********************************************************************
1102  *           DeviceIo_VCD
1103  */
1104 static BOOL DeviceIo_VCD(DWORD dwIoControlCode,
1105                               LPVOID lpvInBuffer, DWORD cbInBuffer,
1106                               LPVOID lpvOutBuffer, DWORD cbOutBuffer,
1107                               LPDWORD lpcbBytesReturned,
1108                               LPOVERLAPPED lpOverlapped)
1109 {
1110     BOOL retv = TRUE;
1111
1112     switch (dwIoControlCode)
1113     {
1114     case IOCTL_SERIAL_LSRMST_INSERT:
1115     {
1116         FIXME( "IOCTL_SERIAL_LSRMST_INSERT NIY !\n");
1117         retv = FALSE;
1118     }
1119     break;
1120
1121     default:
1122         FIXME( "Unknown Control %ld\n", dwIoControlCode);
1123         retv = FALSE;
1124         break;
1125     }
1126
1127     return retv;
1128 }
1129
1130
1131 /***********************************************************************
1132  *           DeviceIo_VWin32
1133  */
1134
1135 static void DIOCRegs_2_CONTEXT( DIOC_REGISTERS *pIn, CONTEXT86 *pCxt )
1136 {
1137     memset( pCxt, 0, sizeof(*pCxt) );
1138     /* Note: segment registers == 0 means that CTX_SEG_OFF_TO_LIN
1139              will interpret 32-bit register contents as linear pointers */
1140
1141     pCxt->ContextFlags=CONTEXT86_INTEGER|CONTEXT86_CONTROL;
1142     pCxt->Eax = pIn->reg_EAX;
1143     pCxt->Ebx = pIn->reg_EBX;
1144     pCxt->Ecx = pIn->reg_ECX;
1145     pCxt->Edx = pIn->reg_EDX;
1146     pCxt->Esi = pIn->reg_ESI;
1147     pCxt->Edi = pIn->reg_EDI;
1148
1149     /* FIXME: Only partial CONTEXT86_CONTROL */
1150     pCxt->EFlags = pIn->reg_Flags;
1151 }
1152
1153 static void CONTEXT_2_DIOCRegs( CONTEXT86 *pCxt, DIOC_REGISTERS *pOut )
1154 {
1155     memset( pOut, 0, sizeof(DIOC_REGISTERS) );
1156
1157     pOut->reg_EAX = pCxt->Eax;
1158     pOut->reg_EBX = pCxt->Ebx;
1159     pOut->reg_ECX = pCxt->Ecx;
1160     pOut->reg_EDX = pCxt->Edx;
1161     pOut->reg_ESI = pCxt->Esi;
1162     pOut->reg_EDI = pCxt->Edi;
1163
1164     /* FIXME: Only partial CONTEXT86_CONTROL */
1165     pOut->reg_Flags = pCxt->EFlags;
1166 }
1167
1168 #define DIOC_AH(regs) (((unsigned char*)&((regs)->reg_EAX))[1])
1169 #define DIOC_AL(regs) (((unsigned char*)&((regs)->reg_EAX))[0])
1170 #define DIOC_BH(regs) (((unsigned char*)&((regs)->reg_EBX))[1])
1171 #define DIOC_BL(regs) (((unsigned char*)&((regs)->reg_EBX))[0])
1172 #define DIOC_DH(regs) (((unsigned char*)&((regs)->reg_EDX))[1])
1173 #define DIOC_DL(regs) (((unsigned char*)&((regs)->reg_EDX))[0])
1174
1175 #define DIOC_AX(regs) (((unsigned short*)&((regs)->reg_EAX))[0])
1176 #define DIOC_BX(regs) (((unsigned short*)&((regs)->reg_EBX))[0])
1177 #define DIOC_CX(regs) (((unsigned short*)&((regs)->reg_ECX))[0])
1178 #define DIOC_DX(regs) (((unsigned short*)&((regs)->reg_EDX))[0])
1179
1180 #define DIOC_SET_CARRY(regs) (((regs)->reg_Flags)|=0x00000001)
1181
1182 static const DWORD VWIN32_DriveTypeInfo[7]={
1183     0x0000, /* none */
1184     0x2709, /* 360 K */
1185     0x4f0f, /* 1.2 M */
1186     0x4f09, /* 720 K */
1187     0x4f12, /* 1.44 M */
1188     0x4f24, /* 2.88 M */
1189     0x4f24  /* 2.88 M */
1190 };
1191
1192 /**********************************************************************
1193  *          VWIN32_ReadFloppyParams
1194  *
1195  * Handler for int 13h (disk I/O).
1196  */
1197 static VOID VWIN32_ReadFloppyParams(DIOC_REGISTERS *regs)
1198 {
1199 #ifdef linux
1200     static BYTE floppy_params[2][13] =
1201     {
1202         { 0xaf, 0x02, 0x25, 0x02, 0x12, 0x1b, 0xff, 0x6c, 0xf6, 0x0f, 0x08 },
1203         { 0xaf, 0x02, 0x25, 0x02, 0x12, 0x1b, 0xff, 0x6c, 0xf6, 0x0f, 0x08 }
1204     };
1205
1206     unsigned int i, nr_of_drives = 0;
1207     BYTE drive_nr = DIOC_DL(regs);
1208     int floppy_fd,r;
1209     struct floppy_drive_params floppy_parm;
1210     char root[] = "A:\\";
1211
1212     TRACE("in  [ EDX=%08lx ]\n", regs->reg_EDX );
1213
1214     DIOC_AH(regs) = 0x00; /* success */
1215
1216     for (i = 0; i < MAX_DOS_DRIVES; i++, root[0]++)
1217         if (GetDriveTypeA(root) == DRIVE_REMOVABLE) nr_of_drives++;
1218     DIOC_DL(regs) = nr_of_drives;
1219
1220     if (drive_nr > 1) { /* invalid drive ? */
1221         DIOC_BX(regs) = 0;
1222         DIOC_CX(regs) = 0;
1223         DIOC_DH(regs) = 0;
1224         DIOC_SET_CARRY(regs);
1225         return;
1226     }
1227
1228     if ( (floppy_fd = DRIVE_OpenDevice( drive_nr, O_NONBLOCK)) == -1)
1229     {
1230         WARN("Can't determine floppy geometry !\n");
1231         DIOC_BX(regs) = 0;
1232         DIOC_CX(regs) = 0;
1233         DIOC_DH(regs) = 0;
1234         DIOC_SET_CARRY(regs);
1235         return;
1236     }
1237     r = ioctl(floppy_fd, FDGETDRVPRM, &floppy_parm);
1238
1239     close(floppy_fd);
1240
1241     if(r<0)
1242     {
1243         DIOC_SET_CARRY(regs);
1244         return;
1245     }
1246
1247     regs->reg_ECX = 0;
1248     DIOC_AL(regs) = 0;
1249     DIOC_BL(regs) = floppy_parm.cmos;
1250
1251     /* CH = low eight bits of max cyl
1252        CL = max sec nr (bits 5-0),
1253        hi two bits of max cyl (bits 7-6)
1254        DH = max head nr */
1255     if(DIOC_BL(regs) && (DIOC_BL(regs)<7))
1256     {
1257         DIOC_DH(regs) = 0x01;
1258         DIOC_CX(regs) = VWIN32_DriveTypeInfo[DIOC_BL(regs)];
1259     }
1260     else
1261     {
1262         DIOC_CX(regs) = 0x0;
1263         DIOC_DX(regs) = 0x0;
1264     }
1265
1266     regs->reg_EDI = (DWORD)floppy_params[drive_nr];
1267
1268     if(!regs->reg_EDI)
1269     {
1270         ERR("Get floppy params failed for drive %d\n",drive_nr);
1271         DIOC_SET_CARRY(regs);
1272     }
1273
1274     TRACE("out [ EAX=%08lx EBX=%08lx ECX=%08lx EDX=%08lx EDI=%08lx ]\n",
1275           regs->reg_EAX, regs->reg_EBX, regs->reg_ECX, regs->reg_EDX, regs->reg_EDI);
1276
1277     /* FIXME: Word exits quietly if we return with no error. Why? */
1278     FIXME("Returned ERROR!\n");
1279     DIOC_SET_CARRY(regs);
1280
1281 #else
1282     DIOC_AH(regs) = 0x01;
1283     DIOC_SET_CARRY(regs);
1284 #endif
1285 }
1286
1287 /**********************************************************************
1288  *          VWIN32_Int13Handler
1289  *
1290  * Handler for VWIN32_DIOC_DOS_INT13 (disk I/O).
1291  */
1292 static VOID VWIN32_Int13Handler( DIOC_REGISTERS *regs)
1293 {
1294     TRACE("AH=%02x\n",DIOC_AH(regs));
1295     switch(DIOC_AH(regs)) /* AH */
1296     {
1297     case 0x00:             /* RESET DISK SYSTEM     */
1298         break; /* no return ? */
1299
1300     case 0x01:             /* STATUS OF DISK SYSTEM */
1301         DIOC_AL(regs) = 0; /* successful completion */
1302         break;
1303
1304     case 0x02:             /* READ SECTORS INTO MEMORY */
1305         DIOC_AL(regs) = 0; /* number of sectors read */
1306         DIOC_AH(regs) = 0; /* status */
1307         break;
1308
1309     case 0x03:             /* WRITE SECTORS FROM MEMORY */
1310         break; /* no return ? */
1311
1312     case 0x04:             /* VERIFY DISK SECTOR(S) */
1313         DIOC_AL(regs) = 0; /* number of sectors verified */
1314         DIOC_AH(regs) = 0;
1315         break;
1316
1317     case 0x05:             /* FORMAT TRACK */
1318     case 0x06:             /* FORMAT TRACK AND SET BAD SECTOR FLAGS */
1319     case 0x07:             /* FORMAT DRIVE STARTING AT GIVEN TRACK  */
1320         /* despite what Ralf Brown says, 0x06 and 0x07 seem to
1321          * set CFLAG, too (at least my BIOS does that) */
1322         DIOC_AH(regs) = 0x0c;
1323         DIOC_SET_CARRY(regs);
1324         break;
1325
1326     case 0x08:             /* GET DRIVE PARAMETERS  */
1327         if (DIOC_DL(regs) & 0x80) { /* hard disk ? */
1328             DIOC_AH(regs) = 0x07;
1329             DIOC_SET_CARRY(regs);
1330         }
1331         else  /* floppy disk */
1332             VWIN32_ReadFloppyParams(regs);
1333         break;
1334
1335     case 0x09:         /* INITIALIZE CONTROLLER WITH DRIVE PARAMETERS */
1336     case 0x0a:         /* FIXED DISK - READ LONG (XT,AT,XT286,PS)     */
1337     case 0x0b:         /* FIXED DISK - WRITE LONG (XT,AT,XT286,PS)    */
1338     case 0x0c:         /* SEEK TO CYLINDER                            */
1339     case 0x0d:         /* ALTERNATE RESET HARD DISKS                  */
1340     case 0x10:         /* CHECK IF DRIVE READY                        */
1341     case 0x11:         /* RECALIBRATE DRIVE                           */
1342     case 0x14:         /* CONTROLLER INTERNAL DIAGNOSTIC              */
1343         DIOC_AH(regs) = 0;
1344         break;
1345
1346     case 0x15:         /* GET DISK TYPE (AT,XT2,XT286,CONV,PS) */
1347         if (DIOC_DL(regs) & 0x80) { /* hard disk ? */
1348             DIOC_AH(regs) = 3; /* fixed disk */
1349             DIOC_SET_CARRY(regs);
1350         }
1351         else { /* floppy disk ? */
1352             DIOC_AH(regs) = 2; /* floppy with change detection */
1353             DIOC_SET_CARRY(regs);
1354         }
1355         break;
1356
1357     case 0x0e:         /* READ SECTOR BUFFER (XT only)      */
1358     case 0x0f:         /* WRITE SECTOR BUFFER (XT only)     */
1359     case 0x12:         /* CONTROLLER RAM DIAGNOSTIC (XT,PS) */
1360     case 0x13:         /* DRIVE DIAGNOSTIC (XT,PS)          */
1361         DIOC_AH(regs) = 0x01;
1362         DIOC_SET_CARRY(regs);
1363         break;
1364
1365     case 0x16:         /* FLOPPY - CHANGE OF DISK STATUS */
1366         DIOC_AH(regs) = 0; /* FIXME - no change */
1367         break;
1368
1369     case 0x17:         /* SET DISK TYPE FOR FORMAT */
1370         if (DIOC_DL(regs) < 4)
1371             DIOC_AH(regs) = 0x00; /* successful completion */
1372         else
1373             DIOC_AH(regs) = 0x01; /* error */
1374         break;
1375
1376     case 0x18:         /* SET MEDIA TYPE FOR FORMAT */
1377         if (DIOC_DL(regs) < 4)
1378             DIOC_AH(regs) = 0x00; /* successful completion */
1379         else
1380             DIOC_AH(regs) = 0x01; /* error */
1381         break;
1382
1383     case 0x19:       /* FIXED DISK - PARK HEADS */
1384         break;
1385
1386     default:
1387         FIXME("Unknown VWIN32 INT13 call AX=%04X\n",DIOC_AX(regs));
1388     }
1389 }
1390
1391 static BOOL DeviceIo_VWin32(DWORD dwIoControlCode,
1392                               LPVOID lpvInBuffer, DWORD cbInBuffer,
1393                               LPVOID lpvOutBuffer, DWORD cbOutBuffer,
1394                               LPDWORD lpcbBytesReturned,
1395                               LPOVERLAPPED lpOverlapped)
1396 {
1397     BOOL retv = TRUE;
1398
1399     switch (dwIoControlCode)
1400     {
1401     case VWIN32_DIOC_DOS_INT13:
1402     {
1403         DIOC_REGISTERS *pIn  = (DIOC_REGISTERS *)lpvInBuffer;
1404         DIOC_REGISTERS *pOut = (DIOC_REGISTERS *)lpvOutBuffer;
1405
1406         memcpy(pOut, pIn, sizeof (DIOC_REGISTERS));
1407         VWIN32_Int13Handler(pOut);
1408         break;
1409     }
1410
1411     case VWIN32_DIOC_DOS_IOCTL:
1412     case 0x10: /* Int 0x21 call, call it VWIN_DIOC_INT21 ? */
1413     case VWIN32_DIOC_DOS_INT25:
1414     case VWIN32_DIOC_DOS_INT26:
1415     case 0x29: /* Int 0x31 call, call it VWIN_DIOC_INT31 ? */
1416     case VWIN32_DIOC_DOS_DRIVEINFO:
1417     {
1418         CONTEXT86 cxt;
1419         DIOC_REGISTERS *pIn  = (DIOC_REGISTERS *)lpvInBuffer;
1420         DIOC_REGISTERS *pOut = (DIOC_REGISTERS *)lpvOutBuffer;
1421
1422         TRACE( "Control '%s': "
1423                "eax=0x%08lx, ebx=0x%08lx, ecx=0x%08lx, "
1424                "edx=0x%08lx, esi=0x%08lx, edi=0x%08lx \n",
1425                (dwIoControlCode == VWIN32_DIOC_DOS_IOCTL)? "VWIN32_DIOC_DOS_IOCTL" :
1426                (dwIoControlCode == VWIN32_DIOC_DOS_INT25)? "VWIN32_DIOC_DOS_INT25" :
1427                (dwIoControlCode == VWIN32_DIOC_DOS_INT26)? "VWIN32_DIOC_DOS_INT26" :
1428                (dwIoControlCode == VWIN32_DIOC_DOS_DRIVEINFO)? "VWIN32_DIOC_DOS_DRIVEINFO" :  "???",
1429                pIn->reg_EAX, pIn->reg_EBX, pIn->reg_ECX,
1430                pIn->reg_EDX, pIn->reg_ESI, pIn->reg_EDI );
1431
1432         DIOCRegs_2_CONTEXT( pIn, &cxt );
1433
1434         switch (dwIoControlCode)
1435         {
1436         case VWIN32_DIOC_DOS_IOCTL: DOS3Call( &cxt ); break; /* Call int 21h */
1437         case VWIN32_DIOC_DOS_INT13: INT_Int13Handler( &cxt ); break;
1438         case 0x10: /* Int 0x21 call, call it VWIN_DIOC_INT21 ? */
1439                                     DOS3Call( &cxt ); break;
1440         case VWIN32_DIOC_DOS_INT25: INT_Int25Handler( &cxt ); break;
1441         case VWIN32_DIOC_DOS_INT26: INT_Int26Handler( &cxt ); break;
1442         case 0x29: /* Int 0x31 call, call it VWIN_DIOC_INT31 ? */
1443                                     INT_Int31Handler( &cxt ); break;
1444         case VWIN32_DIOC_DOS_DRIVEINFO: DOS3Call( &cxt ); break; /* Call int 21h 730x */
1445         }
1446
1447         CONTEXT_2_DIOCRegs( &cxt, pOut );
1448     }
1449     break;
1450
1451     case VWIN32_DIOC_SIMCTRLC:
1452         FIXME( "Control VWIN32_DIOC_SIMCTRLC not implemented\n");
1453         retv = FALSE;
1454         break;
1455
1456     default:
1457         FIXME( "Unknown Control %ld\n", dwIoControlCode);
1458         retv = FALSE;
1459         break;
1460     }
1461
1462     return retv;
1463 }
1464
1465 /* this is the main multimedia device loader */
1466 static BOOL DeviceIo_MMDEVLDR(DWORD dwIoControlCode,
1467                               LPVOID lpvInBuffer, DWORD cbInBuffer,
1468                               LPVOID lpvOutBuffer, DWORD cbOutBuffer,
1469                               LPDWORD lpcbBytesReturned,
1470                               LPOVERLAPPED lpOverlapped)
1471 {
1472         FIXME("(%ld,%p,%ld,%p,%ld,%p,%p): stub\n",
1473             dwIoControlCode,
1474             lpvInBuffer,cbInBuffer,
1475             lpvOutBuffer,cbOutBuffer,
1476             lpcbBytesReturned,
1477             lpOverlapped
1478         );
1479         switch (dwIoControlCode) {
1480         case 5:
1481                 /* Hmm. */
1482                 *(DWORD*)lpvOutBuffer=0;
1483                 *lpcbBytesReturned=4;
1484                 return TRUE;
1485         }
1486         return FALSE;
1487 }
1488 /* this is used by some Origin games */
1489 static BOOL DeviceIo_MONODEBG(DWORD dwIoControlCode,
1490                               LPVOID lpvInBuffer, DWORD cbInBuffer,
1491                               LPVOID lpvOutBuffer, DWORD cbOutBuffer,
1492                               LPDWORD lpcbBytesReturned,
1493                               LPOVERLAPPED lpOverlapped)
1494 {
1495         switch (dwIoControlCode) {
1496         case 1: /* version */
1497                 *(LPDWORD)lpvOutBuffer = 0x20004; /* WC SecretOps */
1498                 break;
1499         case 9: /* debug output */
1500                 ERR("MONODEBG: %s\n",debugstr_a(lpvInBuffer));
1501                 break;
1502         default:
1503                 FIXME("(%ld,%p,%ld,%p,%ld,%p,%p): stub\n",
1504                         dwIoControlCode,
1505                         lpvInBuffer,cbInBuffer,
1506                         lpvOutBuffer,cbOutBuffer,
1507                         lpcbBytesReturned,
1508                         lpOverlapped
1509                 );
1510                 break;
1511         }
1512         return TRUE;
1513 }
1514 /* pccard */
1515 static BOOL DeviceIo_PCCARD (DWORD dwIoControlCode,
1516                               LPVOID lpvInBuffer, DWORD cbInBuffer,
1517                               LPVOID lpvOutBuffer, DWORD cbOutBuffer,
1518                               LPDWORD lpcbBytesReturned,
1519                               LPOVERLAPPED lpOverlapped)
1520 {
1521         switch (dwIoControlCode) {
1522         case 0x0000: /* PCCARD_Get_Version */
1523         case 0x0001: /* PCCARD_Card_Services */
1524         default:
1525                 FIXME( "(%ld,%p,%ld,%p,%ld,%p,%p): stub\n",
1526                         dwIoControlCode,
1527                         lpvInBuffer,cbInBuffer,
1528                         lpvOutBuffer,cbOutBuffer,
1529                         lpcbBytesReturned,
1530                         lpOverlapped
1531                 );
1532                 break;
1533         }
1534         return FALSE;
1535 }
1536
1537 /***********************************************************************
1538  *              OpenVxDHandle (KERNEL32.@)
1539  *
1540  *      This function is supposed to return the corresponding Ring 0
1541  *      ("kernel") handle for a Ring 3 handle in Win9x.
1542  *      Evidently, Wine will have problems with this. But we try anyway,
1543  *      maybe it helps...
1544  */
1545 HANDLE  WINAPI  OpenVxDHandle(HANDLE hHandleRing3)
1546 {
1547         FIXME( "(0x%08x), stub! (returning Ring 3 handle instead of Ring 0)\n", hHandleRing3);
1548         return hHandleRing3;
1549 }
1550
1551 static BOOL DeviceIo_HASP(DWORD dwIoControlCode, LPVOID lpvInBuffer, DWORD cbInBuffer,
1552                               LPVOID lpvOutBuffer, DWORD cbOutBuffer,
1553                               LPDWORD lpcbBytesReturned,
1554                               LPOVERLAPPED lpOverlapped)
1555 {
1556     BOOL retv = TRUE;
1557         FIXME("(%ld,%p,%ld,%p,%ld,%p,%p): stub\n",
1558                         dwIoControlCode,
1559                         lpvInBuffer,cbInBuffer,
1560                         lpvOutBuffer,cbOutBuffer,
1561                         lpcbBytesReturned,
1562                         lpOverlapped);
1563
1564     return retv;
1565 }
1566