2 * Win32 device functions
4 * Copyright 1998 Marcus Meissner
5 * Copyright 1998 Ulrich Weigand
6 * Copyright 1998 Patrik Stridvall
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.
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.
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
24 #include "wine/port.h"
30 #include <sys/types.h>
44 #include "stackframe.h"
45 #include "wine/server.h"
46 #include "wine/debug.h"
49 #ifdef HAVE_SYS_IOCTL_H
50 # include <sys/ioctl.h>
54 # include <linux/fd.h>
58 WINE_DEFAULT_DEBUG_CHANNEL(file
);
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
);
77 static DWORD
VxDCall_VMM( DWORD service
, CONTEXT86
*context
);
79 static BOOL
DeviceIo_IFSMgr(DWORD dwIoControlCode
,
80 LPVOID lpvInBuffer
, DWORD cbInBuffer
,
81 LPVOID lpvOutBuffer
, DWORD cbOutBuffer
,
82 LPDWORD lpcbBytesReturned
,
83 LPOVERLAPPED lpOverlapped
);
85 static BOOL
DeviceIo_VCD(DWORD dwIoControlCode
,
86 LPVOID lpvInBuffer
, DWORD cbInBuffer
,
87 LPVOID lpvOutBuffer
, DWORD cbOutBuffer
,
88 LPDWORD lpcbBytesReturned
,
89 LPOVERLAPPED lpOverlapped
);
91 static DWORD
VxDCall_VWin32( DWORD service
, CONTEXT86
*context
);
93 static BOOL
DeviceIo_VWin32(DWORD dwIoControlCode
,
94 LPVOID lpvInBuffer
, DWORD cbInBuffer
,
95 LPVOID lpvOutBuffer
, DWORD cbOutBuffer
,
96 LPDWORD lpcbBytesReturned
,
97 LPOVERLAPPED lpOverlapped
);
99 static BOOL
DeviceIo_PCCARD (DWORD dwIoControlCode
,
100 LPVOID lpvInBuffer
, DWORD cbInBuffer
,
101 LPVOID lpvOutBuffer
, DWORD cbOutBuffer
,
102 LPDWORD lpcbBytesReturned
,
103 LPOVERLAPPED lpOverlapped
);
105 static BOOL
DeviceIo_HASP (DWORD dwIoControlCode
,
106 LPVOID lpvInBuffer
, DWORD cbInBuffer
,
107 LPVOID lpvOutBuffer
, DWORD cbOutBuffer
,
108 LPDWORD lpcbBytesReturned
,
109 LPOVERLAPPED lpOverlapped
);
111 * VxD names are taken from the Win95 DDK
118 DWORD (*vxdcall
)(DWORD
, CONTEXT86
*);
119 BOOL (*deviceio
)(DWORD
, LPVOID
, DWORD
,
120 LPVOID
, DWORD
, LPDWORD
, LPOVERLAPPED
);
123 static const struct VxDInfo VxDList
[] =
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
},
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
},
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
},
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
},
208 /* Multimedia OEM IDs */
209 { "VTDAPI", 0x0442, NULL
, DeviceIo_VTDAPI
},
210 { "MMDEVLDR", 0x044A, NULL
, DeviceIo_MMDEVLDR
},
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
},
250 { "PCCARD", 0x097C, NULL
, DeviceIo_PCCARD
},
251 { "HASP95", 0x3721, NULL
, DeviceIo_HASP
},
253 /* WINE additions, ids unknown */
254 { "MONODEBG.VXD", 0x4242, NULL
, DeviceIo_MONODEBG
},
256 { NULL
, 0, NULL
, NULL
}
260 * VMM VxDCall service names are (mostly) taken from Stan Mitchell's
261 * "Inside the Windows 95 File System"
264 #define N_VMM_SERVICE 41
266 LPCSTR VMM_Service_Name
[N_VMM_SERVICE
] =
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??? */
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 */
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 */
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 */
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 */
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 */
347 HANDLE
DEVICE_Open( LPCWSTR filenameW
, DWORD access
, LPSECURITY_ATTRIBUTES sa
)
349 const struct VxDInfo
*info
;
350 char filename
[MAX_PATH
];
352 if (!WideCharToMultiByte(CP_ACP
, 0, filenameW
, -1, filename
, MAX_PATH
, NULL
, NULL
))
354 SetLastError( ERROR_FILE_NOT_FOUND
);
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
);
362 FIXME( "Unknown/unsupported VxD %s. Try setting Windows version to 'nt40' or 'win31'.\n",
364 SetLastError( ERROR_FILE_NOT_FOUND
);
368 static DWORD
DEVICE_GetClientID( HANDLE handle
)
371 SERVER_START_REQ( get_file_info
)
373 req
->handle
= handle
;
374 if (!wine_server_call( req
) && (reply
->type
== FILE_TYPE_UNKNOWN
))
381 static const struct VxDInfo
*DEVICE_GetInfo( DWORD clientID
)
383 const struct VxDInfo
*info
= NULL
;
385 if (clientID
& 0x10000)
387 for (info
= VxDList
; info
->name
; info
++)
388 if (info
->id
== LOWORD(clientID
)) break;
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.
399 * A return value of FALSE indicates that something has gone wrong which
400 * GetLastError can decipher.
402 BOOL WINAPI
DeviceIoControl(HANDLE hDevice
, DWORD dwIoControlCode
,
403 LPVOID lpvInBuffer
, DWORD cbInBuffer
,
404 LPVOID lpvOutBuffer
, DWORD cbOutBuffer
,
405 LPDWORD lpcbBytesReturned
,
406 LPOVERLAPPED lpOverlapped
)
410 TRACE( "(%d,%ld,%p,%ld,%p,%ld,%p,%p)\n",
411 hDevice
,dwIoControlCode
,lpvInBuffer
,cbInBuffer
,
412 lpvOutBuffer
,cbOutBuffer
,lpcbBytesReturned
,lpOverlapped
);
414 if (!(clientID
= DEVICE_GetClientID( hDevice
)))
416 SetLastError( ERROR_INVALID_PARAMETER
);
420 /* Check if this is a user defined control code for a VxD */
421 if( HIWORD( dwIoControlCode
) == 0 )
423 const struct VxDInfo
*info
;
424 if (!(info
= DEVICE_GetInfo( clientID
)))
426 FIXME( "No device found for id %lx\n", clientID
);
428 else if ( info
->deviceio
)
430 return info
->deviceio( dwIoControlCode
,
431 lpvInBuffer
, cbInBuffer
,
432 lpvOutBuffer
, cbOutBuffer
,
433 lpcbBytesReturned
, lpOverlapped
);
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
442 SetLastError( ERROR_INVALID_FUNCTION
);
450 str
[0] += LOBYTE(clientID
);
451 if (GetDriveTypeA(str
) == DRIVE_CDROM
)
452 return CDROM_DeviceIoControl(clientID
, hDevice
, dwIoControlCode
, lpvInBuffer
, cbInBuffer
,
453 lpvOutBuffer
, cbOutBuffer
, lpcbBytesReturned
,
455 else switch( dwIoControlCode
)
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
);
493 FIXME( "ignored dwIoControlCode=%08lx\n",dwIoControlCode
);
494 SetLastError( ERROR_CALL_NOT_IMPLEMENTED
);
502 /***********************************************************************
505 static BOOL
DeviceIo_VTDAPI(DWORD dwIoControlCode
, LPVOID lpvInBuffer
, DWORD cbInBuffer
,
506 LPVOID lpvOutBuffer
, DWORD cbOutBuffer
,
507 LPDWORD lpcbBytesReturned
,
508 LPOVERLAPPED lpOverlapped
)
512 switch (dwIoControlCode
)
515 if (lpvOutBuffer
&& (cbOutBuffer
>=4))
516 *(DWORD
*)lpvOutBuffer
= GetTickCount();
518 if (lpcbBytesReturned
)
519 *lpcbBytesReturned
= 4;
524 FIXME( "Control %ld not implemented\n", dwIoControlCode
);
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)
543 void VxDCall( DWORD service
, CONTEXT86
*context
)
545 DWORD ret
= 0xffffffff; /* FIXME */
548 TRACE( "(%08lx, ...)\n", service
);
550 for (i
= 0; VxDList
[i
].name
; i
++)
551 if (VxDList
[i
].id
== HIWORD(service
))
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
);
559 ret
= VxDList
[i
].vxdcall( service
, context
);
565 /***********************************************************************
568 static DWORD
VxDCall_VMM( DWORD service
, CONTEXT86
*context
)
570 switch ( LOWORD(service
) )
572 case 0x0011: /* RegOpenKey */
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
);
580 case 0x0012: /* RegCreateKey */
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
);
588 case 0x0013: /* RegCloseKey */
590 HKEY hkey
= (HKEY
)stack32_pop( context
);
591 return RegCloseKey( hkey
);
594 case 0x0014: /* RegDeleteKey */
596 HKEY hkey
= (HKEY
) stack32_pop( context
);
597 LPCSTR lpszSubKey
= (LPCSTR
)stack32_pop( context
);
598 return RegDeleteKeyA( hkey
, lpszSubKey
);
601 case 0x0015: /* RegSetValue */
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
);
611 case 0x0016: /* RegDeleteValue */
613 HKEY hkey
= (HKEY
) stack32_pop( context
);
614 LPSTR lpszValue
= (LPSTR
)stack32_pop( context
);
615 return RegDeleteValueA( hkey
, lpszValue
);
618 case 0x0017: /* RegQueryValue */
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
);
627 case 0x0018: /* RegEnumKey */
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
);
636 case 0x0019: /* RegEnumValue */
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
);
650 case 0x001A: /* RegQueryValueEx */
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
);
662 case 0x001B: /* RegSetValueEx */
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
);
674 case 0x001C: /* RegFlushKey */
676 HKEY hkey
= (HKEY
)stack32_pop( context
);
677 return RegFlushKey( hkey
);
680 case 0x001D: /* RegQueryInfoKey */
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. */
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
,
697 case 0x0021: /* RegLoadKey */
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
);
705 case 0x0022: /* RegUnLoadKey */
707 HKEY hkey
= (HKEY
) stack32_pop( context
);
708 LPCSTR lpszSubKey
= (LPCSTR
)stack32_pop( context
);
709 return RegUnLoadKeyA( hkey
, lpszSubKey
);
712 case 0x0023: /* RegSaveKey */
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
);
720 #if 0 /* Functions are not yet implemented in misc/registry.c */
721 case 0x0024: /* RegRemapPreDefKey */
722 case 0x0026: /* RegQueryMultipleValues */
725 case 0x0027: /* RegReplaceKey */
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
);
733 case 0x0000: /* PageReserve */
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
);
742 TRACE("PageReserve: page: %08lx, npages: %08lx, flags: %08lx partial stub!\n",
743 page
, npages
, flags
);
745 if ( page
== PR_SYSTEM
) {
746 ERR("Can't reserve ring 1 memory\n");
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
);
762 case 0x0001: /* PageCommit */
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
);
774 TRACE("PageCommit: page: %08lx, npages: %08lx, hpd: %08lx pagerdata: "
775 "%08lx, flags: %08lx partial stub\n",
776 page
, npages
, hpd
, pagerdata
, flags
);
778 if ( flags
& PC_USER
)
779 if ( flags
& PC_WRITEABLE
)
780 virt_perm
= PAGE_EXECUTE_READWRITE
;
782 virt_perm
= PAGE_EXECUTE_READ
;
784 virt_perm
= PAGE_NOACCESS
;
786 address
= (LPVOID
)(page
* psize
);
787 ret
= VirtualAlloc ( address
, ( npages
* psize
), MEM_COMMIT
, virt_perm
);
788 TRACE("PageCommit: Returning: %08lx\n", (DWORD
)ret
);
792 case 0x0002: /* PageDecommit */
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
);
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" );
808 case 0x000d: /* PageModifyPermissions */
814 MEMORY_BASIC_INFORMATION mbi
;
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
);
822 TRACE("PageModifyPermissions %08lx %08lx %08lx %08lx partial stub\n",
823 page
, npages
, permand
, permor
);
824 address
= (LPVOID
)( page
* psize
);
826 VirtualQuery ( address
, &mbi
, sizeof ( MEMORY_BASIC_INFORMATION
));
827 virt_old_perm
= mbi
.Protect
;
829 switch ( virt_old_perm
& mbi
.Protect
) {
832 case PAGE_EXECUTE_READ
:
833 pg_old_perm
= PC_USER
;
837 case PAGE_EXECUTE_READWRITE
:
838 case PAGE_EXECUTE_WRITECOPY
:
839 pg_old_perm
= PC_USER
| PC_WRITEABLE
;
846 pg_new_perm
= pg_old_perm
;
847 pg_new_perm
&= permand
& ~PC_STATIC
;
848 pg_new_perm
|= permor
& ~PC_STATIC
;
850 virt_new_perm
= ( virt_old_perm
) & ~0xff;
851 if ( pg_new_perm
& PC_USER
)
853 if ( pg_new_perm
& PC_WRITEABLE
)
854 virt_new_perm
|= PAGE_EXECUTE_READWRITE
;
856 virt_new_perm
|= PAGE_EXECUTE_READ
;
859 if ( ! VirtualProtect ( address
, ( npages
* psize
), virt_new_perm
, &virt_old_perm
) ) {
860 ERR("Can't change page permissions for %08lx\n", (DWORD
)address
);
863 TRACE("Returning: %08lx\n", pg_old_perm
);
866 case 0x000a: /* PageFree */
869 LPVOID hmem
= (LPVOID
) stack32_pop( context
);
870 DWORD flags
= (DWORD
) stack32_pop( context
);
872 TRACE("PageFree: hmem: %08lx, flags: %08lx partial stub\n",
873 (DWORD
)hmem
, flags
);
875 ret
= VirtualFree ( hmem
, 0, MEM_RELEASE
);
877 TRACE("Returning: %d\n", ret
);
881 case 0x001e: /* GetDemandPageInfo */
883 DWORD dinfo
= (DWORD
)stack32_pop( context
);
884 DWORD flags
= (DWORD
)stack32_pop( context
);
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.
894 FIXME("GetDemandPageInfo(%08lx %08lx): stub!\n", dinfo
, flags
);
899 if (LOWORD(service
) < N_VMM_SERVICE
)
900 FIXME( "Unimplemented service %s (%08lx)\n",
901 VMM_Service_Name
[LOWORD(service
)], service
);
903 FIXME( "Unknown service %08lx\n", service
);
907 return 0xffffffff; /* FIXME */
910 /***********************************************************************
913 * These ioctls are used by 'MSNET32.DLL'.
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.
922 * IFSMgr DeviceIO service
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
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
;
943 static void win32apieq_2_CONTEXT(struct win32apireq
*pIn
,CONTEXT86
*pCxt
)
945 memset(pCxt
,0,sizeof(*pCxt
));
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
;
955 /* FIXME: Only partial CONTEXT86_CONTROL */
956 pCxt
->Ebp
= pIn
->ar_ebp
;
958 /* FIXME: pIn->ar_proid ignored */
959 /* FIXME: pIn->ar_error ignored */
960 /* FIXME: pIn->ar_pad ignored */
963 static void CONTEXT_2_win32apieq(CONTEXT86
*pCxt
,struct win32apireq
*pOut
)
965 memset(pOut
,0,sizeof(struct win32apireq
));
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
;
974 /* FIXME: Only partial CONTEXT86_CONTROL */
975 pOut
->ar_ebp
= pCxt
->Ebp
;
977 /* FIXME: pOut->ar_proid ignored */
978 /* FIXME: pOut->ar_error ignored */
979 /* FIXME: pOut->ar_pad ignored */
982 static BOOL
DeviceIo_IFSMgr(DWORD dwIoControlCode
, LPVOID lpvInBuffer
, DWORD cbInBuffer
,
983 LPVOID lpvOutBuffer
, DWORD cbOutBuffer
,
984 LPDWORD lpcbBytesReturned
,
985 LPOVERLAPPED lpOverlapped
)
988 TRACE("(%ld,%p,%ld,%p,%ld,%p,%p): stub\n",
990 lpvInBuffer
,cbInBuffer
,
991 lpvOutBuffer
,cbOutBuffer
,
995 switch (dwIoControlCode
)
1000 struct win32apireq
*pIn
=(struct win32apireq
*) lpvInBuffer
;
1001 struct win32apireq
*pOut
=(struct win32apireq
*) lpvOutBuffer
;
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
1014 win32apieq_2_CONTEXT(pIn
,&cxt
);
1016 if(dwIoControlCode
==IFS_IOCTL_21
)
1018 DOS3Call(&cxt
); /* Call int 21h */
1020 INT_Int2fHandler(&cxt
); /* Call int 2Fh */
1023 CONTEXT_2_win32apieq(&cxt
,pOut
);
1027 case IFS_IOCTL_GET_RES
:{
1028 FIXME( "Control 'IFS_IOCTL_GET_RES' not implemented\n");
1031 case IFS_IOCTL_GET_NETPRO_NAME_A
:{
1032 FIXME( "Control 'IFS_IOCTL_GET_NETPRO_NAME_A' not implemented\n");
1036 FIXME( "Control %ld not implemented\n", dwIoControlCode
);
1043 /********************************************************************************
1046 * Service numbers taken from page 448 of Pietrek's "Windows 95 System
1047 * Programming Secrets". Parameters from experimentation on real Win98.
1051 static DWORD
VxDCall_VWin32( DWORD service
, CONTEXT86
*context
)
1053 switch ( LOWORD(service
) )
1055 case 0x0000: /* GetVersion */
1057 DWORD vers
= GetVersion();
1058 return (LOBYTE(vers
) << 8) | HIBYTE(vers
);
1062 case 0x0020: /* Get VMCPD Version */
1064 DWORD parm
= (DWORD
) stack32_pop(context
);
1066 FIXME("Get VMCPD Version(%08lx): partial stub!\n", parm
);
1068 /* FIXME: This is what Win98 returns, it may
1069 * not be correct in all situations.
1070 * It makes Bleem! happy though.
1076 case 0x0029: /* Int31/DPMI dispatch */
1078 DWORD callnum
= (DWORD
) stack32_pop(context
);
1079 DWORD parm
= (DWORD
) stack32_pop(context
);
1081 TRACE("Int31/DPMI dispatch(%08lx)\n", callnum
);
1083 SET_AX( context
, callnum
);
1084 SET_CX( context
, parm
);
1085 INT_Int31Handler(context
);
1087 return LOWORD(context
->Eax
);
1091 case 0x002a: /* Int41 dispatch - parm = int41 service number */
1093 DWORD callnum
= (DWORD
) stack32_pop(context
);
1095 return callnum
; /* FIXME: should really call INT_Int41Handler() */
1100 FIXME("Unknown VWin32 service %08lx\n", service
);
1108 /***********************************************************************
1111 static BOOL
DeviceIo_VCD(DWORD dwIoControlCode
,
1112 LPVOID lpvInBuffer
, DWORD cbInBuffer
,
1113 LPVOID lpvOutBuffer
, DWORD cbOutBuffer
,
1114 LPDWORD lpcbBytesReturned
,
1115 LPOVERLAPPED lpOverlapped
)
1119 switch (dwIoControlCode
)
1121 case IOCTL_SERIAL_LSRMST_INSERT
:
1123 FIXME( "IOCTL_SERIAL_LSRMST_INSERT NIY !\n");
1129 FIXME( "Unknown Control %ld\n", dwIoControlCode
);
1138 /***********************************************************************
1142 static void DIOCRegs_2_CONTEXT( DIOC_REGISTERS
*pIn
, CONTEXT86
*pCxt
)
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 */
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
;
1156 /* FIXME: Only partial CONTEXT86_CONTROL */
1157 pCxt
->EFlags
= pIn
->reg_Flags
;
1160 static void CONTEXT_2_DIOCRegs( CONTEXT86
*pCxt
, DIOC_REGISTERS
*pOut
)
1162 memset( pOut
, 0, sizeof(DIOC_REGISTERS
) );
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
;
1171 /* FIXME: Only partial CONTEXT86_CONTROL */
1172 pOut
->reg_Flags
= pCxt
->EFlags
;
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])
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])
1187 #define DIOC_SET_CARRY(regs) (((regs)->reg_Flags)|=0x00000001)
1189 static const DWORD VWIN32_DriveTypeInfo
[7]={
1194 0x4f12, /* 1.44 M */
1195 0x4f24, /* 2.88 M */
1199 /**********************************************************************
1200 * VWIN32_ReadFloppyParams
1202 * Handler for int 13h (disk I/O).
1204 static VOID
VWIN32_ReadFloppyParams(DIOC_REGISTERS
*regs
)
1207 static BYTE floppy_params
[2][13] =
1209 { 0xaf, 0x02, 0x25, 0x02, 0x12, 0x1b, 0xff, 0x6c, 0xf6, 0x0f, 0x08 },
1210 { 0xaf, 0x02, 0x25, 0x02, 0x12, 0x1b, 0xff, 0x6c, 0xf6, 0x0f, 0x08 }
1213 unsigned int i
, nr_of_drives
= 0;
1214 BYTE drive_nr
= DIOC_DL(regs
);
1216 struct floppy_drive_params floppy_parm
;
1217 char root
[] = "A:\\";
1219 TRACE("in [ EDX=%08lx ]\n", regs
->reg_EDX
);
1221 DIOC_AH(regs
) = 0x00; /* success */
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
;
1227 if (drive_nr
> 1) { /* invalid drive ? */
1231 DIOC_SET_CARRY(regs
);
1235 if ( (floppy_fd
= DRIVE_OpenDevice( drive_nr
, O_NONBLOCK
)) == -1)
1237 WARN("Can't determine floppy geometry !\n");
1241 DIOC_SET_CARRY(regs
);
1244 r
= ioctl(floppy_fd
, FDGETDRVPRM
, &floppy_parm
);
1250 DIOC_SET_CARRY(regs
);
1256 DIOC_BL(regs
) = floppy_parm
.cmos
;
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)
1262 if(DIOC_BL(regs
) && (DIOC_BL(regs
)<7))
1264 DIOC_DH(regs
) = 0x01;
1265 DIOC_CX(regs
) = VWIN32_DriveTypeInfo
[DIOC_BL(regs
)];
1269 DIOC_CX(regs
) = 0x0;
1270 DIOC_DX(regs
) = 0x0;
1273 regs
->reg_EDI
= (DWORD
)floppy_params
[drive_nr
];
1277 ERR("Get floppy params failed for drive %d\n",drive_nr
);
1278 DIOC_SET_CARRY(regs
);
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
);
1284 /* FIXME: Word exits quietly if we return with no error. Why? */
1285 FIXME("Returned ERROR!\n");
1286 DIOC_SET_CARRY(regs
);
1289 DIOC_AH(regs
) = 0x01;
1290 DIOC_SET_CARRY(regs
);
1294 /**********************************************************************
1295 * VWIN32_Int13Handler
1297 * Handler for VWIN32_DIOC_DOS_INT13 (disk I/O).
1299 static VOID
VWIN32_Int13Handler( DIOC_REGISTERS
*regs
)
1301 TRACE("AH=%02x\n",DIOC_AH(regs
));
1302 switch(DIOC_AH(regs
)) /* AH */
1304 case 0x00: /* RESET DISK SYSTEM */
1305 break; /* no return ? */
1307 case 0x01: /* STATUS OF DISK SYSTEM */
1308 DIOC_AL(regs
) = 0; /* successful completion */
1311 case 0x02: /* READ SECTORS INTO MEMORY */
1312 DIOC_AL(regs
) = 0; /* number of sectors read */
1313 DIOC_AH(regs
) = 0; /* status */
1316 case 0x03: /* WRITE SECTORS FROM MEMORY */
1317 break; /* no return ? */
1319 case 0x04: /* VERIFY DISK SECTOR(S) */
1320 DIOC_AL(regs
) = 0; /* number of sectors verified */
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
);
1333 case 0x08: /* GET DRIVE PARAMETERS */
1334 if (DIOC_DL(regs
) & 0x80) { /* hard disk ? */
1335 DIOC_AH(regs
) = 0x07;
1336 DIOC_SET_CARRY(regs
);
1338 else /* floppy disk */
1339 VWIN32_ReadFloppyParams(regs
);
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 */
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
);
1358 else { /* floppy disk ? */
1359 DIOC_AH(regs
) = 2; /* floppy with change detection */
1360 DIOC_SET_CARRY(regs
);
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
);
1372 case 0x16: /* FLOPPY - CHANGE OF DISK STATUS */
1373 DIOC_AH(regs
) = 0; /* FIXME - no change */
1376 case 0x17: /* SET DISK TYPE FOR FORMAT */
1377 if (DIOC_DL(regs
) < 4)
1378 DIOC_AH(regs
) = 0x00; /* successful completion */
1380 DIOC_AH(regs
) = 0x01; /* error */
1383 case 0x18: /* SET MEDIA TYPE FOR FORMAT */
1384 if (DIOC_DL(regs
) < 4)
1385 DIOC_AH(regs
) = 0x00; /* successful completion */
1387 DIOC_AH(regs
) = 0x01; /* error */
1390 case 0x19: /* FIXED DISK - PARK HEADS */
1394 FIXME("Unknown VWIN32 INT13 call AX=%04X\n",DIOC_AX(regs
));
1398 static BOOL
DeviceIo_VWin32(DWORD dwIoControlCode
,
1399 LPVOID lpvInBuffer
, DWORD cbInBuffer
,
1400 LPVOID lpvOutBuffer
, DWORD cbOutBuffer
,
1401 LPDWORD lpcbBytesReturned
,
1402 LPOVERLAPPED lpOverlapped
)
1406 switch (dwIoControlCode
)
1408 case VWIN32_DIOC_DOS_INT13
:
1410 DIOC_REGISTERS
*pIn
= (DIOC_REGISTERS
*)lpvInBuffer
;
1411 DIOC_REGISTERS
*pOut
= (DIOC_REGISTERS
*)lpvOutBuffer
;
1413 memcpy(pOut
, pIn
, sizeof (DIOC_REGISTERS
));
1414 VWIN32_Int13Handler(pOut
);
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
:
1426 DIOC_REGISTERS
*pIn
= (DIOC_REGISTERS
*)lpvInBuffer
;
1427 DIOC_REGISTERS
*pOut
= (DIOC_REGISTERS
*)lpvOutBuffer
;
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
);
1439 DIOCRegs_2_CONTEXT( pIn
, &cxt
);
1441 switch (dwIoControlCode
)
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 */
1454 CONTEXT_2_DIOCRegs( &cxt
, pOut
);
1458 case VWIN32_DIOC_SIMCTRLC
:
1459 FIXME( "Control VWIN32_DIOC_SIMCTRLC not implemented\n");
1464 FIXME( "Unknown Control %ld\n", dwIoControlCode
);
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
)
1479 FIXME("(%ld,%p,%ld,%p,%ld,%p,%p): stub\n",
1481 lpvInBuffer
,cbInBuffer
,
1482 lpvOutBuffer
,cbOutBuffer
,
1486 switch (dwIoControlCode
) {
1489 *(DWORD
*)lpvOutBuffer
=0;
1490 *lpcbBytesReturned
=4;
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
)
1502 switch (dwIoControlCode
) {
1503 case 1: /* version */
1504 *(LPDWORD
)lpvOutBuffer
= 0x20004; /* WC SecretOps */
1506 case 9: /* debug output */
1507 ERR("MONODEBG: %s\n",debugstr_a(lpvInBuffer
));
1510 FIXME("(%ld,%p,%ld,%p,%ld,%p,%p): stub\n",
1512 lpvInBuffer
,cbInBuffer
,
1513 lpvOutBuffer
,cbOutBuffer
,
1522 static BOOL
DeviceIo_PCCARD (DWORD dwIoControlCode
,
1523 LPVOID lpvInBuffer
, DWORD cbInBuffer
,
1524 LPVOID lpvOutBuffer
, DWORD cbOutBuffer
,
1525 LPDWORD lpcbBytesReturned
,
1526 LPOVERLAPPED lpOverlapped
)
1528 switch (dwIoControlCode
) {
1529 case 0x0000: /* PCCARD_Get_Version */
1530 case 0x0001: /* PCCARD_Card_Services */
1532 FIXME( "(%ld,%p,%ld,%p,%ld,%p,%p): stub\n",
1534 lpvInBuffer
,cbInBuffer
,
1535 lpvOutBuffer
,cbOutBuffer
,
1544 /***********************************************************************
1545 * OpenVxDHandle (KERNEL32.@)
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,
1552 HANDLE WINAPI
OpenVxDHandle(HANDLE hHandleRing3
)
1554 FIXME( "(0x%08x), stub! (returning Ring 3 handle instead of Ring 0)\n", hHandleRing3
);
1555 return hHandleRing3
;
1558 static BOOL
DeviceIo_HASP(DWORD dwIoControlCode
, LPVOID lpvInBuffer
, DWORD cbInBuffer
,
1559 LPVOID lpvOutBuffer
, DWORD cbOutBuffer
,
1560 LPDWORD lpcbBytesReturned
,
1561 LPOVERLAPPED lpOverlapped
)
1564 FIXME("(%ld,%p,%ld,%p,%ld,%p,%p): stub\n",
1566 lpvInBuffer
,cbInBuffer
,
1567 lpvOutBuffer
,cbOutBuffer
,