2 * Win32 device functions
4 * Copyright 1998 Marcus Meissner
5 * Copyright 1998 Ulrich Weigand
6 * Copyright 1998 Patrik Stridvall
11 #include "wine/port.h"
15 #include <sys/types.h>
29 #include "stackframe.h"
30 #include "wine/server.h"
31 #include "debugtools.h"
33 DEFAULT_DEBUG_CHANNEL(win32
);
36 static BOOL
DeviceIo_VTDAPI(DWORD dwIoControlCode
,
37 LPVOID lpvInBuffer
, DWORD cbInBuffer
,
38 LPVOID lpvOutBuffer
, DWORD cbOutBuffer
,
39 LPDWORD lpcbBytesReturned
,
40 LPOVERLAPPED lpOverlapped
);
41 static BOOL
DeviceIo_MONODEBG(DWORD dwIoControlCode
,
42 LPVOID lpvInBuffer
, DWORD cbInBuffer
,
43 LPVOID lpvOutBuffer
, DWORD cbOutBuffer
,
44 LPDWORD lpcbBytesReturned
,
45 LPOVERLAPPED lpOverlapped
);
46 static BOOL
DeviceIo_MMDEVLDR(DWORD dwIoControlCode
,
47 LPVOID lpvInBuffer
, DWORD cbInBuffer
,
48 LPVOID lpvOutBuffer
, DWORD cbOutBuffer
,
49 LPDWORD lpcbBytesReturned
,
50 LPOVERLAPPED lpOverlapped
);
52 static DWORD
VxDCall_VMM( DWORD service
, CONTEXT86
*context
);
54 static BOOL
DeviceIo_IFSMgr(DWORD dwIoControlCode
,
55 LPVOID lpvInBuffer
, DWORD cbInBuffer
,
56 LPVOID lpvOutBuffer
, DWORD cbOutBuffer
,
57 LPDWORD lpcbBytesReturned
,
58 LPOVERLAPPED lpOverlapped
);
60 static BOOL
DeviceIo_VCD(DWORD dwIoControlCode
,
61 LPVOID lpvInBuffer
, DWORD cbInBuffer
,
62 LPVOID lpvOutBuffer
, DWORD cbOutBuffer
,
63 LPDWORD lpcbBytesReturned
,
64 LPOVERLAPPED lpOverlapped
);
66 static DWORD
VxDCall_VWin32( DWORD service
, CONTEXT86
*context
);
68 static BOOL
DeviceIo_VWin32(DWORD dwIoControlCode
,
69 LPVOID lpvInBuffer
, DWORD cbInBuffer
,
70 LPVOID lpvOutBuffer
, DWORD cbOutBuffer
,
71 LPDWORD lpcbBytesReturned
,
72 LPOVERLAPPED lpOverlapped
);
74 static BOOL
DeviceIo_PCCARD (DWORD dwIoControlCode
,
75 LPVOID lpvInBuffer
, DWORD cbInBuffer
,
76 LPVOID lpvOutBuffer
, DWORD cbOutBuffer
,
77 LPDWORD lpcbBytesReturned
,
78 LPOVERLAPPED lpOverlapped
);
80 static BOOL
DeviceIo_HASP (DWORD dwIoControlCode
,
81 LPVOID lpvInBuffer
, DWORD cbInBuffer
,
82 LPVOID lpvOutBuffer
, DWORD cbOutBuffer
,
83 LPDWORD lpcbBytesReturned
,
84 LPOVERLAPPED lpOverlapped
);
86 * VxD names are taken from the Win95 DDK
93 DWORD (*vxdcall
)(DWORD
, CONTEXT86
*);
94 BOOL (*deviceio
)(DWORD
, LPVOID
, DWORD
,
95 LPVOID
, DWORD
, LPDWORD
, LPOVERLAPPED
);
98 static const struct VxDInfo VxDList
[] =
100 /* Standard VxD IDs */
101 { "VMM", 0x0001, VxDCall_VMM
, NULL
},
102 { "DEBUG", 0x0002, NULL
, NULL
},
103 { "VPICD", 0x0003, NULL
, NULL
},
104 { "VDMAD", 0x0004, NULL
, NULL
},
105 { "VTD", 0x0005, NULL
, NULL
},
106 { "V86MMGR", 0x0006, NULL
, NULL
},
107 { "PAGESWAP", 0x0007, NULL
, NULL
},
108 { "PARITY", 0x0008, NULL
, NULL
},
109 { "REBOOT", 0x0009, NULL
, NULL
},
110 { "VDD", 0x000A, NULL
, NULL
},
111 { "VSD", 0x000B, NULL
, NULL
},
112 { "VMD", 0x000C, NULL
, NULL
},
113 { "VKD", 0x000D, NULL
, NULL
},
114 { "VCD", 0x000E, NULL
, DeviceIo_VCD
},
115 { "VPD", 0x000F, NULL
, NULL
},
116 { "BLOCKDEV", 0x0010, NULL
, NULL
},
117 { "VMCPD", 0x0011, NULL
, NULL
},
118 { "EBIOS", 0x0012, NULL
, NULL
},
119 { "BIOSXLAT", 0x0013, NULL
, NULL
},
120 { "VNETBIOS", 0x0014, NULL
, NULL
},
121 { "DOSMGR", 0x0015, NULL
, NULL
},
122 { "WINLOAD", 0x0016, NULL
, NULL
},
123 { "SHELL", 0x0017, NULL
, NULL
},
124 { "VMPOLL", 0x0018, NULL
, NULL
},
125 { "VPROD", 0x0019, NULL
, NULL
},
126 { "DOSNET", 0x001A, NULL
, NULL
},
127 { "VFD", 0x001B, NULL
, NULL
},
128 { "VDD2", 0x001C, NULL
, NULL
},
129 { "WINDEBUG", 0x001D, NULL
, NULL
},
130 { "TSRLOAD", 0x001E, NULL
, NULL
},
131 { "BIOSHOOK", 0x001F, NULL
, NULL
},
132 { "INT13", 0x0020, NULL
, NULL
},
133 { "PAGEFILE", 0x0021, NULL
, NULL
},
134 { "SCSI", 0x0022, NULL
, NULL
},
135 { "MCA_POS", 0x0023, NULL
, NULL
},
136 { "SCSIFD", 0x0024, NULL
, NULL
},
137 { "VPEND", 0x0025, NULL
, NULL
},
138 { "VPOWERD", 0x0026, NULL
, NULL
},
139 { "VXDLDR", 0x0027, NULL
, NULL
},
140 { "NDIS", 0x0028, NULL
, NULL
},
141 { "BIOS_EXT", 0x0029, NULL
, NULL
},
142 { "VWIN32", 0x002A, VxDCall_VWin32
, DeviceIo_VWin32
},
143 { "VCOMM", 0x002B, NULL
, NULL
},
144 { "SPOOLER", 0x002C, NULL
, NULL
},
145 { "WIN32S", 0x002D, NULL
, NULL
},
146 { "DEBUGCMD", 0x002E, NULL
, NULL
},
148 { "VNB", 0x0031, NULL
, NULL
},
149 { "SERVER", 0x0032, NULL
, NULL
},
150 { "CONFIGMG", 0x0033, NULL
, NULL
},
151 { "DWCFGMG", 0x0034, NULL
, NULL
},
152 { "SCSIPORT", 0x0035, NULL
, NULL
},
153 { "VFBACKUP", 0x0036, NULL
, NULL
},
154 { "ENABLE", 0x0037, NULL
, NULL
},
155 { "VCOND", 0x0038, NULL
, NULL
},
157 { "EFAX", 0x003A, NULL
, NULL
},
158 { "DSVXD", 0x003B, NULL
, NULL
},
159 { "ISAPNP", 0x003C, NULL
, NULL
},
160 { "BIOS", 0x003D, NULL
, NULL
},
161 { "WINSOCK", 0x003E, NULL
, NULL
},
162 { "WSOCK", 0x003E, NULL
, NULL
},
163 { "WSIPX", 0x003F, NULL
, NULL
},
164 { "IFSMgr", 0x0040, NULL
, DeviceIo_IFSMgr
},
165 { "VCDFSD", 0x0041, NULL
, NULL
},
166 { "MRCI2", 0x0042, NULL
, NULL
},
167 { "PCI", 0x0043, NULL
, NULL
},
168 { "PELOADER", 0x0044, NULL
, NULL
},
169 { "EISA", 0x0045, NULL
, NULL
},
170 { "DRAGCLI", 0x0046, NULL
, NULL
},
171 { "DRAGSRV", 0x0047, NULL
, NULL
},
172 { "PERF", 0x0048, NULL
, NULL
},
173 { "AWREDIR", 0x0049, NULL
, NULL
},
175 /* Far East support */
176 { "ETEN", 0x0060, NULL
, NULL
},
177 { "CHBIOS", 0x0061, NULL
, NULL
},
178 { "VMSGD", 0x0062, NULL
, NULL
},
179 { "VPPID", 0x0063, NULL
, NULL
},
180 { "VIME", 0x0064, NULL
, NULL
},
181 { "VHBIOSD", 0x0065, NULL
, NULL
},
183 /* Multimedia OEM IDs */
184 { "VTDAPI", 0x0442, NULL
, DeviceIo_VTDAPI
},
185 { "MMDEVLDR", 0x044A, NULL
, DeviceIo_MMDEVLDR
},
187 /* Network Device IDs */
188 { "VNetSup", 0x0480, NULL
, NULL
},
189 { "VRedir", 0x0481, NULL
, NULL
},
190 { "VBrowse", 0x0482, NULL
, NULL
},
191 { "VSHARE", 0x0483, NULL
, NULL
},
192 { "IFSMgr", 0x0484, NULL
, NULL
},
193 { "MEMPROBE", 0x0485, NULL
, NULL
},
194 { "VFAT", 0x0486, NULL
, NULL
},
195 { "NWLINK", 0x0487, NULL
, NULL
},
196 { "VNWLINK", 0x0487, NULL
, NULL
},
197 { "NWSUP", 0x0487, NULL
, NULL
},
198 { "VTDI", 0x0488, NULL
, NULL
},
199 { "VIP", 0x0489, NULL
, NULL
},
200 { "VTCP", 0x048A, NULL
, NULL
},
201 { "VCache", 0x048B, NULL
, NULL
},
202 { "VUDP", 0x048C, NULL
, NULL
},
203 { "VAsync", 0x048D, NULL
, NULL
},
204 { "NWREDIR", 0x048E, NULL
, NULL
},
205 { "STAT80", 0x048F, NULL
, NULL
},
206 { "SCSIPORT", 0x0490, NULL
, NULL
},
207 { "FILESEC", 0x0491, NULL
, NULL
},
208 { "NWSERVER", 0x0492, NULL
, NULL
},
209 { "SECPROV", 0x0493, NULL
, NULL
},
210 { "NSCL", 0x0494, NULL
, NULL
},
211 { "WSTCP", 0x0495, NULL
, NULL
},
212 { "NDIS2SUP", 0x0496, NULL
, NULL
},
213 { "MSODISUP", 0x0497, NULL
, NULL
},
214 { "Splitter", 0x0498, NULL
, NULL
},
215 { "PPP", 0x0499, NULL
, NULL
},
216 { "VDHCP", 0x049A, NULL
, NULL
},
217 { "VNBT", 0x049B, NULL
, NULL
},
218 { "LOGGER", 0x049D, NULL
, NULL
},
219 { "EFILTER", 0x049E, NULL
, NULL
},
220 { "FFILTER", 0x049F, NULL
, NULL
},
221 { "TFILTER", 0x04A0, NULL
, NULL
},
222 { "AFILTER", 0x04A1, NULL
, NULL
},
223 { "IRLAMP", 0x04A2, NULL
, NULL
},
225 { "PCCARD", 0x097C, NULL
, DeviceIo_PCCARD
},
226 { "HASP95", 0x3721, NULL
, DeviceIo_HASP
},
228 /* WINE additions, ids unknown */
229 { "MONODEBG.VXD", 0x4242, NULL
, DeviceIo_MONODEBG
},
231 { NULL
, 0, NULL
, NULL
}
235 * VMM VxDCall service names are (mostly) taken from Stan Mitchell's
236 * "Inside the Windows 95 File System"
239 #define N_VMM_SERVICE 41
241 LPCSTR VMM_Service_Name
[N_VMM_SERVICE
] =
243 "PageReserve", /* 0x0000 */
244 "PageCommit", /* 0x0001 */
245 "PageDecommit", /* 0x0002 */
246 "PagerRegister", /* 0x0003 */
247 "PagerQuery", /* 0x0004 */
248 "HeapAllocate", /* 0x0005 */
249 "ContextCreate", /* 0x0006 */
250 "ContextDestroy", /* 0x0007 */
251 "PageAttach", /* 0x0008 */
252 "PageFlush", /* 0x0009 */
253 "PageFree", /* 0x000A */
254 "ContextSwitch", /* 0x000B */
255 "HeapReAllocate", /* 0x000C */
256 "PageModifyPermissions", /* 0x000D */
257 "PageQuery", /* 0x000E */
258 "GetCurrentContext", /* 0x000F */
259 "HeapFree", /* 0x0010 */
260 "RegOpenKey", /* 0x0011 */
261 "RegCreateKey", /* 0x0012 */
262 "RegCloseKey", /* 0x0013 */
263 "RegDeleteKey", /* 0x0014 */
264 "RegSetValue", /* 0x0015 */
265 "RegDeleteValue", /* 0x0016 */
266 "RegQueryValue", /* 0x0017 */
267 "RegEnumKey", /* 0x0018 */
268 "RegEnumValue", /* 0x0019 */
269 "RegQueryValueEx", /* 0x001A */
270 "RegSetValueEx", /* 0x001B */
271 "RegFlushKey", /* 0x001C */
272 "RegQueryInfoKey", /* 0x001D */
273 "GetDemandPageInfo", /* 0x001E */
274 "BlockOnID", /* 0x001F */
275 "SignalID", /* 0x0020 */
276 "RegLoadKey", /* 0x0021 */
277 "RegUnLoadKey", /* 0x0022 */
278 "RegSaveKey", /* 0x0023 */
279 "RegRemapPreDefKey", /* 0x0024 */
280 "PageChangePager", /* 0x0025 */
281 "RegQueryMultipleValues", /* 0x0026 */
282 "RegReplaceKey", /* 0x0027 */
283 "<KERNEL32.101>" /* 0x0028 -- What does this do??? */
286 /* PageReserve arena values */
287 #define PR_PRIVATE 0x80000400 /* anywhere in private arena */
288 #define PR_SHARED 0x80060000 /* anywhere in shared arena */
289 #define PR_SYSTEM 0x80080000 /* anywhere in system arena */
291 /* PageReserve flags */
292 #define PR_FIXED 0x00000008 /* don't move during PageReAllocate */
293 #define PR_4MEG 0x00000001 /* allocate on 4mb boundary */
294 #define PR_STATIC 0x00000010 /* see PageReserve documentation */
296 /* PageCommit default pager handle values */
297 #define PD_ZEROINIT 0x00000001 /* swappable zero-initialized pages */
298 #define PD_NOINIT 0x00000002 /* swappable uninitialized pages */
299 #define PD_FIXEDZERO 0x00000003 /* fixed zero-initialized pages */
300 #define PD_FIXED 0x00000004 /* fixed uninitialized pages */
302 /* PageCommit flags */
303 #define PC_FIXED 0x00000008 /* pages are permanently locked */
304 #define PC_LOCKED 0x00000080 /* pages are made present and locked */
305 #define PC_LOCKEDIFDP 0x00000100 /* pages are locked if swap via DOS */
306 #define PC_WRITEABLE 0x00020000 /* make the pages writeable */
307 #define PC_USER 0x00040000 /* make the pages ring 3 accessible */
308 #define PC_INCR 0x40000000 /* increment "pagerdata" each page */
309 #define PC_PRESENT 0x80000000 /* make pages initially present */
310 #define PC_STATIC 0x20000000 /* allow commit in PR_STATIC object */
311 #define PC_DIRTY 0x08000000 /* make pages initially dirty */
312 #define PC_CACHEDIS 0x00100000 /* Allocate uncached pages - new for WDM */
313 #define PC_CACHEWT 0x00080000 /* Allocate write through cache pages - new for WDM */
314 #define PC_PAGEFLUSH 0x00008000 /* Touch device mapped pages on alloc - new for WDM */
316 /* PageCommitContig additional flags */
317 #define PCC_ZEROINIT 0x00000001 /* zero-initialize new pages */
318 #define PCC_NOLIN 0x10000000 /* don't map to any linear address */
322 HANDLE
DEVICE_Open( LPCSTR filename
, DWORD access
, LPSECURITY_ATTRIBUTES sa
)
324 const struct VxDInfo
*info
;
326 for (info
= VxDList
; info
->name
; info
++)
327 if (!strncasecmp( info
->name
, filename
, strlen(info
->name
) ))
328 return FILE_CreateDevice( info
->id
| 0x10000, access
, sa
);
330 FIXME( "Unknown/unsupported VxD %s. Try --winver nt40 or win31 !\n", filename
);
331 SetLastError( ERROR_FILE_NOT_FOUND
);
335 static DWORD
DEVICE_GetClientID( HANDLE handle
)
338 SERVER_START_REQ( get_file_info
)
340 req
->handle
= handle
;
341 if (!wine_server_call( req
) && (reply
->type
== FILE_TYPE_UNKNOWN
))
348 static const struct VxDInfo
*DEVICE_GetInfo( DWORD clientID
)
350 const struct VxDInfo
*info
= NULL
;
352 if (clientID
& 0x10000)
354 for (info
= VxDList
; info
->name
; info
++)
355 if (info
->id
== LOWORD(clientID
)) break;
360 /****************************************************************************
361 * DeviceIoControl (KERNEL32.@)
362 * This is one of those big ugly nasty procedure which can do
363 * a million and one things when it comes to devices. It can also be
364 * used for VxD communication.
366 * A return value of FALSE indicates that something has gone wrong which
367 * GetLastError can decipher.
369 BOOL WINAPI
DeviceIoControl(HANDLE hDevice
, DWORD dwIoControlCode
,
370 LPVOID lpvInBuffer
, DWORD cbInBuffer
,
371 LPVOID lpvOutBuffer
, DWORD cbOutBuffer
,
372 LPDWORD lpcbBytesReturned
,
373 LPOVERLAPPED lpOverlapped
)
377 TRACE( "(%d,%ld,%p,%ld,%p,%ld,%p,%p)\n",
378 hDevice
,dwIoControlCode
,lpvInBuffer
,cbInBuffer
,
379 lpvOutBuffer
,cbOutBuffer
,lpcbBytesReturned
,lpOverlapped
);
381 if (!(clientID
= DEVICE_GetClientID( hDevice
)))
383 SetLastError( ERROR_INVALID_PARAMETER
);
387 /* Check if this is a user defined control code for a VxD */
388 if( HIWORD( dwIoControlCode
) == 0 )
390 const struct VxDInfo
*info
;
391 if (!(info
= DEVICE_GetInfo( clientID
)))
393 FIXME( "No device found for id %lx\n", clientID
);
395 else if ( info
->deviceio
)
397 return info
->deviceio( dwIoControlCode
,
398 lpvInBuffer
, cbInBuffer
,
399 lpvOutBuffer
, cbOutBuffer
,
400 lpcbBytesReturned
, lpOverlapped
);
404 FIXME( "Unimplemented control %ld for VxD device %s\n",
405 dwIoControlCode
, info
->name
? info
->name
: "???" );
406 /* FIXME: this is for invalid calls on W98SE,
407 * but maybe we should use ERROR_CALL_NOT_IMPLEMENTED
409 SetLastError( ERROR_INVALID_FUNCTION
);
417 str
[0] += LOBYTE(clientID
);
418 if (GetDriveTypeA(str
) == DRIVE_CDROM
)
419 return CDROM_DeviceIoControl(clientID
, hDevice
, dwIoControlCode
, lpvInBuffer
, cbInBuffer
,
420 lpvOutBuffer
, cbOutBuffer
, lpcbBytesReturned
,
422 else switch( dwIoControlCode
)
424 case FSCTL_DELETE_REPARSE_POINT
:
425 case FSCTL_DISMOUNT_VOLUME
:
426 case FSCTL_GET_COMPRESSION
:
427 case FSCTL_GET_REPARSE_POINT
:
428 case FSCTL_LOCK_VOLUME
:
429 case FSCTL_QUERY_ALLOCATED_RANGES
:
430 case FSCTL_SET_COMPRESSION
:
431 case FSCTL_SET_REPARSE_POINT
:
432 case FSCTL_SET_SPARSE
:
433 case FSCTL_SET_ZERO_DATA
:
434 case FSCTL_UNLOCK_VOLUME
:
435 case IOCTL_DISK_CHECK_VERIFY
:
436 case IOCTL_DISK_EJECT_MEDIA
:
437 case IOCTL_DISK_FORMAT_TRACKS
:
438 case IOCTL_DISK_GET_DRIVE_GEOMETRY
:
439 case IOCTL_DISK_GET_DRIVE_LAYOUT
:
440 case IOCTL_DISK_GET_MEDIA_TYPES
:
441 case IOCTL_DISK_GET_PARTITION_INFO
:
442 case IOCTL_DISK_LOAD_MEDIA
:
443 case IOCTL_DISK_MEDIA_REMOVAL
:
444 case IOCTL_DISK_PERFORMANCE
:
445 case IOCTL_DISK_REASSIGN_BLOCKS
:
446 case IOCTL_DISK_SET_DRIVE_LAYOUT
:
447 case IOCTL_DISK_SET_PARTITION_INFO
:
448 case IOCTL_DISK_VERIFY
:
449 case IOCTL_SERIAL_LSRMST_INSERT
:
450 case IOCTL_STORAGE_CHECK_VERIFY
:
451 case IOCTL_STORAGE_EJECT_MEDIA
:
452 case IOCTL_STORAGE_GET_MEDIA_TYPES
:
453 case IOCTL_STORAGE_LOAD_MEDIA
:
454 case IOCTL_STORAGE_MEDIA_REMOVAL
:
455 FIXME( "unimplemented dwIoControlCode=%08lx\n", dwIoControlCode
);
456 SetLastError( ERROR_CALL_NOT_IMPLEMENTED
);
460 FIXME( "ignored dwIoControlCode=%08lx\n",dwIoControlCode
);
461 SetLastError( ERROR_CALL_NOT_IMPLEMENTED
);
469 /***********************************************************************
472 static BOOL
DeviceIo_VTDAPI(DWORD dwIoControlCode
, LPVOID lpvInBuffer
, DWORD cbInBuffer
,
473 LPVOID lpvOutBuffer
, DWORD cbOutBuffer
,
474 LPDWORD lpcbBytesReturned
,
475 LPOVERLAPPED lpOverlapped
)
479 switch (dwIoControlCode
)
482 if (lpvOutBuffer
&& (cbOutBuffer
>=4))
483 *(DWORD
*)lpvOutBuffer
= GetTickCount();
485 if (lpcbBytesReturned
)
486 *lpcbBytesReturned
= 4;
491 FIXME( "Control %ld not implemented\n", dwIoControlCode
);
499 /***********************************************************************
500 * VxDCall0 (KERNEL32.1)
501 * VxDCall1 (KERNEL32.2)
502 * VxDCall2 (KERNEL32.3)
503 * VxDCall3 (KERNEL32.4)
504 * VxDCall4 (KERNEL32.5)
505 * VxDCall5 (KERNEL32.6)
506 * VxDCall6 (KERNEL32.7)
507 * VxDCall7 (KERNEL32.8)
508 * VxDCall8 (KERNEL32.9)
510 void VxDCall( DWORD service
, CONTEXT86
*context
)
512 DWORD ret
= 0xffffffff; /* FIXME */
515 TRACE( "(%08lx, ...)\n", service
);
517 for (i
= 0; VxDList
[i
].name
; i
++)
518 if (VxDList
[i
].id
== HIWORD(service
))
521 if (!VxDList
[i
].name
)
522 FIXME( "Unknown VxD (%08lx)\n", service
);
523 else if (!VxDList
[i
].vxdcall
)
524 FIXME( "Unimplemented VxD (%08lx)\n", service
);
526 ret
= VxDList
[i
].vxdcall( service
, context
);
532 /***********************************************************************
535 static DWORD
VxDCall_VMM( DWORD service
, CONTEXT86
*context
)
537 switch ( LOWORD(service
) )
539 case 0x0011: /* RegOpenKey */
541 HKEY hkey
= (HKEY
) stack32_pop( context
);
542 LPCSTR lpszSubKey
= (LPCSTR
)stack32_pop( context
);
543 LPHKEY retkey
= (LPHKEY
)stack32_pop( context
);
544 return RegOpenKeyA( hkey
, lpszSubKey
, retkey
);
547 case 0x0012: /* RegCreateKey */
549 HKEY hkey
= (HKEY
) stack32_pop( context
);
550 LPCSTR lpszSubKey
= (LPCSTR
)stack32_pop( context
);
551 LPHKEY retkey
= (LPHKEY
)stack32_pop( context
);
552 return RegCreateKeyA( hkey
, lpszSubKey
, retkey
);
555 case 0x0013: /* RegCloseKey */
557 HKEY hkey
= (HKEY
)stack32_pop( context
);
558 return RegCloseKey( hkey
);
561 case 0x0014: /* RegDeleteKey */
563 HKEY hkey
= (HKEY
) stack32_pop( context
);
564 LPCSTR lpszSubKey
= (LPCSTR
)stack32_pop( context
);
565 return RegDeleteKeyA( hkey
, lpszSubKey
);
568 case 0x0015: /* RegSetValue */
570 HKEY hkey
= (HKEY
) stack32_pop( context
);
571 LPCSTR lpszSubKey
= (LPCSTR
)stack32_pop( context
);
572 DWORD dwType
= (DWORD
) stack32_pop( context
);
573 LPCSTR lpszData
= (LPCSTR
)stack32_pop( context
);
574 DWORD cbData
= (DWORD
) stack32_pop( context
);
575 return RegSetValueA( hkey
, lpszSubKey
, dwType
, lpszData
, cbData
);
578 case 0x0016: /* RegDeleteValue */
580 HKEY hkey
= (HKEY
) stack32_pop( context
);
581 LPSTR lpszValue
= (LPSTR
)stack32_pop( context
);
582 return RegDeleteValueA( hkey
, lpszValue
);
585 case 0x0017: /* RegQueryValue */
587 HKEY hkey
= (HKEY
) stack32_pop( context
);
588 LPSTR lpszSubKey
= (LPSTR
) stack32_pop( context
);
589 LPSTR lpszData
= (LPSTR
) stack32_pop( context
);
590 LPDWORD lpcbData
= (LPDWORD
)stack32_pop( context
);
591 return RegQueryValueA( hkey
, lpszSubKey
, lpszData
, lpcbData
);
594 case 0x0018: /* RegEnumKey */
596 HKEY hkey
= (HKEY
) stack32_pop( context
);
597 DWORD iSubkey
= (DWORD
)stack32_pop( context
);
598 LPSTR lpszName
= (LPSTR
)stack32_pop( context
);
599 DWORD lpcchName
= (DWORD
)stack32_pop( context
);
600 return RegEnumKeyA( hkey
, iSubkey
, lpszName
, lpcchName
);
603 case 0x0019: /* RegEnumValue */
605 HKEY hkey
= (HKEY
) stack32_pop( context
);
606 DWORD iValue
= (DWORD
) stack32_pop( context
);
607 LPSTR lpszValue
= (LPSTR
) stack32_pop( context
);
608 LPDWORD lpcchValue
= (LPDWORD
)stack32_pop( context
);
609 LPDWORD lpReserved
= (LPDWORD
)stack32_pop( context
);
610 LPDWORD lpdwType
= (LPDWORD
)stack32_pop( context
);
611 LPBYTE lpbData
= (LPBYTE
) stack32_pop( context
);
612 LPDWORD lpcbData
= (LPDWORD
)stack32_pop( context
);
613 return RegEnumValueA( hkey
, iValue
, lpszValue
, lpcchValue
,
614 lpReserved
, lpdwType
, lpbData
, lpcbData
);
617 case 0x001A: /* RegQueryValueEx */
619 HKEY hkey
= (HKEY
) stack32_pop( context
);
620 LPSTR lpszValue
= (LPSTR
) stack32_pop( context
);
621 LPDWORD lpReserved
= (LPDWORD
)stack32_pop( context
);
622 LPDWORD lpdwType
= (LPDWORD
)stack32_pop( context
);
623 LPBYTE lpbData
= (LPBYTE
) stack32_pop( context
);
624 LPDWORD lpcbData
= (LPDWORD
)stack32_pop( context
);
625 return RegQueryValueExA( hkey
, lpszValue
, lpReserved
,
626 lpdwType
, lpbData
, lpcbData
);
629 case 0x001B: /* RegSetValueEx */
631 HKEY hkey
= (HKEY
) stack32_pop( context
);
632 LPSTR lpszValue
= (LPSTR
) stack32_pop( context
);
633 DWORD dwReserved
= (DWORD
) stack32_pop( context
);
634 DWORD dwType
= (DWORD
) stack32_pop( context
);
635 LPBYTE lpbData
= (LPBYTE
)stack32_pop( context
);
636 DWORD cbData
= (DWORD
) stack32_pop( context
);
637 return RegSetValueExA( hkey
, lpszValue
, dwReserved
,
638 dwType
, lpbData
, cbData
);
641 case 0x001C: /* RegFlushKey */
643 HKEY hkey
= (HKEY
)stack32_pop( context
);
644 return RegFlushKey( hkey
);
647 case 0x001D: /* RegQueryInfoKey */
649 /* NOTE: This VxDCall takes only a subset of the parameters that the
650 corresponding Win32 API call does. The implementation in Win95
651 ADVAPI32 sets all output parameters not mentioned here to zero. */
653 HKEY hkey
= (HKEY
) stack32_pop( context
);
654 LPDWORD lpcSubKeys
= (LPDWORD
)stack32_pop( context
);
655 LPDWORD lpcchMaxSubKey
= (LPDWORD
)stack32_pop( context
);
656 LPDWORD lpcValues
= (LPDWORD
)stack32_pop( context
);
657 LPDWORD lpcchMaxValueName
= (LPDWORD
)stack32_pop( context
);
658 LPDWORD lpcchMaxValueData
= (LPDWORD
)stack32_pop( context
);
659 return RegQueryInfoKeyA( hkey
, NULL
, NULL
, NULL
, lpcSubKeys
, lpcchMaxSubKey
,
660 NULL
, lpcValues
, lpcchMaxValueName
, lpcchMaxValueData
,
664 case 0x0021: /* RegLoadKey */
666 HKEY hkey
= (HKEY
) stack32_pop( context
);
667 LPCSTR lpszSubKey
= (LPCSTR
)stack32_pop( context
);
668 LPCSTR lpszFile
= (LPCSTR
)stack32_pop( context
);
669 return RegLoadKeyA( hkey
, lpszSubKey
, lpszFile
);
672 case 0x0022: /* RegUnLoadKey */
674 HKEY hkey
= (HKEY
) stack32_pop( context
);
675 LPCSTR lpszSubKey
= (LPCSTR
)stack32_pop( context
);
676 return RegUnLoadKeyA( hkey
, lpszSubKey
);
679 case 0x0023: /* RegSaveKey */
681 HKEY hkey
= (HKEY
) stack32_pop( context
);
682 LPCSTR lpszFile
= (LPCSTR
)stack32_pop( context
);
683 LPSECURITY_ATTRIBUTES sa
= (LPSECURITY_ATTRIBUTES
)stack32_pop( context
);
684 return RegSaveKeyA( hkey
, lpszFile
, sa
);
687 #if 0 /* Functions are not yet implemented in misc/registry.c */
688 case 0x0024: /* RegRemapPreDefKey */
689 case 0x0026: /* RegQueryMultipleValues */
692 case 0x0027: /* RegReplaceKey */
694 HKEY hkey
= (HKEY
) stack32_pop( context
);
695 LPCSTR lpszSubKey
= (LPCSTR
)stack32_pop( context
);
696 LPCSTR lpszNewFile
= (LPCSTR
)stack32_pop( context
);
697 LPCSTR lpszOldFile
= (LPCSTR
)stack32_pop( context
);
698 return RegReplaceKeyA( hkey
, lpszSubKey
, lpszNewFile
, lpszOldFile
);
700 case 0x0000: /* PageReserve */
704 DWORD psize
= getpagesize();
705 ULONG page
= (ULONG
) stack32_pop( context
);
706 ULONG npages
= (ULONG
) stack32_pop( context
);
707 ULONG flags
= (ULONG
) stack32_pop( context
);
709 TRACE("PageReserve: page: %08lx, npages: %08lx, flags: %08lx partial stub!\n",
710 page
, npages
, flags
);
712 if ( page
== PR_SYSTEM
) {
713 ERR("Can't reserve ring 1 memory\n");
716 /* FIXME: This has to be handled separately for the separate
717 address-spaces we now have */
718 if ( page
== PR_PRIVATE
|| page
== PR_SHARED
) page
= 0;
719 /* FIXME: Handle flags in some way */
720 address
= (LPVOID
)(page
* psize
);
721 ret
= VirtualAlloc ( address
, ( npages
* psize
), MEM_RESERVE
, 0 );
722 TRACE("PageReserve: returning: %08lx\n", (DWORD
)ret
);
729 case 0x0001: /* PageCommit */
734 DWORD psize
= getpagesize();
735 ULONG page
= (ULONG
) stack32_pop( context
);
736 ULONG npages
= (ULONG
) stack32_pop( context
);
737 ULONG hpd
= (ULONG
) stack32_pop( context
);
738 ULONG pagerdata
= (ULONG
) stack32_pop( context
);
739 ULONG flags
= (ULONG
) stack32_pop( context
);
741 TRACE("PageCommit: page: %08lx, npages: %08lx, hpd: %08lx pagerdata: "
742 "%08lx, flags: %08lx partial stub\n",
743 page
, npages
, hpd
, pagerdata
, flags
);
745 if ( flags
& PC_USER
)
746 if ( flags
& PC_WRITEABLE
)
747 virt_perm
= PAGE_EXECUTE_READWRITE
;
749 virt_perm
= PAGE_EXECUTE_READ
;
751 virt_perm
= PAGE_NOACCESS
;
753 address
= (LPVOID
)(page
* psize
);
754 ret
= VirtualAlloc ( address
, ( npages
* psize
), MEM_COMMIT
, virt_perm
);
755 TRACE("PageCommit: Returning: %08lx\n", (DWORD
)ret
);
759 case 0x0002: /* PageDecommit */
763 DWORD psize
= getpagesize();
764 ULONG page
= (ULONG
) stack32_pop( context
);
765 ULONG npages
= (ULONG
) stack32_pop( context
);
766 ULONG flags
= (ULONG
) stack32_pop( context
);
768 TRACE("PageDecommit: page: %08lx, npages: %08lx, flags: %08lx partial stub\n",
769 page
, npages
, flags
);
770 address
= (LPVOID
)( page
* psize
);
771 ret
= VirtualFree ( address
, ( npages
* psize
), MEM_DECOMMIT
);
772 TRACE("PageDecommit: Returning: %s\n", ret
? "TRUE" : "FALSE" );
775 case 0x000d: /* PageModifyPermissions */
781 MEMORY_BASIC_INFORMATION mbi
;
783 DWORD psize
= getpagesize();
784 ULONG page
= stack32_pop ( context
);
785 ULONG npages
= stack32_pop ( context
);
786 ULONG permand
= stack32_pop ( context
);
787 ULONG permor
= stack32_pop ( context
);
789 TRACE("PageModifyPermissions %08lx %08lx %08lx %08lx partial stub\n",
790 page
, npages
, permand
, permor
);
791 address
= (LPVOID
)( page
* psize
);
793 VirtualQuery ( address
, &mbi
, sizeof ( MEMORY_BASIC_INFORMATION
));
794 virt_old_perm
= mbi
.Protect
;
796 switch ( virt_old_perm
& mbi
.Protect
) {
799 case PAGE_EXECUTE_READ
:
800 pg_old_perm
= PC_USER
;
804 case PAGE_EXECUTE_READWRITE
:
805 case PAGE_EXECUTE_WRITECOPY
:
806 pg_old_perm
= PC_USER
| PC_WRITEABLE
;
813 pg_new_perm
= pg_old_perm
;
814 pg_new_perm
&= permand
& ~PC_STATIC
;
815 pg_new_perm
|= permor
& ~PC_STATIC
;
817 virt_new_perm
= ( virt_old_perm
) & ~0xff;
818 if ( pg_new_perm
& PC_USER
)
820 if ( pg_new_perm
& PC_WRITEABLE
)
821 virt_new_perm
|= PAGE_EXECUTE_READWRITE
;
823 virt_new_perm
|= PAGE_EXECUTE_READ
;
826 if ( ! VirtualProtect ( address
, ( npages
* psize
), virt_new_perm
, &virt_old_perm
) ) {
827 ERR("Can't change page permissions for %08lx\n", (DWORD
)address
);
830 TRACE("Returning: %08lx\n", pg_old_perm
);
833 case 0x000a: /* PageFree */
836 LPVOID hmem
= (LPVOID
) stack32_pop( context
);
837 DWORD flags
= (DWORD
) stack32_pop( context
);
839 TRACE("PageFree: hmem: %08lx, flags: %08lx partial stub\n",
840 (DWORD
)hmem
, flags
);
842 ret
= VirtualFree ( hmem
, 0, MEM_RELEASE
);
844 TRACE("Returning: %d\n", ret
);
848 case 0x001e: /* GetDemandPageInfo */
850 DWORD dinfo
= (DWORD
)stack32_pop( context
);
851 DWORD flags
= (DWORD
)stack32_pop( context
);
853 /* GetDemandPageInfo is supposed to fill out the struct at
854 * "dinfo" with various low-level memory management information.
855 * Apps are certainly not supposed to call this, although it's
856 * demoed and documented by Pietrek on pages 441-443 of "Windows
857 * 95 System Programming Secrets" if any program needs a real
858 * implementation of this.
861 FIXME("GetDemandPageInfo(%08lx %08lx): stub!\n", dinfo
, flags
);
866 if (LOWORD(service
) < N_VMM_SERVICE
)
867 FIXME( "Unimplemented service %s (%08lx)\n",
868 VMM_Service_Name
[LOWORD(service
)], service
);
870 FIXME( "Unknown service %08lx\n", service
);
874 return 0xffffffff; /* FIXME */
877 /***********************************************************************
880 * These ioctls are used by 'MSNET32.DLL'.
882 * I have been unable to uncover any documentation about the ioctls so
883 * the implementation of the cases IFS_IOCTL_21 and IFS_IOCTL_2F are
884 * based on reasonable guesses on information found in the Windows 95 DDK.
889 * IFSMgr DeviceIO service
892 #define IFS_IOCTL_21 100
893 #define IFS_IOCTL_2F 101
894 #define IFS_IOCTL_GET_RES 102
895 #define IFS_IOCTL_GET_NETPRO_NAME_A 103
898 unsigned long ar_proid
;
899 unsigned long ar_eax
;
900 unsigned long ar_ebx
;
901 unsigned long ar_ecx
;
902 unsigned long ar_edx
;
903 unsigned long ar_esi
;
904 unsigned long ar_edi
;
905 unsigned long ar_ebp
;
906 unsigned short ar_error
;
907 unsigned short ar_pad
;
910 static void win32apieq_2_CONTEXT(struct win32apireq
*pIn
,CONTEXT86
*pCxt
)
912 memset(pCxt
,0,sizeof(*pCxt
));
914 pCxt
->ContextFlags
=CONTEXT86_INTEGER
|CONTEXT86_CONTROL
;
915 pCxt
->Eax
= pIn
->ar_eax
;
916 pCxt
->Ebx
= pIn
->ar_ebx
;
917 pCxt
->Ecx
= pIn
->ar_ecx
;
918 pCxt
->Edx
= pIn
->ar_edx
;
919 pCxt
->Esi
= pIn
->ar_esi
;
920 pCxt
->Edi
= pIn
->ar_edi
;
922 /* FIXME: Only partial CONTEXT86_CONTROL */
923 pCxt
->Ebp
= pIn
->ar_ebp
;
925 /* FIXME: pIn->ar_proid ignored */
926 /* FIXME: pIn->ar_error ignored */
927 /* FIXME: pIn->ar_pad ignored */
930 static void CONTEXT_2_win32apieq(CONTEXT86
*pCxt
,struct win32apireq
*pOut
)
932 memset(pOut
,0,sizeof(struct win32apireq
));
934 pOut
->ar_eax
= pCxt
->Eax
;
935 pOut
->ar_ebx
= pCxt
->Ebx
;
936 pOut
->ar_ecx
= pCxt
->Ecx
;
937 pOut
->ar_edx
= pCxt
->Edx
;
938 pOut
->ar_esi
= pCxt
->Esi
;
939 pOut
->ar_edi
= pCxt
->Edi
;
941 /* FIXME: Only partial CONTEXT86_CONTROL */
942 pOut
->ar_ebp
= pCxt
->Ebp
;
944 /* FIXME: pOut->ar_proid ignored */
945 /* FIXME: pOut->ar_error ignored */
946 /* FIXME: pOut->ar_pad ignored */
949 static BOOL
DeviceIo_IFSMgr(DWORD dwIoControlCode
, LPVOID lpvInBuffer
, DWORD cbInBuffer
,
950 LPVOID lpvOutBuffer
, DWORD cbOutBuffer
,
951 LPDWORD lpcbBytesReturned
,
952 LPOVERLAPPED lpOverlapped
)
955 TRACE("(%ld,%p,%ld,%p,%ld,%p,%p): stub\n",
957 lpvInBuffer
,cbInBuffer
,
958 lpvOutBuffer
,cbOutBuffer
,
962 switch (dwIoControlCode
)
967 struct win32apireq
*pIn
=(struct win32apireq
*) lpvInBuffer
;
968 struct win32apireq
*pOut
=(struct win32apireq
*) lpvOutBuffer
;
972 "proid=0x%08lx, eax=0x%08lx, ebx=0x%08lx, ecx=0x%08lx, "
973 "edx=0x%08lx, esi=0x%08lx, edi=0x%08lx, ebp=0x%08lx, "
974 "error=0x%04x, pad=0x%04x\n",
975 (dwIoControlCode
==IFS_IOCTL_21
)?"IFS_IOCTL_21":"IFS_IOCTL_2F",
976 pIn
->ar_proid
, pIn
->ar_eax
, pIn
->ar_ebx
, pIn
->ar_ecx
,
977 pIn
->ar_edx
, pIn
->ar_esi
, pIn
->ar_edi
, pIn
->ar_ebp
,
978 pIn
->ar_error
, pIn
->ar_pad
981 win32apieq_2_CONTEXT(pIn
,&cxt
);
983 if(dwIoControlCode
==IFS_IOCTL_21
)
985 DOS3Call(&cxt
); /* Call int 21h */
987 INT_Int2fHandler(&cxt
); /* Call int 2Fh */
990 CONTEXT_2_win32apieq(&cxt
,pOut
);
994 case IFS_IOCTL_GET_RES
:{
995 FIXME( "Control 'IFS_IOCTL_GET_RES' not implemented\n");
998 case IFS_IOCTL_GET_NETPRO_NAME_A
:{
999 FIXME( "Control 'IFS_IOCTL_GET_NETPRO_NAME_A' not implemented\n");
1003 FIXME( "Control %ld not implemented\n", dwIoControlCode
);
1010 /********************************************************************************
1013 * Service numbers taken from page 448 of Pietrek's "Windows 95 System
1014 * Programming Secrets". Parameters from experimentation on real Win98.
1018 static DWORD
VxDCall_VWin32( DWORD service
, CONTEXT86
*context
)
1020 switch ( LOWORD(service
) )
1022 case 0x0000: /* GetVersion */
1024 DWORD vers
= GetVersion();
1025 return (LOBYTE(vers
) << 8) | HIBYTE(vers
);
1029 case 0x0020: /* Get VMCPD Version */
1031 DWORD parm
= (DWORD
) stack32_pop(context
);
1033 FIXME("Get VMCPD Version(%08lx): partial stub!\n", parm
);
1035 /* FIXME: This is what Win98 returns, it may
1036 * not be correct in all situations.
1037 * It makes Bleem! happy though.
1043 case 0x0029: /* Int31/DPMI dispatch */
1045 DWORD callnum
= (DWORD
) stack32_pop(context
);
1046 DWORD parm
= (DWORD
) stack32_pop(context
);
1048 TRACE("Int31/DPMI dispatch(%08lx)\n", callnum
);
1050 AX_reg(context
) = callnum
;
1051 CX_reg(context
) = parm
;
1052 INT_Int31Handler(context
);
1054 return LOWORD(context
->Eax
);
1058 case 0x002a: /* Int41 dispatch - parm = int41 service number */
1060 DWORD callnum
= (DWORD
) stack32_pop(context
);
1062 return callnum
; /* FIXME: should really call INT_Int41Handler() */
1067 FIXME("Unknown VWin32 service %08lx\n", service
);
1075 /***********************************************************************
1078 static BOOL
DeviceIo_VCD(DWORD dwIoControlCode
,
1079 LPVOID lpvInBuffer
, DWORD cbInBuffer
,
1080 LPVOID lpvOutBuffer
, DWORD cbOutBuffer
,
1081 LPDWORD lpcbBytesReturned
,
1082 LPOVERLAPPED lpOverlapped
)
1086 switch (dwIoControlCode
)
1088 case IOCTL_SERIAL_LSRMST_INSERT
:
1090 FIXME( "IOCTL_SERIAL_LSRMST_INSERT NIY !\n");
1096 FIXME( "Unknown Control %ld\n", dwIoControlCode
);
1105 /***********************************************************************
1109 static void DIOCRegs_2_CONTEXT( DIOC_REGISTERS
*pIn
, CONTEXT86
*pCxt
)
1111 memset( pCxt
, 0, sizeof(*pCxt
) );
1112 /* Note: segment registers == 0 means that CTX_SEG_OFF_TO_LIN
1113 will interpret 32-bit register contents as linear pointers */
1115 pCxt
->ContextFlags
=CONTEXT86_INTEGER
|CONTEXT86_CONTROL
;
1116 pCxt
->Eax
= pIn
->reg_EAX
;
1117 pCxt
->Ebx
= pIn
->reg_EBX
;
1118 pCxt
->Ecx
= pIn
->reg_ECX
;
1119 pCxt
->Edx
= pIn
->reg_EDX
;
1120 pCxt
->Esi
= pIn
->reg_ESI
;
1121 pCxt
->Edi
= pIn
->reg_EDI
;
1123 /* FIXME: Only partial CONTEXT86_CONTROL */
1124 pCxt
->EFlags
= pIn
->reg_Flags
;
1127 static void CONTEXT_2_DIOCRegs( CONTEXT86
*pCxt
, DIOC_REGISTERS
*pOut
)
1129 memset( pOut
, 0, sizeof(DIOC_REGISTERS
) );
1131 pOut
->reg_EAX
= pCxt
->Eax
;
1132 pOut
->reg_EBX
= pCxt
->Ebx
;
1133 pOut
->reg_ECX
= pCxt
->Ecx
;
1134 pOut
->reg_EDX
= pCxt
->Edx
;
1135 pOut
->reg_ESI
= pCxt
->Esi
;
1136 pOut
->reg_EDI
= pCxt
->Edi
;
1138 /* FIXME: Only partial CONTEXT86_CONTROL */
1139 pOut
->reg_Flags
= pCxt
->EFlags
;
1143 static BOOL
DeviceIo_VWin32(DWORD dwIoControlCode
,
1144 LPVOID lpvInBuffer
, DWORD cbInBuffer
,
1145 LPVOID lpvOutBuffer
, DWORD cbOutBuffer
,
1146 LPDWORD lpcbBytesReturned
,
1147 LPOVERLAPPED lpOverlapped
)
1151 switch (dwIoControlCode
)
1153 case VWIN32_DIOC_DOS_IOCTL
:
1154 case VWIN32_DIOC_DOS_INT13
:
1155 case VWIN32_DIOC_DOS_INT25
:
1156 case VWIN32_DIOC_DOS_INT26
:
1157 case VWIN32_DIOC_DOS_DRIVEINFO
:
1160 DIOC_REGISTERS
*pIn
= (DIOC_REGISTERS
*)lpvInBuffer
;
1161 DIOC_REGISTERS
*pOut
= (DIOC_REGISTERS
*)lpvOutBuffer
;
1163 TRACE( "Control '%s': "
1164 "eax=0x%08lx, ebx=0x%08lx, ecx=0x%08lx, "
1165 "edx=0x%08lx, esi=0x%08lx, edi=0x%08lx ",
1166 (dwIoControlCode
== VWIN32_DIOC_DOS_IOCTL
)? "VWIN32_DIOC_DOS_IOCTL" :
1167 (dwIoControlCode
== VWIN32_DIOC_DOS_INT13
)? "VWIN32_DIOC_DOS_INT13" :
1168 (dwIoControlCode
== VWIN32_DIOC_DOS_INT25
)? "VWIN32_DIOC_DOS_INT25" :
1169 (dwIoControlCode
== VWIN32_DIOC_DOS_INT26
)? "VWIN32_DIOC_DOS_INT26" :
1170 (dwIoControlCode
== VWIN32_DIOC_DOS_DRIVEINFO
)? "VWIN32_DIOC_DOS_DRIVEINFO" : "???",
1171 pIn
->reg_EAX
, pIn
->reg_EBX
, pIn
->reg_ECX
,
1172 pIn
->reg_EDX
, pIn
->reg_ESI
, pIn
->reg_EDI
);
1174 DIOCRegs_2_CONTEXT( pIn
, &cxt
);
1176 switch (dwIoControlCode
)
1178 case VWIN32_DIOC_DOS_IOCTL
: DOS3Call( &cxt
); break; /* Call int 21h */
1179 case VWIN32_DIOC_DOS_INT13
: INT_Int13Handler( &cxt
); break;
1180 case VWIN32_DIOC_DOS_INT25
: INT_Int25Handler( &cxt
); break;
1181 case VWIN32_DIOC_DOS_INT26
: INT_Int26Handler( &cxt
); break;
1182 case VWIN32_DIOC_DOS_DRIVEINFO
: DOS3Call( &cxt
); break; /* Call int 21h 730x */
1185 CONTEXT_2_DIOCRegs( &cxt
, pOut
);
1189 case VWIN32_DIOC_SIMCTRLC
:
1190 FIXME( "Control VWIN32_DIOC_SIMCTRLC not implemented\n");
1195 FIXME( "Unknown Control %ld\n", dwIoControlCode
);
1203 /* this is the main multimedia device loader */
1204 static BOOL
DeviceIo_MMDEVLDR(DWORD dwIoControlCode
,
1205 LPVOID lpvInBuffer
, DWORD cbInBuffer
,
1206 LPVOID lpvOutBuffer
, DWORD cbOutBuffer
,
1207 LPDWORD lpcbBytesReturned
,
1208 LPOVERLAPPED lpOverlapped
)
1210 FIXME("(%ld,%p,%ld,%p,%ld,%p,%p): stub\n",
1212 lpvInBuffer
,cbInBuffer
,
1213 lpvOutBuffer
,cbOutBuffer
,
1217 switch (dwIoControlCode
) {
1220 *(DWORD
*)lpvOutBuffer
=0;
1221 *lpcbBytesReturned
=4;
1226 /* this is used by some Origin games */
1227 static BOOL
DeviceIo_MONODEBG(DWORD dwIoControlCode
,
1228 LPVOID lpvInBuffer
, DWORD cbInBuffer
,
1229 LPVOID lpvOutBuffer
, DWORD cbOutBuffer
,
1230 LPDWORD lpcbBytesReturned
,
1231 LPOVERLAPPED lpOverlapped
)
1233 switch (dwIoControlCode
) {
1234 case 1: /* version */
1235 *(LPDWORD
)lpvOutBuffer
= 0x20004; /* WC SecretOps */
1237 case 9: /* debug output */
1238 ERR("MONODEBG: %s\n",debugstr_a(lpvInBuffer
));
1241 FIXME("(%ld,%p,%ld,%p,%ld,%p,%p): stub\n",
1243 lpvInBuffer
,cbInBuffer
,
1244 lpvOutBuffer
,cbOutBuffer
,
1253 static BOOL
DeviceIo_PCCARD (DWORD dwIoControlCode
,
1254 LPVOID lpvInBuffer
, DWORD cbInBuffer
,
1255 LPVOID lpvOutBuffer
, DWORD cbOutBuffer
,
1256 LPDWORD lpcbBytesReturned
,
1257 LPOVERLAPPED lpOverlapped
)
1259 switch (dwIoControlCode
) {
1260 case 0x0000: /* PCCARD_Get_Version */
1261 case 0x0001: /* PCCARD_Card_Services */
1263 FIXME( "(%ld,%p,%ld,%p,%ld,%p,%p): stub\n",
1265 lpvInBuffer
,cbInBuffer
,
1266 lpvOutBuffer
,cbOutBuffer
,
1275 /***********************************************************************
1276 * OpenVxDHandle (KERNEL32.@)
1278 DWORD WINAPI
OpenVxDHandle(DWORD pmt
)
1280 FIXME( "(0x%08lx) stub!\n", pmt
);
1284 static BOOL
DeviceIo_HASP(DWORD dwIoControlCode
, LPVOID lpvInBuffer
, DWORD cbInBuffer
,
1285 LPVOID lpvOutBuffer
, DWORD cbOutBuffer
,
1286 LPDWORD lpcbBytesReturned
,
1287 LPOVERLAPPED lpOverlapped
)
1290 FIXME("(%ld,%p,%ld,%p,%ld,%p,%p): stub\n",
1292 lpvInBuffer
,cbInBuffer
,
1293 lpvOutBuffer
,cbOutBuffer
,