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( LPCWSTR filenameW, DWORD access, LPSECURITY_ATTRIBUTES sa )
 348 {
 349     const struct VxDInfo *info;
 350     char filename[MAX_PATH];
 351
 352     if (!WideCharToMultiByte(CP_ACP, 0, filenameW, -1, filename, MAX_PATH, NULL, NULL))
 353     {
 354         SetLastError( ERROR_FILE_NOT_FOUND );
 355         return 0;
 356     }
 357
 358     for (info = VxDList; info->name; info++)
 359         if (!strncasecmp( info->name, filename, strlen(info->name) ))
 360             return FILE_CreateDevice( info->id | 0x10000, access, sa );
 361
 362     FIXME( "Unknown/unsupported VxD %s. Try setting Windows version to 'nt40' or 'win31'.\n",
 363            filename);
 364     SetLastError( ERROR_FILE_NOT_FOUND );
 365     return 0;
 366 }
 367
 368 static DWORD DEVICE_GetClientID( HANDLE handle )
 369 {
 370     DWORD       ret = 0;
 371     SERVER_START_REQ( get_file_info )
 372     {
 373         req->handle = handle;
 374         if (!wine_server_call( req ) && (reply->type == FILE_TYPE_UNKNOWN))
 375             ret = reply->attr;
 376     }
 377     SERVER_END_REQ;
 378     return ret;
 379 }
 380
 381 static const struct VxDInfo *DEVICE_GetInfo( DWORD clientID )
 382 {
 383     const struct VxDInfo *info = NULL;
 384
 385     if (clientID & 0x10000)
 386     {
 387         for (info = VxDList; info->name; info++)
 388             if (info->id == LOWORD(clientID)) break;
 389     }
 390     return info;
 391 }
 392
 393 /****************************************************************************
 394  *              DeviceIoControl (KERNEL32.@)
 395  * This is one of those big ugly nasty procedure which can do
 396  * a million and one things when it comes to devices. It can also be
 397  * used for VxD communication.
 398  *
 399  * A return value of FALSE indicates that something has gone wrong which
 400  * GetLastError can decipher.
 401  */
 402 BOOL WINAPI DeviceIoControl(HANDLE hDevice, DWORD dwIoControlCode,
 403                               LPVOID lpvInBuffer, DWORD cbInBuffer,
 404                               LPVOID lpvOutBuffer, DWORD cbOutBuffer,
 405                               LPDWORD lpcbBytesReturned,
 406                               LPOVERLAPPED lpOverlapped)
 407 {
 408         DWORD clientID;
 409
 410         TRACE( "(%d,%ld,%p,%ld,%p,%ld,%p,%p)\n",
 411                hDevice,dwIoControlCode,lpvInBuffer,cbInBuffer,
 412                lpvOutBuffer,cbOutBuffer,lpcbBytesReturned,lpOverlapped  );
 413
 414         if (!(clientID = DEVICE_GetClientID( hDevice )))
 415         {
 416                 SetLastError( ERROR_INVALID_PARAMETER );
 417                 return FALSE;
 418         }
 419
 420         /* Check if this is a user defined control code for a VxD */
 421         if( HIWORD( dwIoControlCode ) == 0 )
 422         {
 423                 const struct VxDInfo *info;
 424                 if (!(info = DEVICE_GetInfo( clientID )))
 425                 {
 426                         FIXME( "No device found for id %lx\n", clientID);
 427                 }
 428                 else if ( info->deviceio )
 429                 {
 430                         return info->deviceio( dwIoControlCode,
 431                                         lpvInBuffer, cbInBuffer,
 432                                         lpvOutBuffer, cbOutBuffer,
 433                                         lpcbBytesReturned, lpOverlapped );
 434                 }
 435                 else
 436                 {
 437                         FIXME( "Unimplemented control %ld for VxD device %s\n",
 438                                dwIoControlCode, info->name ? info->name : "???" );
 439                         /* FIXME: this is for invalid calls on W98SE,
 440                          * but maybe we should use ERROR_CALL_NOT_IMPLEMENTED
 441                          * instead ? */
 442                         SetLastError( ERROR_INVALID_FUNCTION );
 443                 }
 444         }
 445         else
 446         {
 447                 char str[3];
 448
 449                 strcpy(str,  "A:");
 450                 str[0] += LOBYTE(clientID);
 451                 if (GetDriveTypeA(str) == DRIVE_CDROM)
 452                     return CDROM_DeviceIoControl(clientID, hDevice, dwIoControlCode, lpvInBuffer, cbInBuffer,
 453                                                  lpvOutBuffer, cbOutBuffer, lpcbBytesReturned,
 454                                                  lpOverlapped);
 455                 else switch( dwIoControlCode )
 456                 {
 457                 case FSCTL_DELETE_REPARSE_POINT:
 458                 case FSCTL_DISMOUNT_VOLUME:
 459                 case FSCTL_GET_COMPRESSION:
 460                 case FSCTL_GET_REPARSE_POINT:
 461                 case FSCTL_LOCK_VOLUME:
 462                 case FSCTL_QUERY_ALLOCATED_RANGES:
 463                 case FSCTL_SET_COMPRESSION:
 464                 case FSCTL_SET_REPARSE_POINT:
 465                 case FSCTL_SET_SPARSE:
 466                 case FSCTL_SET_ZERO_DATA:
 467                 case FSCTL_UNLOCK_VOLUME:
 468                 case IOCTL_DISK_CHECK_VERIFY:
 469                 case IOCTL_DISK_EJECT_MEDIA:
 470                 case IOCTL_DISK_FORMAT_TRACKS:
 471                 case IOCTL_DISK_GET_DRIVE_GEOMETRY:
 472                 case IOCTL_DISK_GET_DRIVE_LAYOUT:
 473                 case IOCTL_DISK_GET_MEDIA_TYPES:
 474                 case IOCTL_DISK_GET_PARTITION_INFO:
 475                 case IOCTL_DISK_LOAD_MEDIA:
 476                 case IOCTL_DISK_MEDIA_REMOVAL:
 477                 case IOCTL_DISK_PERFORMANCE:
 478                 case IOCTL_DISK_REASSIGN_BLOCKS:
 479                 case IOCTL_DISK_SET_DRIVE_LAYOUT:
 480                 case IOCTL_DISK_SET_PARTITION_INFO:
 481                 case IOCTL_DISK_VERIFY:
 482                 case IOCTL_SERIAL_LSRMST_INSERT:
 483                 case IOCTL_STORAGE_CHECK_VERIFY:
 484                 case IOCTL_STORAGE_EJECT_MEDIA:
 485                 case IOCTL_STORAGE_GET_MEDIA_TYPES:
 486                 case IOCTL_STORAGE_LOAD_MEDIA:
 487                 case IOCTL_STORAGE_MEDIA_REMOVAL:
 488                         FIXME( "unimplemented dwIoControlCode=%08lx\n", dwIoControlCode);
 489                         SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 490                         return FALSE;
 491                         break;
 492                 default:
 493                         FIXME( "ignored dwIoControlCode=%08lx\n",dwIoControlCode);
 494                         SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 495                         return FALSE;
 496                         break;
 497                 }
 498         }
 499         return FALSE;
 500 }
 501
 502 /***********************************************************************
 503  *           DeviceIo_VTDAPI
 504  */
 505 static BOOL DeviceIo_VTDAPI(DWORD dwIoControlCode, LPVOID lpvInBuffer, DWORD cbInBuffer,
 506                               LPVOID lpvOutBuffer, DWORD cbOutBuffer,
 507                               LPDWORD lpcbBytesReturned,
 508                               LPOVERLAPPED lpOverlapped)
 509 {
 510     BOOL retv = TRUE;
 511
 512     switch (dwIoControlCode)
 513     {
 514     case 5:
 515         if (lpvOutBuffer && (cbOutBuffer>=4))
 516             *(DWORD*)lpvOutBuffer = GetTickCount();
 517
 518         if (lpcbBytesReturned)
 519             *lpcbBytesReturned = 4;
 520
 521         break;
 522
 523     default:
 524         FIXME( "Control %ld not implemented\n", dwIoControlCode);
 525         retv = FALSE;
 526         break;
 527     }
 528
 529     return retv;
 530 }
 531
 532 /***********************************************************************
 533  *              VxDCall0 (KERNEL32.1)
 534  *              VxDCall1 (KERNEL32.2)
 535  *              VxDCall2 (KERNEL32.3)
 536  *              VxDCall3 (KERNEL32.4)
 537  *              VxDCall4 (KERNEL32.5)
 538  *              VxDCall5 (KERNEL32.6)
 539  *              VxDCall6 (KERNEL32.7)
 540  *              VxDCall7 (KERNEL32.8)
 541  *              VxDCall8 (KERNEL32.9)
 542  */
 543 void VxDCall( DWORD service, CONTEXT86 *context )
 544 {
 545     DWORD ret = 0xffffffff; /* FIXME */
 546     int i;
 547
 548     TRACE( "(%08lx, ...)\n", service);
 549
 550     for (i = 0; VxDList[i].name; i++)
 551         if (VxDList[i].id == HIWORD(service))
 552             break;
 553
 554     if (!VxDList[i].name)
 555         FIXME( "Unknown VxD (%08lx)\n", service);
 556     else if (!VxDList[i].vxdcall)
 557         FIXME( "Unimplemented VxD (%08lx)\n", service);
 558     else
 559         ret = VxDList[i].vxdcall( service, context );
 560
 561     context->Eax = ret;
 562 }
 563
 564
 565 /***********************************************************************
 566  *           VxDCall_VMM
 567  */
 568 static DWORD VxDCall_VMM( DWORD service, CONTEXT86 *context )
 569 {
 570     switch ( LOWORD(service) )
 571     {
 572     case 0x0011:  /* RegOpenKey */
 573     {
 574         HKEY    hkey       = (HKEY)  stack32_pop( context );
 575         LPCSTR  lpszSubKey = (LPCSTR)stack32_pop( context );
 576         LPHKEY  retkey     = (LPHKEY)stack32_pop( context );
 577         return RegOpenKeyA( hkey, lpszSubKey, retkey );
 578     }
 579
 580     case 0x0012:  /* RegCreateKey */
 581     {
 582         HKEY    hkey       = (HKEY)  stack32_pop( context );
 583         LPCSTR  lpszSubKey = (LPCSTR)stack32_pop( context );
 584         LPHKEY  retkey     = (LPHKEY)stack32_pop( context );
 585         return RegCreateKeyA( hkey, lpszSubKey, retkey );
 586     }
 587
 588     case 0x0013:  /* RegCloseKey */
 589     {
 590         HKEY    hkey       = (HKEY)stack32_pop( context );
 591         return RegCloseKey( hkey );
 592     }
 593
 594     case 0x0014:  /* RegDeleteKey */
 595     {
 596         HKEY    hkey       = (HKEY)  stack32_pop( context );
 597         LPCSTR  lpszSubKey = (LPCSTR)stack32_pop( context );
 598         return RegDeleteKeyA( hkey, lpszSubKey );
 599     }
 600
 601     case 0x0015:  /* RegSetValue */
 602     {
 603         HKEY    hkey       = (HKEY)  stack32_pop( context );
 604         LPCSTR  lpszSubKey = (LPCSTR)stack32_pop( context );
 605         DWORD   dwType     = (DWORD) stack32_pop( context );
 606         LPCSTR  lpszData   = (LPCSTR)stack32_pop( context );
 607         DWORD   cbData     = (DWORD) stack32_pop( context );
 608         return RegSetValueA( hkey, lpszSubKey, dwType, lpszData, cbData );
 609     }
 610
 611     case 0x0016:  /* RegDeleteValue */
 612     {
 613         HKEY    hkey       = (HKEY) stack32_pop( context );
 614         LPSTR   lpszValue  = (LPSTR)stack32_pop( context );
 615         return RegDeleteValueA( hkey, lpszValue );
 616     }
 617
 618     case 0x0017:  /* RegQueryValue */
 619     {
 620         HKEY    hkey       = (HKEY)   stack32_pop( context );
 621         LPSTR   lpszSubKey = (LPSTR)  stack32_pop( context );
 622         LPSTR   lpszData   = (LPSTR)  stack32_pop( context );
 623         LPDWORD lpcbData   = (LPDWORD)stack32_pop( context );
 624         return RegQueryValueA( hkey, lpszSubKey, lpszData, lpcbData );
 625     }
 626
 627     case 0x0018:  /* RegEnumKey */
 628     {
 629         HKEY    hkey       = (HKEY) stack32_pop( context );
 630         DWORD   iSubkey    = (DWORD)stack32_pop( context );
 631         LPSTR   lpszName   = (LPSTR)stack32_pop( context );
 632         DWORD   lpcchName  = (DWORD)stack32_pop( context );
 633         return RegEnumKeyA( hkey, iSubkey, lpszName, lpcchName );
 634     }
 635
 636     case 0x0019:  /* RegEnumValue */
 637     {
 638         HKEY    hkey       = (HKEY)   stack32_pop( context );
 639         DWORD   iValue     = (DWORD)  stack32_pop( context );
 640         LPSTR   lpszValue  = (LPSTR)  stack32_pop( context );
 641         LPDWORD lpcchValue = (LPDWORD)stack32_pop( context );
 642         LPDWORD lpReserved = (LPDWORD)stack32_pop( context );
 643         LPDWORD lpdwType   = (LPDWORD)stack32_pop( context );
 644         LPBYTE  lpbData    = (LPBYTE) stack32_pop( context );
 645         LPDWORD lpcbData   = (LPDWORD)stack32_pop( context );
 646         return RegEnumValueA( hkey, iValue, lpszValue, lpcchValue,
 647                               lpReserved, lpdwType, lpbData, lpcbData );
 648     }
 649
 650     case 0x001A:  /* RegQueryValueEx */
 651     {
 652         HKEY    hkey       = (HKEY)   stack32_pop( context );
 653         LPSTR   lpszValue  = (LPSTR)  stack32_pop( context );
 654         LPDWORD lpReserved = (LPDWORD)stack32_pop( context );
 655         LPDWORD lpdwType   = (LPDWORD)stack32_pop( context );
 656         LPBYTE  lpbData    = (LPBYTE) stack32_pop( context );
 657         LPDWORD lpcbData   = (LPDWORD)stack32_pop( context );
 658         return RegQueryValueExA( hkey, lpszValue, lpReserved,
 659                                  lpdwType, lpbData, lpcbData );
 660     }
 661
 662     case 0x001B:  /* RegSetValueEx */
 663     {
 664         HKEY    hkey       = (HKEY)  stack32_pop( context );
 665         LPSTR   lpszValue  = (LPSTR) stack32_pop( context );
 666         DWORD   dwReserved = (DWORD) stack32_pop( context );
 667         DWORD   dwType     = (DWORD) stack32_pop( context );
 668         LPBYTE  lpbData    = (LPBYTE)stack32_pop( context );
 669         DWORD   cbData     = (DWORD) stack32_pop( context );
 670         return RegSetValueExA( hkey, lpszValue, dwReserved,
 671                                dwType, lpbData, cbData );
 672     }
 673
 674     case 0x001C:  /* RegFlushKey */
 675     {
 676         HKEY    hkey       = (HKEY)stack32_pop( context );
 677         return RegFlushKey( hkey );
 678     }
 679
 680     case 0x001D:  /* RegQueryInfoKey */
 681     {
 682         /* NOTE: This VxDCall takes only a subset of the parameters that the
 683                  corresponding Win32 API call does. The implementation in Win95
 684                  ADVAPI32 sets all output parameters not mentioned here to zero. */
 685
 686         HKEY    hkey              = (HKEY)   stack32_pop( context );
 687         LPDWORD lpcSubKeys        = (LPDWORD)stack32_pop( context );
 688         LPDWORD lpcchMaxSubKey    = (LPDWORD)stack32_pop( context );
 689         LPDWORD lpcValues         = (LPDWORD)stack32_pop( context );
 690         LPDWORD lpcchMaxValueName = (LPDWORD)stack32_pop( context );
 691         LPDWORD lpcchMaxValueData = (LPDWORD)stack32_pop( context );
 692         return RegQueryInfoKeyA( hkey, NULL, NULL, NULL, lpcSubKeys, lpcchMaxSubKey,
 693                                  NULL, lpcValues, lpcchMaxValueName, lpcchMaxValueData,
 694                                  NULL, NULL );
 695     }
 696
 697     case 0x0021:  /* RegLoadKey */
 698     {
 699         HKEY    hkey       = (HKEY)  stack32_pop( context );
 700         LPCSTR  lpszSubKey = (LPCSTR)stack32_pop( context );
 701         LPCSTR  lpszFile   = (LPCSTR)stack32_pop( context );
 702         return RegLoadKeyA( hkey, lpszSubKey, lpszFile );
 703     }
 704
 705     case 0x0022:  /* RegUnLoadKey */
 706     {
 707         HKEY    hkey       = (HKEY)  stack32_pop( context );
 708         LPCSTR  lpszSubKey = (LPCSTR)stack32_pop( context );
 709         return RegUnLoadKeyA( hkey, lpszSubKey );
 710     }
 711
 712     case 0x0023:  /* RegSaveKey */
 713     {
 714         HKEY    hkey       = (HKEY)  stack32_pop( context );
 715         LPCSTR  lpszFile   = (LPCSTR)stack32_pop( context );
 716         LPSECURITY_ATTRIBUTES sa = (LPSECURITY_ATTRIBUTES)stack32_pop( context );
 717         return RegSaveKeyA( hkey, lpszFile, sa );
 718     }
 719
 720 #if 0 /* Functions are not yet implemented in misc/registry.c */
 721     case 0x0024:  /* RegRemapPreDefKey */
 722     case 0x0026:  /* RegQueryMultipleValues */
 723 #endif
 724
 725     case 0x0027:  /* RegReplaceKey */
 726     {
 727         HKEY    hkey       = (HKEY)  stack32_pop( context );
 728         LPCSTR  lpszSubKey = (LPCSTR)stack32_pop( context );
 729         LPCSTR  lpszNewFile= (LPCSTR)stack32_pop( context );
 730         LPCSTR  lpszOldFile= (LPCSTR)stack32_pop( context );
 731         return RegReplaceKeyA( hkey, lpszSubKey, lpszNewFile, lpszOldFile );
 732     }
 733     case 0x0000: /* PageReserve */
 734       {
 735         LPVOID address;
 736         LPVOID ret;
 737         DWORD psize = getpagesize();
 738         ULONG page   = (ULONG) stack32_pop( context );
 739         ULONG npages = (ULONG) stack32_pop( context );
 740         ULONG flags  = (ULONG) stack32_pop( context );
 741
 742         TRACE("PageReserve: page: %08lx, npages: %08lx, flags: %08lx partial stub!\n",
 743               page, npages, flags );
 744
 745         if ( page == PR_SYSTEM ) {
 746           ERR("Can't reserve ring 1 memory\n");
 747           return -1;
 748         }
 749         /* FIXME: This has to be handled separately for the separate
 750            address-spaces we now have */
 751         if ( page == PR_PRIVATE || page == PR_SHARED ) page = 0;
 752         /* FIXME: Handle flags in some way */
 753         address = (LPVOID )(page * psize);
 754         ret = VirtualAlloc ( address, ( npages * psize ), MEM_RESERVE, 0 );
 755         TRACE("PageReserve: returning: %08lx\n", (DWORD )ret );
 756         if ( ret == NULL )
 757           return -1;
 758         else
 759           return (DWORD )ret;
 760       }
 761
 762     case 0x0001: /* PageCommit */
 763       {
 764         LPVOID address;
 765         LPVOID ret;
 766         DWORD virt_perm;
 767         DWORD psize = getpagesize();
 768         ULONG page   = (ULONG) stack32_pop( context );
 769         ULONG npages = (ULONG) stack32_pop( context );
 770         ULONG hpd  = (ULONG) stack32_pop( context );
 771         ULONG pagerdata   = (ULONG) stack32_pop( context );
 772         ULONG flags  = (ULONG) stack32_pop( context );
 773
 774         TRACE("PageCommit: page: %08lx, npages: %08lx, hpd: %08lx pagerdata: "
 775               "%08lx, flags: %08lx partial stub\n",
 776               page, npages, hpd, pagerdata, flags );
 777
 778         if ( flags & PC_USER )
 779           if ( flags & PC_WRITEABLE )
 780             virt_perm = PAGE_EXECUTE_READWRITE;
 781           else
 782             virt_perm = PAGE_EXECUTE_READ;
 783         else
 784           virt_perm = PAGE_NOACCESS;
 785
 786         address = (LPVOID )(page * psize);
 787         ret = VirtualAlloc ( address, ( npages * psize ), MEM_COMMIT, virt_perm );
 788         TRACE("PageCommit: Returning: %08lx\n", (DWORD )ret );
 789         return (DWORD )ret;
 790
 791       }
 792     case 0x0002: /* PageDecommit */
 793       {
 794         LPVOID address;
 795         BOOL ret;
 796         DWORD psize = getpagesize();
 797         ULONG page = (ULONG) stack32_pop( context );
 798         ULONG npages = (ULONG) stack32_pop( context );
 799         ULONG flags = (ULONG) stack32_pop( context );
 800
 801         TRACE("PageDecommit: page: %08lx, npages: %08lx, flags: %08lx partial stub\n",
 802               page, npages, flags );
 803         address = (LPVOID )( page * psize );
 804         ret = VirtualFree ( address, ( npages * psize ), MEM_DECOMMIT );
 805         TRACE("PageDecommit: Returning: %s\n", ret ? "TRUE" : "FALSE" );
 806         return ret;
 807       }
 808     case 0x000d: /* PageModifyPermissions */
 809       {
 810         DWORD pg_old_perm;
 811         DWORD pg_new_perm;
 812         DWORD virt_old_perm;
 813         DWORD virt_new_perm;
 814         MEMORY_BASIC_INFORMATION mbi;
 815         LPVOID address;
 816         DWORD psize = getpagesize();
 817         ULONG page = stack32_pop ( context );
 818         ULONG npages = stack32_pop ( context );
 819         ULONG permand = stack32_pop ( context );
 820         ULONG permor = stack32_pop ( context );
 821
 822         TRACE("PageModifyPermissions %08lx %08lx %08lx %08lx partial stub\n",
 823               page, npages, permand, permor );
 824         address = (LPVOID )( page * psize );
 825
 826         VirtualQuery ( address, &mbi, sizeof ( MEMORY_BASIC_INFORMATION ));
 827         virt_old_perm = mbi.Protect;
 828
 829         switch ( virt_old_perm & mbi.Protect ) {
 830         case PAGE_READONLY:
 831         case PAGE_EXECUTE:
 832         case PAGE_EXECUTE_READ:
 833           pg_old_perm = PC_USER;
 834           break;
 835         case PAGE_READWRITE:
 836         case PAGE_WRITECOPY:
 837         case PAGE_EXECUTE_READWRITE:
 838         case PAGE_EXECUTE_WRITECOPY:
 839           pg_old_perm = PC_USER | PC_WRITEABLE;
 840           break;
 841         case PAGE_NOACCESS:
 842         default:
 843           pg_old_perm = 0;
 844           break;
 845         }
 846         pg_new_perm = pg_old_perm;
 847         pg_new_perm &= permand & ~PC_STATIC;
 848         pg_new_perm |= permor  & ~PC_STATIC;
 849
 850         virt_new_perm = ( virt_old_perm )  & ~0xff;
 851         if ( pg_new_perm & PC_USER )
 852         {
 853           if ( pg_new_perm & PC_WRITEABLE )
 854             virt_new_perm |= PAGE_EXECUTE_READWRITE;
 855           else
 856             virt_new_perm |= PAGE_EXECUTE_READ;
 857         }
 858
 859         if ( ! VirtualProtect ( address, ( npages * psize ), virt_new_perm, &virt_old_perm ) ) {
 860           ERR("Can't change page permissions for %08lx\n", (DWORD )address );
 861           return 0xffffffff;
 862         }
 863         TRACE("Returning: %08lx\n", pg_old_perm );
 864         return pg_old_perm;
 865       }
 866     case 0x000a: /* PageFree */
 867       {
 868         BOOL ret;
 869         LPVOID hmem = (LPVOID) stack32_pop( context );
 870         DWORD flags = (DWORD ) stack32_pop( context );
 871
 872         TRACE("PageFree: hmem: %08lx, flags: %08lx partial stub\n",
 873               (DWORD )hmem, flags );
 874
 875         ret = VirtualFree ( hmem, 0, MEM_RELEASE );
 876         context->Eax = ret;
 877         TRACE("Returning: %d\n", ret );
 878
 879         return 0;
 880       }
 881     case 0x001e: /* GetDemandPageInfo */
 882       {
 883          DWORD dinfo = (DWORD)stack32_pop( context );
 884          DWORD flags = (DWORD)stack32_pop( context );
 885
 886          /* GetDemandPageInfo is supposed to fill out the struct at
 887           * "dinfo" with various low-level memory management information.
 888           * Apps are certainly not supposed to call this, although it's
 889           * demoed and documented by Pietrek on pages 441-443 of "Windows
 890           * 95 System Programming Secrets" if any program needs a real
 891           * implementation of this.
 892           */
 893
 894          FIXME("GetDemandPageInfo(%08lx %08lx): stub!\n", dinfo, flags);
 895
 896          return 0;
 897       }
 898     default:
 899         if (LOWORD(service) < N_VMM_SERVICE)
 900             FIXME( "Unimplemented service %s (%08lx)\n",
 901                           VMM_Service_Name[LOWORD(service)], service);
 902         else
 903             FIXME( "Unknown service %08lx\n", service);
 904         break;
 905     }
 906
 907     return 0xffffffff;  /* FIXME */
 908 }
 909
 910 /***********************************************************************
 911  *           DeviceIo_IFSMgr
 912  * NOTES
 913  *   These ioctls are used by 'MSNET32.DLL'.
 914  *
 915  *   I have been unable to uncover any documentation about the ioctls so
 916  *   the implementation of the cases IFS_IOCTL_21 and IFS_IOCTL_2F are
 917  *   based on reasonable guesses on information found in the Windows 95 DDK.
 918  *
 919  */
 920
 921 /*
 922  * IFSMgr DeviceIO service
 923  */
 924
 925 #define IFS_IOCTL_21                100
 926 #define IFS_IOCTL_2F                101
 927 #define IFS_IOCTL_GET_RES           102
 928 #define IFS_IOCTL_GET_NETPRO_NAME_A 103
 929
 930 struct win32apireq {
 931         unsigned long   ar_proid;
 932         unsigned long   ar_eax;
 933         unsigned long   ar_ebx;
 934         unsigned long   ar_ecx;
 935         unsigned long   ar_edx;
 936         unsigned long   ar_esi;
 937         unsigned long   ar_edi;
 938         unsigned long   ar_ebp;
 939         unsigned short  ar_error;
 940         unsigned short  ar_pad;
 941 };
 942
 943 static void win32apieq_2_CONTEXT(struct win32apireq *pIn,CONTEXT86 *pCxt)
 944 {
 945         memset(pCxt,0,sizeof(*pCxt));
 946
 947         pCxt->ContextFlags=CONTEXT86_INTEGER|CONTEXT86_CONTROL;
 948         pCxt->Eax = pIn->ar_eax;
 949         pCxt->Ebx = pIn->ar_ebx;
 950         pCxt->Ecx = pIn->ar_ecx;
 951         pCxt->Edx = pIn->ar_edx;
 952         pCxt->Esi = pIn->ar_esi;
 953         pCxt->Edi = pIn->ar_edi;
 954
 955         /* FIXME: Only partial CONTEXT86_CONTROL */
 956         pCxt->Ebp = pIn->ar_ebp;
 957
 958         /* FIXME: pIn->ar_proid ignored */
 959         /* FIXME: pIn->ar_error ignored */
 960         /* FIXME: pIn->ar_pad ignored */
 961 }
 962
 963 static void CONTEXT_2_win32apieq(CONTEXT86 *pCxt,struct win32apireq *pOut)
 964 {
 965         memset(pOut,0,sizeof(struct win32apireq));
 966
 967         pOut->ar_eax = pCxt->Eax;
 968         pOut->ar_ebx = pCxt->Ebx;
 969         pOut->ar_ecx = pCxt->Ecx;
 970         pOut->ar_edx = pCxt->Edx;
 971         pOut->ar_esi = pCxt->Esi;
 972         pOut->ar_edi = pCxt->Edi;
 973
 974         /* FIXME: Only partial CONTEXT86_CONTROL */
 975         pOut->ar_ebp = pCxt->Ebp;
 976
 977         /* FIXME: pOut->ar_proid ignored */
 978         /* FIXME: pOut->ar_error ignored */
 979         /* FIXME: pOut->ar_pad ignored */
 980 }
 981
 982 static BOOL DeviceIo_IFSMgr(DWORD dwIoControlCode, LPVOID lpvInBuffer, DWORD cbInBuffer,
 983                               LPVOID lpvOutBuffer, DWORD cbOutBuffer,
 984                               LPDWORD lpcbBytesReturned,
 985                               LPOVERLAPPED lpOverlapped)
 986 {
 987     BOOL retv = TRUE;
 988         TRACE("(%ld,%p,%ld,%p,%ld,%p,%p): stub\n",
 989                         dwIoControlCode,
 990                         lpvInBuffer,cbInBuffer,
 991                         lpvOutBuffer,cbOutBuffer,
 992                         lpcbBytesReturned,
 993                         lpOverlapped);
 994
 995     switch (dwIoControlCode)
 996     {
 997         case IFS_IOCTL_21:
 998         case IFS_IOCTL_2F:{
 999                 CONTEXT86 cxt;
1000                 struct win32apireq *pIn=(struct win32apireq *) lpvInBuffer;
1001                 struct win32apireq *pOut=(struct win32apireq *) lpvOutBuffer;
1002
1003                 TRACE(
1004                         "Control '%s': "
1005                         "proid=0x%08lx, eax=0x%08lx, ebx=0x%08lx, ecx=0x%08lx, "
1006                         "edx=0x%08lx, esi=0x%08lx, edi=0x%08lx, ebp=0x%08lx, "
1007                         "error=0x%04x, pad=0x%04x\n",
1008                         (dwIoControlCode==IFS_IOCTL_21)?"IFS_IOCTL_21":"IFS_IOCTL_2F",
1009                         pIn->ar_proid, pIn->ar_eax, pIn->ar_ebx, pIn->ar_ecx,
1010                         pIn->ar_edx, pIn->ar_esi, pIn->ar_edi, pIn->ar_ebp,
1011                         pIn->ar_error, pIn->ar_pad
1012                 );
1013
1014                 win32apieq_2_CONTEXT(pIn,&cxt);
1015
1016                 if(dwIoControlCode==IFS_IOCTL_21)
1017                 {
1018                         DOS3Call(&cxt); /* Call int 21h */
1019                 } else {
1020                         INT_Int2fHandler(&cxt); /* Call int 2Fh */
1021                 }
1022
1023                 CONTEXT_2_win32apieq(&cxt,pOut);
1024
1025         retv = TRUE;
1026         } break;
1027         case IFS_IOCTL_GET_RES:{
1028         FIXME( "Control 'IFS_IOCTL_GET_RES' not implemented\n");
1029         retv = FALSE;
1030         } break;
1031         case IFS_IOCTL_GET_NETPRO_NAME_A:{
1032         FIXME( "Control 'IFS_IOCTL_GET_NETPRO_NAME_A' not implemented\n");
1033         retv = FALSE;
1034         } break;
1035     default:
1036         FIXME( "Control %ld not implemented\n", dwIoControlCode);
1037         retv = FALSE;
1038     }
1039
1040     return retv;
1041 }
1042
1043 /********************************************************************************
1044  *      VxDCall_VWin32
1045  *
1046  *  Service numbers taken from page 448 of Pietrek's "Windows 95 System
1047  *  Programming Secrets".  Parameters from experimentation on real Win98.
1048  *
1049  */
1050
1051 static DWORD VxDCall_VWin32( DWORD service, CONTEXT86 *context )
1052 {
1053   switch ( LOWORD(service) )
1054     {
1055     case 0x0000: /* GetVersion */
1056     {
1057         DWORD vers = GetVersion();
1058         return (LOBYTE(vers) << 8) | HIBYTE(vers);
1059     }
1060     break;
1061
1062     case 0x0020: /* Get VMCPD Version */
1063     {
1064         DWORD parm = (DWORD) stack32_pop(context);
1065
1066         FIXME("Get VMCPD Version(%08lx): partial stub!\n", parm);
1067
1068         /* FIXME: This is what Win98 returns, it may
1069          *        not be correct in all situations.
1070          *        It makes Bleem! happy though.
1071          */
1072
1073         return 0x0405;
1074     }
1075
1076     case 0x0029: /* Int31/DPMI dispatch */
1077     {
1078         DWORD callnum = (DWORD) stack32_pop(context);
1079         DWORD parm    = (DWORD) stack32_pop(context);
1080
1081         TRACE("Int31/DPMI dispatch(%08lx)\n", callnum);
1082
1083         AX_reg(context) = callnum;
1084         CX_reg(context) = parm;
1085         INT_Int31Handler(context);
1086
1087         return LOWORD(context->Eax);
1088     }
1089     break;
1090
1091     case 0x002a: /* Int41 dispatch - parm = int41 service number */
1092     {
1093         DWORD callnum = (DWORD) stack32_pop(context);
1094
1095         return callnum; /* FIXME: should really call INT_Int41Handler() */
1096     }
1097     break;
1098
1099     default:
1100       FIXME("Unknown VWin32 service %08lx\n", service);
1101       break;
1102     }
1103
1104   return 0xffffffff;
1105 }
1106
1107
1108 /***********************************************************************
1109  *           DeviceIo_VCD
1110  */
1111 static BOOL DeviceIo_VCD(DWORD dwIoControlCode,
1112                               LPVOID lpvInBuffer, DWORD cbInBuffer,
1113                               LPVOID lpvOutBuffer, DWORD cbOutBuffer,
1114                               LPDWORD lpcbBytesReturned,
1115                               LPOVERLAPPED lpOverlapped)
1116 {
1117     BOOL retv = TRUE;
1118
1119     switch (dwIoControlCode)
1120     {
1121     case IOCTL_SERIAL_LSRMST_INSERT:
1122     {
1123         FIXME( "IOCTL_SERIAL_LSRMST_INSERT NIY !\n");
1124         retv = FALSE;
1125     }
1126     break;
1127
1128     default:
1129         FIXME( "Unknown Control %ld\n", dwIoControlCode);
1130         retv = FALSE;
1131         break;
1132     }
1133
1134     return retv;
1135 }
1136
1137
1138 /***********************************************************************
1139  *           DeviceIo_VWin32
1140  */
1141
1142 static void DIOCRegs_2_CONTEXT( DIOC_REGISTERS *pIn, CONTEXT86 *pCxt )
1143 {
1144     memset( pCxt, 0, sizeof(*pCxt) );
1145     /* Note: segment registers == 0 means that CTX_SEG_OFF_TO_LIN
1146              will interpret 32-bit register contents as linear pointers */
1147
1148     pCxt->ContextFlags=CONTEXT86_INTEGER|CONTEXT86_CONTROL;
1149     pCxt->Eax = pIn->reg_EAX;
1150     pCxt->Ebx = pIn->reg_EBX;
1151     pCxt->Ecx = pIn->reg_ECX;
1152     pCxt->Edx = pIn->reg_EDX;
1153     pCxt->Esi = pIn->reg_ESI;
1154     pCxt->Edi = pIn->reg_EDI;
1155
1156     /* FIXME: Only partial CONTEXT86_CONTROL */
1157     pCxt->EFlags = pIn->reg_Flags;
1158 }
1159
1160 static void CONTEXT_2_DIOCRegs( CONTEXT86 *pCxt, DIOC_REGISTERS *pOut )
1161 {
1162     memset( pOut, 0, sizeof(DIOC_REGISTERS) );
1163
1164     pOut->reg_EAX = pCxt->Eax;
1165     pOut->reg_EBX = pCxt->Ebx;
1166     pOut->reg_ECX = pCxt->Ecx;
1167     pOut->reg_EDX = pCxt->Edx;
1168     pOut->reg_ESI = pCxt->Esi;
1169     pOut->reg_EDI = pCxt->Edi;
1170
1171     /* FIXME: Only partial CONTEXT86_CONTROL */
1172     pOut->reg_Flags = pCxt->EFlags;
1173 }
1174
1175 #define DIOC_AH(regs) (((unsigned char*)&((regs)->reg_EAX))[1])
1176 #define DIOC_AL(regs) (((unsigned char*)&((regs)->reg_EAX))[0])
1177 #define DIOC_BH(regs) (((unsigned char*)&((regs)->reg_EBX))[1])
1178 #define DIOC_BL(regs) (((unsigned char*)&((regs)->reg_EBX))[0])
1179 #define DIOC_DH(regs) (((unsigned char*)&((regs)->reg_EDX))[1])
1180 #define DIOC_DL(regs) (((unsigned char*)&((regs)->reg_EDX))[0])
1181
1182 #define DIOC_AX(regs) (((unsigned short*)&((regs)->reg_EAX))[0])
1183 #define DIOC_BX(regs) (((unsigned short*)&((regs)->reg_EBX))[0])
1184 #define DIOC_CX(regs) (((unsigned short*)&((regs)->reg_ECX))[0])
1185 #define DIOC_DX(regs) (((unsigned short*)&((regs)->reg_EDX))[0])
1186
1187 #define DIOC_SET_CARRY(regs) (((regs)->reg_Flags)|=0x00000001)
1188
1189 static const DWORD VWIN32_DriveTypeInfo[7]={
1190     0x0000, /* none */
1191     0x2709, /* 360 K */
1192     0x4f0f, /* 1.2 M */
1193     0x4f09, /* 720 K */
1194     0x4f12, /* 1.44 M */
1195     0x4f24, /* 2.88 M */
1196     0x4f24  /* 2.88 M */
1197 };
1198
1199 /**********************************************************************
1200  *          VWIN32_ReadFloppyParams
1201  *
1202  * Handler for int 13h (disk I/O).
1203  */
1204 static VOID VWIN32_ReadFloppyParams(DIOC_REGISTERS *regs)
1205 {
1206 #ifdef linux
1207     static BYTE floppy_params[2][13] =
1208     {
1209         { 0xaf, 0x02, 0x25, 0x02, 0x12, 0x1b, 0xff, 0x6c, 0xf6, 0x0f, 0x08 },
1210         { 0xaf, 0x02, 0x25, 0x02, 0x12, 0x1b, 0xff, 0x6c, 0xf6, 0x0f, 0x08 }
1211     };
1212
1213     unsigned int i, nr_of_drives = 0;
1214     BYTE drive_nr = DIOC_DL(regs);
1215     int floppy_fd,r;
1216     struct floppy_drive_params floppy_parm;
1217     char root[] = "A:\\";
1218
1219     TRACE("in  [ EDX=%08lx ]\n", regs->reg_EDX );
1220
1221     DIOC_AH(regs) = 0x00; /* success */
1222
1223     for (i = 0; i < MAX_DOS_DRIVES; i++, root[0]++)
1224         if (GetDriveTypeA(root) == DRIVE_REMOVABLE) nr_of_drives++;
1225     DIOC_DL(regs) = nr_of_drives;
1226
1227     if (drive_nr > 1) { /* invalid drive ? */
1228         DIOC_BX(regs) = 0;
1229         DIOC_CX(regs) = 0;
1230         DIOC_DH(regs) = 0;
1231         DIOC_SET_CARRY(regs);
1232         return;
1233     }
1234
1235     if ( (floppy_fd = DRIVE_OpenDevice( drive_nr, O_NONBLOCK)) == -1)
1236     {
1237         WARN("Can't determine floppy geometry !\n");
1238         DIOC_BX(regs) = 0;
1239         DIOC_CX(regs) = 0;
1240         DIOC_DH(regs) = 0;
1241         DIOC_SET_CARRY(regs);
1242         return;
1243     }
1244     r = ioctl(floppy_fd, FDGETDRVPRM, &floppy_parm);
1245
1246     close(floppy_fd);
1247
1248     if(r<0)
1249     {
1250         DIOC_SET_CARRY(regs);
1251         return;
1252     }
1253
1254     regs->reg_ECX = 0;
1255     DIOC_AL(regs) = 0;
1256     DIOC_BL(regs) = floppy_parm.cmos;
1257
1258     /* CH = low eight bits of max cyl
1259        CL = max sec nr (bits 5-0),
1260        hi two bits of max cyl (bits 7-6)
1261        DH = max head nr */
1262     if(DIOC_BL(regs) && (DIOC_BL(regs)<7))
1263     {
1264         DIOC_DH(regs) = 0x01;
1265         DIOC_CX(regs) = VWIN32_DriveTypeInfo[DIOC_BL(regs)];
1266     }
1267     else
1268     {
1269         DIOC_CX(regs) = 0x0;
1270         DIOC_DX(regs) = 0x0;
1271     }
1272
1273     regs->reg_EDI = (DWORD)floppy_params[drive_nr];
1274
1275     if(!regs->reg_EDI)
1276     {
1277         ERR("Get floppy params failed for drive %d\n",drive_nr);
1278         DIOC_SET_CARRY(regs);
1279     }
1280
1281     TRACE("out [ EAX=%08lx EBX=%08lx ECX=%08lx EDX=%08lx EDI=%08lx ]\n",
1282           regs->reg_EAX, regs->reg_EBX, regs->reg_ECX, regs->reg_EDX, regs->reg_EDI);
1283
1284     /* FIXME: Word exits quietly if we return with no error. Why? */
1285     FIXME("Returned ERROR!\n");
1286     DIOC_SET_CARRY(regs);
1287
1288 #else
1289     DIOC_AH(regs) = 0x01;
1290     DIOC_SET_CARRY(regs);
1291 #endif
1292 }
1293
1294 /**********************************************************************
1295  *          VWIN32_Int13Handler
1296  *
1297  * Handler for VWIN32_DIOC_DOS_INT13 (disk I/O).
1298  */
1299 static VOID VWIN32_Int13Handler( DIOC_REGISTERS *regs)
1300 {
1301     TRACE("AH=%02x\n",DIOC_AH(regs));
1302     switch(DIOC_AH(regs)) /* AH */
1303     {
1304     case 0x00:             /* RESET DISK SYSTEM     */
1305         break; /* no return ? */
1306
1307     case 0x01:             /* STATUS OF DISK SYSTEM */
1308         DIOC_AL(regs) = 0; /* successful completion */
1309         break;
1310
1311     case 0x02:             /* READ SECTORS INTO MEMORY */
1312         DIOC_AL(regs) = 0; /* number of sectors read */
1313         DIOC_AH(regs) = 0; /* status */
1314         break;
1315
1316     case 0x03:             /* WRITE SECTORS FROM MEMORY */
1317         break; /* no return ? */
1318
1319     case 0x04:             /* VERIFY DISK SECTOR(S) */
1320         DIOC_AL(regs) = 0; /* number of sectors verified */
1321         DIOC_AH(regs) = 0;
1322         break;
1323
1324     case 0x05:             /* FORMAT TRACK */
1325     case 0x06:             /* FORMAT TRACK AND SET BAD SECTOR FLAGS */
1326     case 0x07:             /* FORMAT DRIVE STARTING AT GIVEN TRACK  */
1327         /* despite what Ralf Brown says, 0x06 and 0x07 seem to
1328          * set CFLAG, too (at least my BIOS does that) */
1329         DIOC_AH(regs) = 0x0c;
1330         DIOC_SET_CARRY(regs);
1331         break;
1332
1333     case 0x08:             /* GET DRIVE PARAMETERS  */
1334         if (DIOC_DL(regs) & 0x80) { /* hard disk ? */
1335             DIOC_AH(regs) = 0x07;
1336             DIOC_SET_CARRY(regs);
1337         }
1338         else  /* floppy disk */
1339             VWIN32_ReadFloppyParams(regs);
1340         break;
1341
1342     case 0x09:         /* INITIALIZE CONTROLLER WITH DRIVE PARAMETERS */
1343     case 0x0a:         /* FIXED DISK - READ LONG (XT,AT,XT286,PS)     */
1344     case 0x0b:         /* FIXED DISK - WRITE LONG (XT,AT,XT286,PS)    */
1345     case 0x0c:         /* SEEK TO CYLINDER                            */
1346     case 0x0d:         /* ALTERNATE RESET HARD DISKS                  */
1347     case 0x10:         /* CHECK IF DRIVE READY                        */
1348     case 0x11:         /* RECALIBRATE DRIVE                           */
1349     case 0x14:         /* CONTROLLER INTERNAL DIAGNOSTIC              */
1350         DIOC_AH(regs) = 0;
1351         break;
1352
1353     case 0x15:         /* GET DISK TYPE (AT,XT2,XT286,CONV,PS) */
1354         if (DIOC_DL(regs) & 0x80) { /* hard disk ? */
1355             DIOC_AH(regs) = 3; /* fixed disk */
1356             DIOC_SET_CARRY(regs);
1357         }
1358         else { /* floppy disk ? */
1359             DIOC_AH(regs) = 2; /* floppy with change detection */
1360             DIOC_SET_CARRY(regs);
1361         }
1362         break;
1363
1364     case 0x0e:         /* READ SECTOR BUFFER (XT only)      */
1365     case 0x0f:         /* WRITE SECTOR BUFFER (XT only)     */
1366     case 0x12:         /* CONTROLLER RAM DIAGNOSTIC (XT,PS) */
1367     case 0x13:         /* DRIVE DIAGNOSTIC (XT,PS)          */
1368         DIOC_AH(regs) = 0x01;
1369         DIOC_SET_CARRY(regs);
1370         break;
1371
1372     case 0x16:         /* FLOPPY - CHANGE OF DISK STATUS */
1373         DIOC_AH(regs) = 0; /* FIXME - no change */
1374         break;
1375
1376     case 0x17:         /* SET DISK 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 0x18:         /* SET MEDIA TYPE FOR FORMAT */
1384         if (DIOC_DL(regs) < 4)
1385             DIOC_AH(regs) = 0x00; /* successful completion */
1386         else
1387             DIOC_AH(regs) = 0x01; /* error */
1388         break;
1389
1390     case 0x19:       /* FIXED DISK - PARK HEADS */
1391         break;
1392
1393     default:
1394         FIXME("Unknown VWIN32 INT13 call AX=%04X\n",DIOC_AX(regs));
1395     }
1396 }
1397
1398 static BOOL DeviceIo_VWin32(DWORD dwIoControlCode,
1399                               LPVOID lpvInBuffer, DWORD cbInBuffer,
1400                               LPVOID lpvOutBuffer, DWORD cbOutBuffer,
1401                               LPDWORD lpcbBytesReturned,
1402                               LPOVERLAPPED lpOverlapped)
1403 {
1404     BOOL retv = TRUE;
1405
1406     switch (dwIoControlCode)
1407     {
1408     case VWIN32_DIOC_DOS_INT13:
1409     {
1410         DIOC_REGISTERS *pIn  = (DIOC_REGISTERS *)lpvInBuffer;
1411         DIOC_REGISTERS *pOut = (DIOC_REGISTERS *)lpvOutBuffer;
1412
1413         memcpy(pOut, pIn, sizeof (DIOC_REGISTERS));
1414         VWIN32_Int13Handler(pOut);
1415         break;
1416     }
1417
1418     case VWIN32_DIOC_DOS_IOCTL:
1419     case 0x10: /* Int 0x21 call, call it VWIN_DIOC_INT21 ? */
1420     case VWIN32_DIOC_DOS_INT25:
1421     case VWIN32_DIOC_DOS_INT26:
1422     case 0x29: /* Int 0x31 call, call it VWIN_DIOC_INT31 ? */
1423     case VWIN32_DIOC_DOS_DRIVEINFO:
1424     {
1425         CONTEXT86 cxt;
1426         DIOC_REGISTERS *pIn  = (DIOC_REGISTERS *)lpvInBuffer;
1427         DIOC_REGISTERS *pOut = (DIOC_REGISTERS *)lpvOutBuffer;
1428
1429         TRACE( "Control '%s': "
1430                "eax=0x%08lx, ebx=0x%08lx, ecx=0x%08lx, "
1431                "edx=0x%08lx, esi=0x%08lx, edi=0x%08lx \n",
1432                (dwIoControlCode == VWIN32_DIOC_DOS_IOCTL)? "VWIN32_DIOC_DOS_IOCTL" :
1433                (dwIoControlCode == VWIN32_DIOC_DOS_INT25)? "VWIN32_DIOC_DOS_INT25" :
1434                (dwIoControlCode == VWIN32_DIOC_DOS_INT26)? "VWIN32_DIOC_DOS_INT26" :
1435                (dwIoControlCode == VWIN32_DIOC_DOS_DRIVEINFO)? "VWIN32_DIOC_DOS_DRIVEINFO" :  "???",
1436                pIn->reg_EAX, pIn->reg_EBX, pIn->reg_ECX,
1437                pIn->reg_EDX, pIn->reg_ESI, pIn->reg_EDI );
1438
1439         DIOCRegs_2_CONTEXT( pIn, &cxt );
1440
1441         switch (dwIoControlCode)
1442         {
1443         case VWIN32_DIOC_DOS_IOCTL: DOS3Call( &cxt ); break; /* Call int 21h */
1444         case VWIN32_DIOC_DOS_INT13: INT_Int13Handler( &cxt ); break;
1445         case 0x10: /* Int 0x21 call, call it VWIN_DIOC_INT21 ? */
1446                                     DOS3Call( &cxt ); break;
1447         case VWIN32_DIOC_DOS_INT25: INT_Int25Handler( &cxt ); break;
1448         case VWIN32_DIOC_DOS_INT26: INT_Int26Handler( &cxt ); break;
1449         case 0x29: /* Int 0x31 call, call it VWIN_DIOC_INT31 ? */
1450                                     INT_Int31Handler( &cxt ); break;
1451         case VWIN32_DIOC_DOS_DRIVEINFO: DOS3Call( &cxt ); break; /* Call int 21h 730x */
1452         }
1453
1454         CONTEXT_2_DIOCRegs( &cxt, pOut );
1455     }
1456     break;
1457
1458     case VWIN32_DIOC_SIMCTRLC:
1459         FIXME( "Control VWIN32_DIOC_SIMCTRLC not implemented\n");
1460         retv = FALSE;
1461         break;
1462
1463     default:
1464         FIXME( "Unknown Control %ld\n", dwIoControlCode);
1465         retv = FALSE;
1466         break;
1467     }
1468
1469     return retv;
1470 }
1471
1472 /* this is the main multimedia device loader */
1473 static BOOL DeviceIo_MMDEVLDR(DWORD dwIoControlCode,
1474                               LPVOID lpvInBuffer, DWORD cbInBuffer,
1475                               LPVOID lpvOutBuffer, DWORD cbOutBuffer,
1476                               LPDWORD lpcbBytesReturned,
1477                               LPOVERLAPPED lpOverlapped)
1478 {
1479         FIXME("(%ld,%p,%ld,%p,%ld,%p,%p): stub\n",
1480             dwIoControlCode,
1481             lpvInBuffer,cbInBuffer,
1482             lpvOutBuffer,cbOutBuffer,
1483             lpcbBytesReturned,
1484             lpOverlapped
1485         );
1486         switch (dwIoControlCode) {
1487         case 5:
1488                 /* Hmm. */
1489                 *(DWORD*)lpvOutBuffer=0;
1490                 *lpcbBytesReturned=4;
1491                 return TRUE;
1492         }
1493         return FALSE;
1494 }
1495 /* this is used by some Origin games */
1496 static BOOL DeviceIo_MONODEBG(DWORD dwIoControlCode,
1497                               LPVOID lpvInBuffer, DWORD cbInBuffer,
1498                               LPVOID lpvOutBuffer, DWORD cbOutBuffer,
1499                               LPDWORD lpcbBytesReturned,
1500                               LPOVERLAPPED lpOverlapped)
1501 {
1502         switch (dwIoControlCode) {
1503         case 1: /* version */
1504                 *(LPDWORD)lpvOutBuffer = 0x20004; /* WC SecretOps */
1505                 break;
1506         case 9: /* debug output */
1507                 ERR("MONODEBG: %s\n",debugstr_a(lpvInBuffer));
1508                 break;
1509         default:
1510                 FIXME("(%ld,%p,%ld,%p,%ld,%p,%p): stub\n",
1511                         dwIoControlCode,
1512                         lpvInBuffer,cbInBuffer,
1513                         lpvOutBuffer,cbOutBuffer,
1514                         lpcbBytesReturned,
1515                         lpOverlapped
1516                 );
1517                 break;
1518         }
1519         return TRUE;
1520 }
1521 /* pccard */
1522 static BOOL DeviceIo_PCCARD (DWORD dwIoControlCode,
1523                               LPVOID lpvInBuffer, DWORD cbInBuffer,
1524                               LPVOID lpvOutBuffer, DWORD cbOutBuffer,
1525                               LPDWORD lpcbBytesReturned,
1526                               LPOVERLAPPED lpOverlapped)
1527 {
1528         switch (dwIoControlCode) {
1529         case 0x0000: /* PCCARD_Get_Version */
1530         case 0x0001: /* PCCARD_Card_Services */
1531         default:
1532                 FIXME( "(%ld,%p,%ld,%p,%ld,%p,%p): stub\n",
1533                         dwIoControlCode,
1534                         lpvInBuffer,cbInBuffer,
1535                         lpvOutBuffer,cbOutBuffer,
1536                         lpcbBytesReturned,
1537                         lpOverlapped
1538                 );
1539                 break;
1540         }
1541         return FALSE;
1542 }
1543
1544 /***********************************************************************
1545  *              OpenVxDHandle (KERNEL32.@)
1546  *
1547  *      This function is supposed to return the corresponding Ring 0
1548  *      ("kernel") handle for a Ring 3 handle in Win9x.
1549  *      Evidently, Wine will have problems with this. But we try anyway,
1550  *      maybe it helps...
1551  */
1552 HANDLE  WINAPI  OpenVxDHandle(HANDLE hHandleRing3)
1553 {
1554         FIXME( "(0x%08x), stub! (returning Ring 3 handle instead of Ring 0)\n", hHandleRing3);
1555         return hHandleRing3;
1556 }
1557
1558 static BOOL DeviceIo_HASP(DWORD dwIoControlCode, LPVOID lpvInBuffer, DWORD cbInBuffer,
1559                               LPVOID lpvOutBuffer, DWORD cbOutBuffer,
1560                               LPDWORD lpcbBytesReturned,
1561                               LPOVERLAPPED lpOverlapped)
1562 {
1563     BOOL retv = TRUE;
1564         FIXME("(%ld,%p,%ld,%p,%ld,%p,%p): stub\n",
1565                         dwIoControlCode,
1566                         lpvInBuffer,cbInBuffer,
1567                         lpvOutBuffer,cbOutBuffer,
1568                         lpcbBytesReturned,
1569                         lpOverlapped);
1570
1571     return retv;
1572 }