?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Compile the imagehlp dll with STRICT defined.
[wine/multimedia.git] / win32 / device.c
blobb87eadef225513ec28ada23f0b1e5195811df7d3
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 * The following is a massive duplication of the advapi32 code.
567 * Unfortunately sharing the code is not possible since the native
568 * Win95 advapi32 depends on it. Someday we should probably stop
569 * supporting native Win95 advapi32 altogether...
570 */
571
572
573 #define HKEY_SPECIAL_ROOT_FIRST HKEY_CLASSES_ROOT
574 #define HKEY_SPECIAL_ROOT_LAST HKEY_DYN_DATA
575 #define NB_SPECIAL_ROOT_KEYS ((UINT)HKEY_SPECIAL_ROOT_LAST - (UINT)HKEY_SPECIAL_ROOT_FIRST + 1)
576
577 static HKEY special_root_keys[NB_SPECIAL_ROOT_KEYS];
578
579 static const WCHAR name_CLASSES_ROOT[] =
580 {'M','a','c','h','i','n','e','\\',
581 'S','o','f','t','w','a','r','e','\\',
582 'C','l','a','s','s','e','s',0};
583 static const WCHAR name_LOCAL_MACHINE[] =
584 {'M','a','c','h','i','n','e',0};
585 static const WCHAR name_USERS[] =
586 {'U','s','e','r',0};
587 static const WCHAR name_PERFORMANCE_DATA[] =
588 {'P','e','r','f','D','a','t','a',0};
589 static const WCHAR name_CURRENT_CONFIG[] =
590 {'M','a','c','h','i','n','e','\\',
591 'S','y','s','t','e','m','\\',
592 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
593 'H','a','r','d','w','a','r','e','P','r','o','f','i','l','e','s','\\',
594 'C','u','r','r','e','n','t',0};
595 static const WCHAR name_DYN_DATA[] =
596 {'D','y','n','D','a','t','a',0};
597
598 #define DECL_STR(key) { sizeof(name_##key)-sizeof(WCHAR), sizeof(name_##key), (LPWSTR)name_##key }
599 static UNICODE_STRING root_key_names[NB_SPECIAL_ROOT_KEYS] =
600 {
601 DECL_STR(CLASSES_ROOT),
602 { 0, 0, NULL }, /* HKEY_CURRENT_USER is determined dynamically */
603 DECL_STR(LOCAL_MACHINE),
604 DECL_STR(USERS),
605 DECL_STR(PERFORMANCE_DATA),
606 DECL_STR(CURRENT_CONFIG),
607 DECL_STR(DYN_DATA)
608 };
609 #undef DECL_STR
610
611
612 /* check if value type needs string conversion (Ansi<->Unicode) */
613 inline static int is_string( DWORD type )
614 {
615 return (type == REG_SZ) || (type == REG_EXPAND_SZ) || (type == REG_MULTI_SZ);
616 }
617
618 /* create one of the HKEY_* special root keys */
619 static HKEY create_special_root_hkey( HKEY hkey, DWORD access )
620 {
621 HKEY ret = 0;
622 int idx = (UINT)hkey - (UINT)HKEY_SPECIAL_ROOT_FIRST;
623
624 if (hkey == HKEY_CURRENT_USER)
625 {
626 if (RtlOpenCurrentUser( access, &hkey )) return 0;
627 }
628 else
629 {
630 OBJECT_ATTRIBUTES attr;
631
632 attr.Length = sizeof(attr);
633 attr.RootDirectory = 0;
634 attr.ObjectName = &root_key_names[idx];
635 attr.Attributes = 0;
636 attr.SecurityDescriptor = NULL;
637 attr.SecurityQualityOfService = NULL;
638 if (NtCreateKey( &hkey, access, &attr, 0, NULL, 0, NULL )) return 0;
639 }
640
641 if (!(ret = InterlockedCompareExchange( (PLONG)&special_root_keys[idx], hkey, 0 )))
642 ret = hkey;
643 else
644 NtClose( hkey ); /* somebody beat us to it */
645 return ret;
646 }
647
648 /* map the hkey from special root to normal key if necessary */
649 inline static HKEY get_special_root_hkey( HKEY hkey )
650 {
651 HKEY ret = hkey;
652
653 if ((hkey >= HKEY_SPECIAL_ROOT_FIRST) && (hkey <= HKEY_SPECIAL_ROOT_LAST))
654 {
655 if (!(ret = special_root_keys[(UINT)hkey - (UINT)HKEY_SPECIAL_ROOT_FIRST]))
656 ret = create_special_root_hkey( hkey, KEY_ALL_ACCESS );
657 }
658 return ret;
659 }
660
661
662 /******************************************************************************
663 * VMM_RegCreateKeyA
664 */
665 static DWORD VMM_RegCreateKeyA( HKEY hkey, LPCSTR name, PHKEY retkey )
666 {
667 OBJECT_ATTRIBUTES attr;
668 UNICODE_STRING nameW;
669 ANSI_STRING nameA;
670 NTSTATUS status;
671
672 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
673
674 attr.Length = sizeof(attr);
675 attr.RootDirectory = hkey;
676 attr.ObjectName = &nameW;
677 attr.Attributes = 0;
678 attr.SecurityDescriptor = NULL;
679 attr.SecurityQualityOfService = NULL;
680 RtlInitAnsiString( &nameA, name );
681
682 if (!(status = RtlAnsiStringToUnicodeString( &nameW, &nameA, TRUE )))
683 {
684 status = NtCreateKey( retkey, KEY_ALL_ACCESS, &attr, 0, NULL,
685 REG_OPTION_NON_VOLATILE, NULL );
686 RtlFreeUnicodeString( &nameW );
687 }
688 return RtlNtStatusToDosError( status );
689 }
690
691
692 /******************************************************************************
693 * VMM_RegOpenKeyExA
694 */
695 DWORD WINAPI VMM_RegOpenKeyExA(HKEY hkey, LPCSTR name, DWORD reserved, REGSAM access, PHKEY retkey)
696 {
697 OBJECT_ATTRIBUTES attr;
698 UNICODE_STRING nameW;
699 STRING nameA;
700 NTSTATUS status;
701
702 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
703
704 attr.Length = sizeof(attr);
705 attr.RootDirectory = hkey;
706 attr.ObjectName = &nameW;
707 attr.Attributes = 0;
708 attr.SecurityDescriptor = NULL;
709 attr.SecurityQualityOfService = NULL;
710
711 RtlInitAnsiString( &nameA, name );
712 if (!(status = RtlAnsiStringToUnicodeString( &nameW, &nameA, TRUE )))
713 {
714 status = NtOpenKey( retkey, access, &attr );
715 RtlFreeUnicodeString( &nameW );
716 }
717 return RtlNtStatusToDosError( status );
718 }
719
720
721 /******************************************************************************
722 * VMM_RegCloseKey
723 */
724 static DWORD VMM_RegCloseKey( HKEY hkey )
725 {
726 if (!hkey || hkey >= (HKEY)0x80000000) return ERROR_SUCCESS;
727 return RtlNtStatusToDosError( NtClose( hkey ) );
728 }
729
730
731 /******************************************************************************
732 * VMM_RegDeleteKeyA
733 */
734 static DWORD VMM_RegDeleteKeyA( HKEY hkey, LPCSTR name )
735 {
736 DWORD ret;
737 HKEY tmp;
738
739 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
740
741 if (!name || !*name) return RtlNtStatusToDosError( NtDeleteKey( hkey ) );
742 if (!(ret = VMM_RegOpenKeyExA( hkey, name, 0, 0, &tmp )))
743 {
744 ret = RtlNtStatusToDosError( NtDeleteKey( tmp ) );
745 NtClose( tmp );
746 }
747 return ret;
748 }
749
750
751 /******************************************************************************
752 * VMM_RegSetValueExA
753 */
754 static DWORD VMM_RegSetValueExA( HKEY hkey, LPCSTR name, DWORD reserved, DWORD type,
755 CONST BYTE *data, DWORD count )
756 {
757 UNICODE_STRING nameW;
758 ANSI_STRING nameA;
759 WCHAR *dataW = NULL;
760 NTSTATUS status;
761
762 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
763
764 if (is_string(type))
765 {
766 DWORD lenW;
767
768 if (count)
769 {
770 /* if user forgot to count terminating null, add it (yes NT does this) */
771 if (data[count-1] && !data[count]) count++;
772 }
773 RtlMultiByteToUnicodeSize( &lenW, data, count );
774 if (!(dataW = HeapAlloc( GetProcessHeap(), 0, lenW ))) return ERROR_OUTOFMEMORY;
775 RtlMultiByteToUnicodeN( dataW, lenW, NULL, data, count );
776 count = lenW;
777 data = (BYTE *)dataW;
778 }
779
780 RtlInitAnsiString( &nameA, name );
781 if (!(status = RtlAnsiStringToUnicodeString( &nameW, &nameA, TRUE )))
782 {
783 status = NtSetValueKey( hkey, &nameW, 0, type, data, count );
784 RtlFreeUnicodeString( &nameW );
785 }
786 if (dataW) HeapFree( GetProcessHeap(), 0, dataW );
787 return RtlNtStatusToDosError( status );
788 }
789
790
791 /******************************************************************************
792 * VMM_RegSetValueA
793 */
794 static DWORD VMM_RegSetValueA( HKEY hkey, LPCSTR name, DWORD type, LPCSTR data, DWORD count )
795 {
796 HKEY subkey = hkey;
797 DWORD ret;
798
799 if (type != REG_SZ) return ERROR_INVALID_PARAMETER;
800
801 if (name && name[0]) /* need to create the subkey */
802 {
803 if ((ret = VMM_RegCreateKeyA( hkey, name, &subkey )) != ERROR_SUCCESS) return ret;
804 }
805 ret = VMM_RegSetValueExA( subkey, NULL, 0, REG_SZ, (LPBYTE)data, strlen(data)+1 );
806 if (subkey != hkey) NtClose( subkey );
807 return ret;
808 }
809
810
811 /******************************************************************************
812 * VMM_RegDeleteValueA
813 */
814 static DWORD VMM_RegDeleteValueA( HKEY hkey, LPCSTR name )
815 {
816 UNICODE_STRING nameW;
817 STRING nameA;
818 NTSTATUS status;
819
820 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
821
822 RtlInitAnsiString( &nameA, name );
823 if (!(status = RtlAnsiStringToUnicodeString( &nameW, &nameA, TRUE )))
824 {
825 status = NtDeleteValueKey( hkey, &nameW );
826 RtlFreeUnicodeString( &nameW );
827 }
828 return RtlNtStatusToDosError( status );
829 }
830
831
832 /******************************************************************************
833 * VMM_RegQueryValueExA
834 */
835 static DWORD VMM_RegQueryValueExA( HKEY hkey, LPCSTR name, LPDWORD reserved, LPDWORD type,
836 LPBYTE data, LPDWORD count )
837 {
838 NTSTATUS status;
839 ANSI_STRING nameA;
840 UNICODE_STRING nameW;
841 DWORD total_size;
842 char buffer[256], *buf_ptr = buffer;
843 KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)buffer;
844 static const int info_size = offsetof( KEY_VALUE_PARTIAL_INFORMATION, Data );
845
846 if ((data && !count) || reserved) return ERROR_INVALID_PARAMETER;
847 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
848
849 RtlInitAnsiString( &nameA, name );
850 if ((status = RtlAnsiStringToUnicodeString( &nameW, &nameA, TRUE )))
851 return RtlNtStatusToDosError(status);
852
853 status = NtQueryValueKey( hkey, &nameW, KeyValuePartialInformation,
854 buffer, sizeof(buffer), &total_size );
855 if (status && status != STATUS_BUFFER_OVERFLOW) goto done;
856
857 /* we need to fetch the contents for a string type even if not requested,
858 * because we need to compute the length of the ASCII string. */
859 if (data || is_string(info->Type))
860 {
861 /* retry with a dynamically allocated buffer */
862 while (status == STATUS_BUFFER_OVERFLOW)
863 {
864 if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
865 if (!(buf_ptr = HeapAlloc( GetProcessHeap(), 0, total_size )))
866 {
867 status = STATUS_NO_MEMORY;
868 goto done;
869 }
870 info = (KEY_VALUE_PARTIAL_INFORMATION *)buf_ptr;
871 status = NtQueryValueKey( hkey, &nameW, KeyValuePartialInformation,
872 buf_ptr, total_size, &total_size );
873 }
874
875 if (!status)
876 {
877 if (is_string(info->Type))
878 {
879 DWORD len = WideCharToMultiByte( CP_ACP, 0, (WCHAR *)(buf_ptr + info_size),
880 (total_size - info_size) /sizeof(WCHAR),
881 NULL, 0, NULL, NULL );
882 if (data && len)
883 {
884 if (len > *count) status = STATUS_BUFFER_OVERFLOW;
885 else
886 {
887 WideCharToMultiByte( CP_ACP, 0, (WCHAR *)(buf_ptr + info_size),
888 (total_size - info_size) /sizeof(WCHAR),
889 data, len, NULL, NULL );
890 /* if the type is REG_SZ and data is not 0-terminated
891 * and there is enough space in the buffer NT appends a \0 */
892 if (len < *count && data[len-1]) data[len] = 0;
893 }
894 }
895 total_size = len + info_size;
896 }
897 else if (data)
898 {
899 if (total_size - info_size > *count) status = STATUS_BUFFER_OVERFLOW;
900 else memcpy( data, buf_ptr + info_size, total_size - info_size );
901 }
902 }
903 else if (status != STATUS_BUFFER_OVERFLOW) goto done;
904 }
905
906 if (type) *type = info->Type;
907 if (count) *count = total_size - info_size;
908
909 done:
910 if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
911 RtlFreeUnicodeString( &nameW );
912 return RtlNtStatusToDosError(status);
913 }
914
915
916 /******************************************************************************
917 * VMM_RegQueryValueA
918 */
919 static DWORD VMM_RegQueryValueA( HKEY hkey, LPCSTR name, LPSTR data, LPLONG count )
920 {
921 DWORD ret;
922 HKEY subkey = hkey;
923
924 if (name && name[0])
925 {
926 if ((ret = VMM_RegOpenKeyExA( hkey, name, 0, KEY_ALL_ACCESS, &subkey )) != ERROR_SUCCESS)
927 return ret;
928 }
929 ret = VMM_RegQueryValueExA( subkey, NULL, NULL, NULL, (LPBYTE)data, count );
930 if (subkey != hkey) NtClose( subkey );
931 if (ret == ERROR_FILE_NOT_FOUND)
932 {
933 /* return empty string if default value not found */
934 if (data) *data = 0;
935 if (count) *count = 1;
936 ret = ERROR_SUCCESS;
937 }
938 return ret;
939 }
940
941
942 /******************************************************************************
943 * VMM_RegEnumValueA
944 */
945 static DWORD VMM_RegEnumValueA( HKEY hkey, DWORD index, LPSTR value, LPDWORD val_count,
946 LPDWORD reserved, LPDWORD type, LPBYTE data, LPDWORD count )
947 {
948 NTSTATUS status;
949 DWORD total_size;
950 char buffer[256], *buf_ptr = buffer;
951 KEY_VALUE_FULL_INFORMATION *info = (KEY_VALUE_FULL_INFORMATION *)buffer;
952 static const int info_size = offsetof( KEY_VALUE_FULL_INFORMATION, Name );
953
954 TRACE("(%x,%ld,%p,%p,%p,%p,%p,%p)\n",
955 hkey, index, value, val_count, reserved, type, data, count );
956
957 /* NT only checks count, not val_count */
958 if ((data && !count) || reserved) return ERROR_INVALID_PARAMETER;
959 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
960
961 total_size = info_size + (MAX_PATH + 1) * sizeof(WCHAR);
962 if (data) total_size += *count;
963 total_size = min( sizeof(buffer), total_size );
964
965 status = NtEnumerateValueKey( hkey, index, KeyValueFullInformation,
966 buffer, total_size, &total_size );
967 if (status && status != STATUS_BUFFER_OVERFLOW) goto done;
968
969 /* we need to fetch the contents for a string type even if not requested,
970 * because we need to compute the length of the ASCII string. */
971 if (value || data || is_string(info->Type))
972 {
973 /* retry with a dynamically allocated buffer */
974 while (status == STATUS_BUFFER_OVERFLOW)
975 {
976 if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
977 if (!(buf_ptr = HeapAlloc( GetProcessHeap(), 0, total_size )))
978 return ERROR_NOT_ENOUGH_MEMORY;
979 info = (KEY_VALUE_FULL_INFORMATION *)buf_ptr;
980 status = NtEnumerateValueKey( hkey, index, KeyValueFullInformation,
981 buf_ptr, total_size, &total_size );
982 }
983
984 if (status) goto done;
985
986 if (is_string(info->Type))
987 {
988 DWORD len;
989 RtlUnicodeToMultiByteSize( &len, (WCHAR *)(buf_ptr + info->DataOffset),
990 total_size - info->DataOffset );
991 if (data && len)
992 {
993 if (len > *count) status = STATUS_BUFFER_OVERFLOW;
994 else
995 {
996 RtlUnicodeToMultiByteN( data, len, NULL, (WCHAR *)(buf_ptr + info->DataOffset),
997 total_size - info->DataOffset );
998 /* if the type is REG_SZ and data is not 0-terminated
999 * and there is enough space in the buffer NT appends a \0 */
1000 if (len < *count && data[len-1]) data[len] = 0;
1001 }
1002 }
1003 info->DataLength = len;
1004 }
1005 else if (data)
1006 {
1007 if (total_size - info->DataOffset > *count) status = STATUS_BUFFER_OVERFLOW;
1008 else memcpy( data, buf_ptr + info->DataOffset, total_size - info->DataOffset );
1009 }
1010
1011 if (value && !status)
1012 {
1013 DWORD len;
1014
1015 RtlUnicodeToMultiByteSize( &len, info->Name, info->NameLength );
1016 if (len >= *val_count)
1017 {
1018 status = STATUS_BUFFER_OVERFLOW;
1019 if (*val_count)
1020 {
1021 len = *val_count - 1;
1022 RtlUnicodeToMultiByteN( value, len, NULL, info->Name, info->NameLength );
1023 value[len] = 0;
1024 }
1025 }
1026 else
1027 {
1028 RtlUnicodeToMultiByteN( value, len, NULL, info->Name, info->NameLength );
1029 value[len] = 0;
1030 *val_count = len;
1031 }
1032 }
1033 }
1034 else status = STATUS_SUCCESS;
1035
1036 if (type) *type = info->Type;
1037 if (count) *count = info->DataLength;
1038
1039 done:
1040 if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
1041 return RtlNtStatusToDosError(status);
1042 }
1043
1044
1045 /******************************************************************************
1046 * VMM_RegEnumKeyA
1047 */
1048 static DWORD VMM_RegEnumKeyA( HKEY hkey, DWORD index, LPSTR name, DWORD name_len )
1049 {
1050 NTSTATUS status;
1051 char buffer[256], *buf_ptr = buffer;
1052 KEY_NODE_INFORMATION *info = (KEY_NODE_INFORMATION *)buffer;
1053 DWORD total_size;
1054
1055 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
1056
1057 status = NtEnumerateKey( hkey, index, KeyNodeInformation,
1058 buffer, sizeof(buffer), &total_size );
1059
1060 while (status == STATUS_BUFFER_OVERFLOW)
1061 {
1062 /* retry with a dynamically allocated buffer */
1063 if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
1064 if (!(buf_ptr = HeapAlloc( GetProcessHeap(), 0, total_size )))
1065 return ERROR_NOT_ENOUGH_MEMORY;
1066 info = (KEY_NODE_INFORMATION *)buf_ptr;
1067 status = NtEnumerateKey( hkey, index, KeyNodeInformation,
1068 buf_ptr, total_size, &total_size );
1069 }
1070
1071 if (!status)
1072 {
1073 DWORD len;
1074
1075 RtlUnicodeToMultiByteSize( &len, info->Name, info->NameLength );
1076 if (len >= name_len) status = STATUS_BUFFER_OVERFLOW;
1077 else
1078 {
1079 RtlUnicodeToMultiByteN( name, len, NULL, info->Name, info->NameLength );
1080 name[len] = 0;
1081 }
1082 }
1083
1084 if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
1085 return RtlNtStatusToDosError( status );
1086 }
1087
1088
1089 /******************************************************************************
1090 * VMM_RegQueryInfoKeyA
1091 *
1092 * NOTE: This VxDCall takes only a subset of the parameters that the
1093 * corresponding Win32 API call does. The implementation in Win95
1094 * ADVAPI32 sets all output parameters not mentioned here to zero.
1095 */
1096 static DWORD VMM_RegQueryInfoKeyA( HKEY hkey, LPDWORD subkeys, LPDWORD max_subkey,
1097 LPDWORD values, LPDWORD max_value, LPDWORD max_data )
1098 {
1099 NTSTATUS status;
1100 KEY_FULL_INFORMATION info;
1101 DWORD total_size;
1102
1103 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
1104
1105 status = NtQueryKey( hkey, KeyFullInformation, &info, sizeof(info), &total_size );
1106 if (status && status != STATUS_BUFFER_OVERFLOW) return RtlNtStatusToDosError( status );
1107
1108 if (subkeys) *subkeys = info.SubKeys;
1109 if (max_subkey) *max_subkey = info.MaxNameLen;
1110 if (values) *values = info.Values;
1111 if (max_value) *max_value = info.MaxValueNameLen;
1112 if (max_data) *max_data = info.MaxValueDataLen;
1113 return ERROR_SUCCESS;
1114 }
1115
1116
1117 /***********************************************************************
1118 * VxDCall_VMM
1119 */
1120 static DWORD VxDCall_VMM( DWORD service, CONTEXT86 *context )
1121 {
1122 switch ( LOWORD(service) )
1123 {
1124 case 0x0011: /* RegOpenKey */
1125 {
1126 HKEY hkey = (HKEY) stack32_pop( context );
1127 LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
1128 PHKEY retkey = (PHKEY)stack32_pop( context );
1129 return VMM_RegOpenKeyExA( hkey, lpszSubKey, 0, KEY_ALL_ACCESS, retkey );
1130 }
1131
1132 case 0x0012: /* RegCreateKey */
1133 {
1134 HKEY hkey = (HKEY) stack32_pop( context );
1135 LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
1136 PHKEY retkey = (PHKEY)stack32_pop( context );
1137 return VMM_RegCreateKeyA( hkey, lpszSubKey, retkey );
1138 }
1139
1140 case 0x0013: /* RegCloseKey */
1141 {
1142 HKEY hkey = (HKEY)stack32_pop( context );
1143 return VMM_RegCloseKey( hkey );
1144 }
1145
1146 case 0x0014: /* RegDeleteKey */
1147 {
1148 HKEY hkey = (HKEY) stack32_pop( context );
1149 LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
1150 return VMM_RegDeleteKeyA( hkey, lpszSubKey );
1151 }
1152
1153 case 0x0015: /* RegSetValue */
1154 {
1155 HKEY hkey = (HKEY) stack32_pop( context );
1156 LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
1157 DWORD dwType = (DWORD) stack32_pop( context );
1158 LPCSTR lpszData = (LPCSTR)stack32_pop( context );
1159 DWORD cbData = (DWORD) stack32_pop( context );
1160 return VMM_RegSetValueA( hkey, lpszSubKey, dwType, lpszData, cbData );
1161 }
1162
1163 case 0x0016: /* RegDeleteValue */
1164 {
1165 HKEY hkey = (HKEY) stack32_pop( context );
1166 LPSTR lpszValue = (LPSTR)stack32_pop( context );
1167 return VMM_RegDeleteValueA( hkey, lpszValue );
1168 }
1169
1170 case 0x0017: /* RegQueryValue */
1171 {
1172 HKEY hkey = (HKEY) stack32_pop( context );
1173 LPSTR lpszSubKey = (LPSTR) stack32_pop( context );
1174 LPSTR lpszData = (LPSTR) stack32_pop( context );
1175 LPDWORD lpcbData = (LPDWORD)stack32_pop( context );
1176 return VMM_RegQueryValueA( hkey, lpszSubKey, lpszData, lpcbData );
1177 }
1178
1179 case 0x0018: /* RegEnumKey */
1180 {
1181 HKEY hkey = (HKEY) stack32_pop( context );
1182 DWORD iSubkey = (DWORD)stack32_pop( context );
1183 LPSTR lpszName = (LPSTR)stack32_pop( context );
1184 DWORD lpcchName = (DWORD)stack32_pop( context );
1185 return VMM_RegEnumKeyA( hkey, iSubkey, lpszName, lpcchName );
1186 }
1187
1188 case 0x0019: /* RegEnumValue */
1189 {
1190 HKEY hkey = (HKEY) stack32_pop( context );
1191 DWORD iValue = (DWORD) stack32_pop( context );
1192 LPSTR lpszValue = (LPSTR) stack32_pop( context );
1193 LPDWORD lpcchValue = (LPDWORD)stack32_pop( context );
1194 LPDWORD lpReserved = (LPDWORD)stack32_pop( context );
1195 LPDWORD lpdwType = (LPDWORD)stack32_pop( context );
1196 LPBYTE lpbData = (LPBYTE) stack32_pop( context );
1197 LPDWORD lpcbData = (LPDWORD)stack32_pop( context );
1198 return VMM_RegEnumValueA( hkey, iValue, lpszValue, lpcchValue,
1199 lpReserved, lpdwType, lpbData, lpcbData );
1200 }
1201
1202 case 0x001A: /* RegQueryValueEx */
1203 {
1204 HKEY hkey = (HKEY) stack32_pop( context );
1205 LPSTR lpszValue = (LPSTR) stack32_pop( context );
1206 LPDWORD lpReserved = (LPDWORD)stack32_pop( context );
1207 LPDWORD lpdwType = (LPDWORD)stack32_pop( context );
1208 LPBYTE lpbData = (LPBYTE) stack32_pop( context );
1209 LPDWORD lpcbData = (LPDWORD)stack32_pop( context );
1210 return VMM_RegQueryValueExA( hkey, lpszValue, lpReserved,
1211 lpdwType, lpbData, lpcbData );
1212 }
1213
1214 case 0x001B: /* RegSetValueEx */
1215 {
1216 HKEY hkey = (HKEY) stack32_pop( context );
1217 LPSTR lpszValue = (LPSTR) stack32_pop( context );
1218 DWORD dwReserved = (DWORD) stack32_pop( context );
1219 DWORD dwType = (DWORD) stack32_pop( context );
1220 LPBYTE lpbData = (LPBYTE)stack32_pop( context );
1221 DWORD cbData = (DWORD) stack32_pop( context );
1222 return VMM_RegSetValueExA( hkey, lpszValue, dwReserved,
1223 dwType, lpbData, cbData );
1224 }
1225
1226 case 0x001C: /* RegFlushKey */
1227 {
1228 HKEY hkey = (HKEY)stack32_pop( context );
1229 FIXME( "RegFlushKey(%x): stub\n", hkey );
1230 return ERROR_SUCCESS;
1231 }
1232
1233 case 0x001D: /* RegQueryInfoKey */
1234 {
1235 /* NOTE: This VxDCall takes only a subset of the parameters that the
1236 corresponding Win32 API call does. The implementation in Win95
1237 ADVAPI32 sets all output parameters not mentioned here to zero. */
1238
1239 HKEY hkey = (HKEY) stack32_pop( context );
1240 LPDWORD lpcSubKeys = (LPDWORD)stack32_pop( context );
1241 LPDWORD lpcchMaxSubKey = (LPDWORD)stack32_pop( context );
1242 LPDWORD lpcValues = (LPDWORD)stack32_pop( context );
1243 LPDWORD lpcchMaxValueName = (LPDWORD)stack32_pop( context );
1244 LPDWORD lpcchMaxValueData = (LPDWORD)stack32_pop( context );
1245 return VMM_RegQueryInfoKeyA( hkey, lpcSubKeys, lpcchMaxSubKey,
1246 lpcValues, lpcchMaxValueName, lpcchMaxValueData );
1247 }
1248
1249 case 0x0021: /* RegLoadKey */
1250 {
1251 HKEY hkey = (HKEY) stack32_pop( context );
1252 LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
1253 LPCSTR lpszFile = (LPCSTR)stack32_pop( context );
1254 FIXME("RegLoadKey(%x,%s,%s): stub\n",hkey, debugstr_a(lpszSubKey), debugstr_a(lpszFile));
1255 return ERROR_SUCCESS;
1256 }
1257
1258 case 0x0022: /* RegUnLoadKey */
1259 {
1260 HKEY hkey = (HKEY) stack32_pop( context );
1261 LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
1262 FIXME("RegUnLoadKey(%x,%s): stub\n",hkey, debugstr_a(lpszSubKey));
1263 return ERROR_SUCCESS;
1264 }
1265
1266 case 0x0023: /* RegSaveKey */
1267 {
1268 HKEY hkey = (HKEY) stack32_pop( context );
1269 LPCSTR lpszFile = (LPCSTR)stack32_pop( context );
1270 LPSECURITY_ATTRIBUTES sa = (LPSECURITY_ATTRIBUTES)stack32_pop( context );
1271 FIXME("RegSaveKey(%x,%s,%p): stub\n",hkey, debugstr_a(lpszFile),sa);
1272 return ERROR_SUCCESS;
1273 }
1274
1275 #if 0 /* Functions are not yet implemented in misc/registry.c */
1276 case 0x0024: /* RegRemapPreDefKey */
1277 case 0x0026: /* RegQueryMultipleValues */
1278 #endif
1279
1280 case 0x0027: /* RegReplaceKey */
1281 {
1282 HKEY hkey = (HKEY) stack32_pop( context );
1283 LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
1284 LPCSTR lpszNewFile= (LPCSTR)stack32_pop( context );
1285 LPCSTR lpszOldFile= (LPCSTR)stack32_pop( context );
1286 FIXME("RegReplaceKey(%x,%s,%s,%s): stub\n", hkey, debugstr_a(lpszSubKey),
1287 debugstr_a(lpszNewFile),debugstr_a(lpszOldFile));
1288 return ERROR_SUCCESS;
1289 }
1290
1291 case 0x0000: /* PageReserve */
1292 {
1293 LPVOID address;
1294 LPVOID ret;
1295 DWORD psize = getpagesize();
1296 ULONG page = (ULONG) stack32_pop( context );
1297 ULONG npages = (ULONG) stack32_pop( context );
1298 ULONG flags = (ULONG) stack32_pop( context );
1299
1300 TRACE("PageReserve: page: %08lx, npages: %08lx, flags: %08lx partial stub!\n",
1301 page, npages, flags );
1302
1303 if ( page == PR_SYSTEM ) {
1304 ERR("Can't reserve ring 1 memory\n");
1305 return -1;
1306 }
1307 /* FIXME: This has to be handled separately for the separate
1308 address-spaces we now have */
1309 if ( page == PR_PRIVATE || page == PR_SHARED ) page = 0;
1310 /* FIXME: Handle flags in some way */
1311 address = (LPVOID )(page * psize);
1312 ret = VirtualAlloc ( address, ( npages * psize ), MEM_RESERVE, 0 );
1313 TRACE("PageReserve: returning: %08lx\n", (DWORD )ret );
1314 if ( ret == NULL )
1315 return -1;
1316 else
1317 return (DWORD )ret;
1318 }
1319
1320 case 0x0001: /* PageCommit */
1321 {
1322 LPVOID address;
1323 LPVOID ret;
1324 DWORD virt_perm;
1325 DWORD psize = getpagesize();
1326 ULONG page = (ULONG) stack32_pop( context );
1327 ULONG npages = (ULONG) stack32_pop( context );
1328 ULONG hpd = (ULONG) stack32_pop( context );
1329 ULONG pagerdata = (ULONG) stack32_pop( context );
1330 ULONG flags = (ULONG) stack32_pop( context );
1331
1332 TRACE("PageCommit: page: %08lx, npages: %08lx, hpd: %08lx pagerdata: "
1333 "%08lx, flags: %08lx partial stub\n",
1334 page, npages, hpd, pagerdata, flags );
1335
1336 if ( flags & PC_USER )
1337 if ( flags & PC_WRITEABLE )
1338 virt_perm = PAGE_EXECUTE_READWRITE;
1339 else
1340 virt_perm = PAGE_EXECUTE_READ;
1341 else
1342 virt_perm = PAGE_NOACCESS;
1343
1344 address = (LPVOID )(page * psize);
1345 ret = VirtualAlloc ( address, ( npages * psize ), MEM_COMMIT, virt_perm );
1346 TRACE("PageCommit: Returning: %08lx\n", (DWORD )ret );
1347 return (DWORD )ret;
1348
1349 }
1350 case 0x0002: /* PageDecommit */
1351 {
1352 LPVOID address;
1353 BOOL ret;
1354 DWORD psize = getpagesize();
1355 ULONG page = (ULONG) stack32_pop( context );
1356 ULONG npages = (ULONG) stack32_pop( context );
1357 ULONG flags = (ULONG) stack32_pop( context );
1358
1359 TRACE("PageDecommit: page: %08lx, npages: %08lx, flags: %08lx partial stub\n",
1360 page, npages, flags );
1361 address = (LPVOID )( page * psize );
1362 ret = VirtualFree ( address, ( npages * psize ), MEM_DECOMMIT );
1363 TRACE("PageDecommit: Returning: %s\n", ret ? "TRUE" : "FALSE" );
1364 return ret;
1365 }
1366 case 0x000d: /* PageModifyPermissions */
1367 {
1368 DWORD pg_old_perm;
1369 DWORD pg_new_perm;
1370 DWORD virt_old_perm;
1371 DWORD virt_new_perm;
1372 MEMORY_BASIC_INFORMATION mbi;
1373 LPVOID address;
1374 DWORD psize = getpagesize();
1375 ULONG page = stack32_pop ( context );
1376 ULONG npages = stack32_pop ( context );
1377 ULONG permand = stack32_pop ( context );
1378 ULONG permor = stack32_pop ( context );
1379
1380 TRACE("PageModifyPermissions %08lx %08lx %08lx %08lx partial stub\n",
1381 page, npages, permand, permor );
1382 address = (LPVOID )( page * psize );
1383
1384 VirtualQuery ( address, &mbi, sizeof ( MEMORY_BASIC_INFORMATION ));
1385 virt_old_perm = mbi.Protect;
1386
1387 switch ( virt_old_perm & mbi.Protect ) {
1388 case PAGE_READONLY:
1389 case PAGE_EXECUTE:
1390 case PAGE_EXECUTE_READ:
1391 pg_old_perm = PC_USER;
1392 break;
1393 case PAGE_READWRITE:
1394 case PAGE_WRITECOPY:
1395 case PAGE_EXECUTE_READWRITE:
1396 case PAGE_EXECUTE_WRITECOPY:
1397 pg_old_perm = PC_USER | PC_WRITEABLE;
1398 break;
1399 case PAGE_NOACCESS:
1400 default:
1401 pg_old_perm = 0;
1402 break;
1403 }
1404 pg_new_perm = pg_old_perm;
1405 pg_new_perm &= permand & ~PC_STATIC;
1406 pg_new_perm |= permor & ~PC_STATIC;
1407
1408 virt_new_perm = ( virt_old_perm ) & ~0xff;
1409 if ( pg_new_perm & PC_USER )
1410 {
1411 if ( pg_new_perm & PC_WRITEABLE )
1412 virt_new_perm |= PAGE_EXECUTE_READWRITE;
1413 else
1414 virt_new_perm |= PAGE_EXECUTE_READ;
1415 }
1416
1417 if ( ! VirtualProtect ( address, ( npages * psize ), virt_new_perm, &virt_old_perm ) ) {
1418 ERR("Can't change page permissions for %08lx\n", (DWORD )address );
1419 return 0xffffffff;
1420 }
1421 TRACE("Returning: %08lx\n", pg_old_perm );
1422 return pg_old_perm;
1423 }
1424 case 0x000a: /* PageFree */
1425 {
1426 BOOL ret;
1427 LPVOID hmem = (LPVOID) stack32_pop( context );
1428 DWORD flags = (DWORD ) stack32_pop( context );
1429
1430 TRACE("PageFree: hmem: %08lx, flags: %08lx partial stub\n",
1431 (DWORD )hmem, flags );
1432
1433 ret = VirtualFree ( hmem, 0, MEM_RELEASE );
1434 context->Eax = ret;
1435 TRACE("Returning: %d\n", ret );
1436
1437 return 0;
1438 }
1439 case 0x001e: /* GetDemandPageInfo */
1440 {
1441 DWORD dinfo = (DWORD)stack32_pop( context );
1442 DWORD flags = (DWORD)stack32_pop( context );
1443
1444 /* GetDemandPageInfo is supposed to fill out the struct at
1445 * "dinfo" with various low-level memory management information.
1446 * Apps are certainly not supposed to call this, although it's
1447 * demoed and documented by Pietrek on pages 441-443 of "Windows
1448 * 95 System Programming Secrets" if any program needs a real
1449 * implementation of this.
1450 */
1451
1452 FIXME("GetDemandPageInfo(%08lx %08lx): stub!\n", dinfo, flags);
1453
1454 return 0;
1455 }
1456 default:
1457 if (LOWORD(service) < N_VMM_SERVICE)
1458 FIXME( "Unimplemented service %s (%08lx)\n",
1459 VMM_Service_Name[LOWORD(service)], service);
1460 else
1461 FIXME( "Unknown service %08lx\n", service);
1462 break;
1463 }
1464
1465 return 0xffffffff; /* FIXME */
1466 }
1467
1468 /***********************************************************************
1469 * DeviceIo_IFSMgr
1470 * NOTES
1471 * These ioctls are used by 'MSNET32.DLL'.
1472 *
1473 * I have been unable to uncover any documentation about the ioctls so
1474 * the implementation of the cases IFS_IOCTL_21 and IFS_IOCTL_2F are
1475 * based on reasonable guesses on information found in the Windows 95 DDK.
1476 *
1477 */
1478
1479 /*
1480 * IFSMgr DeviceIO service
1481 */
1482
1483 #define IFS_IOCTL_21 100
1484 #define IFS_IOCTL_2F 101
1485 #define IFS_IOCTL_GET_RES 102
1486 #define IFS_IOCTL_GET_NETPRO_NAME_A 103
1487
1488 struct win32apireq {
1489 unsigned long ar_proid;
1490 unsigned long ar_eax;
1491 unsigned long ar_ebx;
1492 unsigned long ar_ecx;
1493 unsigned long ar_edx;
1494 unsigned long ar_esi;
1495 unsigned long ar_edi;
1496 unsigned long ar_ebp;
1497 unsigned short ar_error;
1498 unsigned short ar_pad;
1499 };
1500
1501 static void win32apieq_2_CONTEXT(struct win32apireq *pIn,CONTEXT86 *pCxt)
1502 {
1503 memset(pCxt,0,sizeof(*pCxt));
1504
1505 pCxt->ContextFlags=CONTEXT86_INTEGER|CONTEXT86_CONTROL;
1506 pCxt->Eax = pIn->ar_eax;
1507 pCxt->Ebx = pIn->ar_ebx;
1508 pCxt->Ecx = pIn->ar_ecx;
1509 pCxt->Edx = pIn->ar_edx;
1510 pCxt->Esi = pIn->ar_esi;
1511 pCxt->Edi = pIn->ar_edi;
1512
1513 /* FIXME: Only partial CONTEXT86_CONTROL */
1514 pCxt->Ebp = pIn->ar_ebp;
1515
1516 /* FIXME: pIn->ar_proid ignored */
1517 /* FIXME: pIn->ar_error ignored */
1518 /* FIXME: pIn->ar_pad ignored */
1519 }
1520
1521 static void CONTEXT_2_win32apieq(CONTEXT86 *pCxt,struct win32apireq *pOut)
1522 {
1523 memset(pOut,0,sizeof(struct win32apireq));
1524
1525 pOut->ar_eax = pCxt->Eax;
1526 pOut->ar_ebx = pCxt->Ebx;
1527 pOut->ar_ecx = pCxt->Ecx;
1528 pOut->ar_edx = pCxt->Edx;
1529 pOut->ar_esi = pCxt->Esi;
1530 pOut->ar_edi = pCxt->Edi;
1531
1532 /* FIXME: Only partial CONTEXT86_CONTROL */
1533 pOut->ar_ebp = pCxt->Ebp;
1534
1535 /* FIXME: pOut->ar_proid ignored */
1536 /* FIXME: pOut->ar_error ignored */
1537 /* FIXME: pOut->ar_pad ignored */
1538 }
1539
1540 static BOOL DeviceIo_IFSMgr(DWORD dwIoControlCode, LPVOID lpvInBuffer, DWORD cbInBuffer,
1541 LPVOID lpvOutBuffer, DWORD cbOutBuffer,
1542 LPDWORD lpcbBytesReturned,
1543 LPOVERLAPPED lpOverlapped)
1544 {
1545 BOOL retv = TRUE;
1546 TRACE("(%ld,%p,%ld,%p,%ld,%p,%p): stub\n",
1547 dwIoControlCode,
1548 lpvInBuffer,cbInBuffer,
1549 lpvOutBuffer,cbOutBuffer,
1550 lpcbBytesReturned,
1551 lpOverlapped);
1552
1553 switch (dwIoControlCode)
1554 {
1555 case IFS_IOCTL_21:
1556 case IFS_IOCTL_2F:{
1557 CONTEXT86 cxt;
1558 struct win32apireq *pIn=(struct win32apireq *) lpvInBuffer;
1559 struct win32apireq *pOut=(struct win32apireq *) lpvOutBuffer;
1560
1561 TRACE(
1562 "Control '%s': "
1563 "proid=0x%08lx, eax=0x%08lx, ebx=0x%08lx, ecx=0x%08lx, "
1564 "edx=0x%08lx, esi=0x%08lx, edi=0x%08lx, ebp=0x%08lx, "
1565 "error=0x%04x, pad=0x%04x\n",
1566 (dwIoControlCode==IFS_IOCTL_21)?"IFS_IOCTL_21":"IFS_IOCTL_2F",
1567 pIn->ar_proid, pIn->ar_eax, pIn->ar_ebx, pIn->ar_ecx,
1568 pIn->ar_edx, pIn->ar_esi, pIn->ar_edi, pIn->ar_ebp,
1569 pIn->ar_error, pIn->ar_pad
1570 );
1571
1572 win32apieq_2_CONTEXT(pIn,&cxt);
1573
1574 if(dwIoControlCode==IFS_IOCTL_21)
1575 {
1576 DOS3Call(&cxt); /* Call int 21h */
1577 } else {
1578 INT_Int2fHandler(&cxt); /* Call int 2Fh */
1579 }
1580
1581 CONTEXT_2_win32apieq(&cxt,pOut);
1582
1583 retv = TRUE;
1584 } break;
1585 case IFS_IOCTL_GET_RES:{
1586 FIXME( "Control 'IFS_IOCTL_GET_RES' not implemented\n");
1587 retv = FALSE;
1588 } break;
1589 case IFS_IOCTL_GET_NETPRO_NAME_A:{
1590 FIXME( "Control 'IFS_IOCTL_GET_NETPRO_NAME_A' not implemented\n");
1591 retv = FALSE;
1592 } break;
1593 default:
1594 FIXME( "Control %ld not implemented\n", dwIoControlCode);
1595 retv = FALSE;
1596 }
1597
1598 return retv;
1599 }
1600
1601 /********************************************************************************
1602 * VxDCall_VWin32
1603 *
1604 * Service numbers taken from page 448 of Pietrek's "Windows 95 System
1605 * Programming Secrets". Parameters from experimentation on real Win98.
1606 *
1607 */
1608
1609 static DWORD VxDCall_VWin32( DWORD service, CONTEXT86 *context )
1610 {
1611 switch ( LOWORD(service) )
1612 {
1613 case 0x0000: /* GetVersion */
1614 {
1615 DWORD vers = GetVersion();
1616 return (LOBYTE(vers) << 8) | HIBYTE(vers);
1617 }
1618 break;
1619
1620 case 0x0020: /* Get VMCPD Version */
1621 {
1622 DWORD parm = (DWORD) stack32_pop(context);
1623
1624 FIXME("Get VMCPD Version(%08lx): partial stub!\n", parm);
1625
1626 /* FIXME: This is what Win98 returns, it may
1627 * not be correct in all situations.
1628 * It makes Bleem! happy though.
1629 */
1630
1631 return 0x0405;
1632 }
1633
1634 case 0x0029: /* Int31/DPMI dispatch */
1635 {
1636 DWORD callnum = (DWORD) stack32_pop(context);
1637 DWORD parm = (DWORD) stack32_pop(context);
1638
1639 TRACE("Int31/DPMI dispatch(%08lx)\n", callnum);
1640
1641 SET_AX( context, callnum );
1642 SET_CX( context, parm );
1643 INT_Int31Handler(context);
1644
1645 return LOWORD(context->Eax);
1646 }
1647 break;
1648
1649 case 0x002a: /* Int41 dispatch - parm = int41 service number */
1650 {
1651 DWORD callnum = (DWORD) stack32_pop(context);
1652
1653 return callnum; /* FIXME: should really call INT_Int41Handler() */
1654 }
1655 break;
1656
1657 default:
1658 FIXME("Unknown VWin32 service %08lx\n", service);
1659 break;
1660 }
1661
1662 return 0xffffffff;
1663 }
1664
1665
1666 /***********************************************************************
1667 * DeviceIo_VCD
1668 */
1669 static BOOL DeviceIo_VCD(DWORD dwIoControlCode,
1670 LPVOID lpvInBuffer, DWORD cbInBuffer,
1671 LPVOID lpvOutBuffer, DWORD cbOutBuffer,
1672 LPDWORD lpcbBytesReturned,
1673 LPOVERLAPPED lpOverlapped)
1674 {
1675 BOOL retv = TRUE;
1676
1677 switch (dwIoControlCode)
1678 {
1679 case IOCTL_SERIAL_LSRMST_INSERT:
1680 {
1681 FIXME( "IOCTL_SERIAL_LSRMST_INSERT NIY !\n");
1682 retv = FALSE;
1683 }
1684 break;
1685
1686 default:
1687 FIXME( "Unknown Control %ld\n", dwIoControlCode);
1688 retv = FALSE;
1689 break;
1690 }
1691
1692 return retv;
1693 }
1694
1695
1696 /***********************************************************************
1697 * DeviceIo_VWin32
1698 */
1699
1700 static void DIOCRegs_2_CONTEXT( DIOC_REGISTERS *pIn, CONTEXT86 *pCxt )
1701 {
1702 memset( pCxt, 0, sizeof(*pCxt) );
1703 /* Note: segment registers == 0 means that CTX_SEG_OFF_TO_LIN
1704 will interpret 32-bit register contents as linear pointers */
1705
1706 pCxt->ContextFlags=CONTEXT86_INTEGER|CONTEXT86_CONTROL;
1707 pCxt->Eax = pIn->reg_EAX;
1708 pCxt->Ebx = pIn->reg_EBX;
1709 pCxt->Ecx = pIn->reg_ECX;
1710 pCxt->Edx = pIn->reg_EDX;
1711 pCxt->Esi = pIn->reg_ESI;
1712 pCxt->Edi = pIn->reg_EDI;
1713
1714 /* FIXME: Only partial CONTEXT86_CONTROL */
1715 pCxt->EFlags = pIn->reg_Flags;
1716 }
1717
1718 static void CONTEXT_2_DIOCRegs( CONTEXT86 *pCxt, DIOC_REGISTERS *pOut )
1719 {
1720 memset( pOut, 0, sizeof(DIOC_REGISTERS) );
1721
1722 pOut->reg_EAX = pCxt->Eax;
1723 pOut->reg_EBX = pCxt->Ebx;
1724 pOut->reg_ECX = pCxt->Ecx;
1725 pOut->reg_EDX = pCxt->Edx;
1726 pOut->reg_ESI = pCxt->Esi;
1727 pOut->reg_EDI = pCxt->Edi;
1728
1729 /* FIXME: Only partial CONTEXT86_CONTROL */
1730 pOut->reg_Flags = pCxt->EFlags;
1731 }
1732
1733 #define DIOC_AH(regs) (((unsigned char*)&((regs)->reg_EAX))[1])
1734 #define DIOC_AL(regs) (((unsigned char*)&((regs)->reg_EAX))[0])
1735 #define DIOC_BH(regs) (((unsigned char*)&((regs)->reg_EBX))[1])
1736 #define DIOC_BL(regs) (((unsigned char*)&((regs)->reg_EBX))[0])
1737 #define DIOC_DH(regs) (((unsigned char*)&((regs)->reg_EDX))[1])
1738 #define DIOC_DL(regs) (((unsigned char*)&((regs)->reg_EDX))[0])
1739
1740 #define DIOC_AX(regs) (((unsigned short*)&((regs)->reg_EAX))[0])
1741 #define DIOC_BX(regs) (((unsigned short*)&((regs)->reg_EBX))[0])
1742 #define DIOC_CX(regs) (((unsigned short*)&((regs)->reg_ECX))[0])
1743 #define DIOC_DX(regs) (((unsigned short*)&((regs)->reg_EDX))[0])
1744
1745 #define DIOC_SET_CARRY(regs) (((regs)->reg_Flags)|=0x00000001)
1746
1747 static const DWORD VWIN32_DriveTypeInfo[7]={
1748 0x0000, /* none */
1749 0x2709, /* 360 K */
1750 0x4f0f, /* 1.2 M */
1751 0x4f09, /* 720 K */
1752 0x4f12, /* 1.44 M */
1753 0x4f24, /* 2.88 M */
1754 0x4f24 /* 2.88 M */
1755 };
1756
1757 /**********************************************************************
1758 * VWIN32_ReadFloppyParams
1759 *
1760 * Handler for int 13h (disk I/O).
1761 */
1762 static VOID VWIN32_ReadFloppyParams(DIOC_REGISTERS *regs)
1763 {
1764 #ifdef linux
1765 static BYTE floppy_params[2][13] =
1766 {
1767 { 0xaf, 0x02, 0x25, 0x02, 0x12, 0x1b, 0xff, 0x6c, 0xf6, 0x0f, 0x08 },
1768 { 0xaf, 0x02, 0x25, 0x02, 0x12, 0x1b, 0xff, 0x6c, 0xf6, 0x0f, 0x08 }
1769 };
1770
1771 unsigned int i, nr_of_drives = 0;
1772 BYTE drive_nr = DIOC_DL(regs);
1773 int floppy_fd,r;
1774 struct floppy_drive_params floppy_parm;
1775 char root[] = "A:\\";
1776
1777 TRACE("in [ EDX=%08lx ]\n", regs->reg_EDX );
1778
1779 DIOC_AH(regs) = 0x00; /* success */
1780
1781 for (i = 0; i < MAX_DOS_DRIVES; i++, root[0]++)
1782 if (GetDriveTypeA(root) == DRIVE_REMOVABLE) nr_of_drives++;
1783 DIOC_DL(regs) = nr_of_drives;
1784
1785 if (drive_nr > 1) { /* invalid drive ? */
1786 DIOC_BX(regs) = 0;
1787 DIOC_CX(regs) = 0;
1788 DIOC_DH(regs) = 0;
1789 DIOC_SET_CARRY(regs);
1790 return;
1791 }
1792
1793 if ( (floppy_fd = DRIVE_OpenDevice( drive_nr, O_NONBLOCK)) == -1)
1794 {
1795 WARN("Can't determine floppy geometry !\n");
1796 DIOC_BX(regs) = 0;
1797 DIOC_CX(regs) = 0;
1798 DIOC_DH(regs) = 0;
1799 DIOC_SET_CARRY(regs);
1800 return;
1801 }
1802 r = ioctl(floppy_fd, FDGETDRVPRM, &floppy_parm);
1803
1804 close(floppy_fd);
1805
1806 if(r<0)
1807 {
1808 DIOC_SET_CARRY(regs);
1809 return;
1810 }
1811
1812 regs->reg_ECX = 0;
1813 DIOC_AL(regs) = 0;
1814 DIOC_BL(regs) = floppy_parm.cmos;
1815
1816 /* CH = low eight bits of max cyl
1817 CL = max sec nr (bits 5-0),
1818 hi two bits of max cyl (bits 7-6)
1819 DH = max head nr */
1820 if(DIOC_BL(regs) && (DIOC_BL(regs)<7))
1821 {
1822 DIOC_DH(regs) = 0x01;
1823 DIOC_CX(regs) = VWIN32_DriveTypeInfo[DIOC_BL(regs)];
1824 }
1825 else
1826 {
1827 DIOC_CX(regs) = 0x0;
1828 DIOC_DX(regs) = 0x0;
1829 }
1830
1831 regs->reg_EDI = (DWORD)floppy_params[drive_nr];
1832
1833 if(!regs->reg_EDI)
1834 {
1835 ERR("Get floppy params failed for drive %d\n",drive_nr);
1836 DIOC_SET_CARRY(regs);
1837 }
1838
1839 TRACE("out [ EAX=%08lx EBX=%08lx ECX=%08lx EDX=%08lx EDI=%08lx ]\n",
1840 regs->reg_EAX, regs->reg_EBX, regs->reg_ECX, regs->reg_EDX, regs->reg_EDI);
1841
1842 /* FIXME: Word exits quietly if we return with no error. Why? */
1843 FIXME("Returned ERROR!\n");
1844 DIOC_SET_CARRY(regs);
1845
1846 #else
1847 DIOC_AH(regs) = 0x01;
1848 DIOC_SET_CARRY(regs);
1849 #endif
1850 }
1851
1852 /**********************************************************************
1853 * VWIN32_Int13Handler
1854 *
1855 * Handler for VWIN32_DIOC_DOS_INT13 (disk I/O).
1856 */
1857 static VOID VWIN32_Int13Handler( DIOC_REGISTERS *regs)
1858 {
1859 TRACE("AH=%02x\n",DIOC_AH(regs));
1860 switch(DIOC_AH(regs)) /* AH */
1861 {
1862 case 0x00: /* RESET DISK SYSTEM */
1863 break; /* no return ? */
1864
1865 case 0x01: /* STATUS OF DISK SYSTEM */
1866 DIOC_AL(regs) = 0; /* successful completion */
1867 break;
1868
1869 case 0x02: /* READ SECTORS INTO MEMORY */
1870 DIOC_AL(regs) = 0; /* number of sectors read */
1871 DIOC_AH(regs) = 0; /* status */
1872 break;
1873
1874 case 0x03: /* WRITE SECTORS FROM MEMORY */
1875 break; /* no return ? */
1876
1877 case 0x04: /* VERIFY DISK SECTOR(S) */
1878 DIOC_AL(regs) = 0; /* number of sectors verified */
1879 DIOC_AH(regs) = 0;
1880 break;
1881
1882 case 0x05: /* FORMAT TRACK */
1883 case 0x06: /* FORMAT TRACK AND SET BAD SECTOR FLAGS */
1884 case 0x07: /* FORMAT DRIVE STARTING AT GIVEN TRACK */
1885 /* despite what Ralf Brown says, 0x06 and 0x07 seem to
1886 * set CFLAG, too (at least my BIOS does that) */
1887 DIOC_AH(regs) = 0x0c;
1888 DIOC_SET_CARRY(regs);
1889 break;
1890
1891 case 0x08: /* GET DRIVE PARAMETERS */
1892 if (DIOC_DL(regs) & 0x80) { /* hard disk ? */
1893 DIOC_AH(regs) = 0x07;
1894 DIOC_SET_CARRY(regs);
1895 }
1896 else /* floppy disk */
1897 VWIN32_ReadFloppyParams(regs);
1898 break;
1899
1900 case 0x09: /* INITIALIZE CONTROLLER WITH DRIVE PARAMETERS */
1901 case 0x0a: /* FIXED DISK - READ LONG (XT,AT,XT286,PS) */
1902 case 0x0b: /* FIXED DISK - WRITE LONG (XT,AT,XT286,PS) */
1903 case 0x0c: /* SEEK TO CYLINDER */
1904 case 0x0d: /* ALTERNATE RESET HARD DISKS */
1905 case 0x10: /* CHECK IF DRIVE READY */
1906 case 0x11: /* RECALIBRATE DRIVE */
1907 case 0x14: /* CONTROLLER INTERNAL DIAGNOSTIC */
1908 DIOC_AH(regs) = 0;
1909 break;
1910
1911 case 0x15: /* GET DISK TYPE (AT,XT2,XT286,CONV,PS) */
1912 if (DIOC_DL(regs) & 0x80) { /* hard disk ? */
1913 DIOC_AH(regs) = 3; /* fixed disk */
1914 DIOC_SET_CARRY(regs);
1915 }
1916 else { /* floppy disk ? */
1917 DIOC_AH(regs) = 2; /* floppy with change detection */
1918 DIOC_SET_CARRY(regs);
1919 }
1920 break;
1921
1922 case 0x0e: /* READ SECTOR BUFFER (XT only) */
1923 case 0x0f: /* WRITE SECTOR BUFFER (XT only) */
1924 case 0x12: /* CONTROLLER RAM DIAGNOSTIC (XT,PS) */
1925 case 0x13: /* DRIVE DIAGNOSTIC (XT,PS) */
1926 DIOC_AH(regs) = 0x01;
1927 DIOC_SET_CARRY(regs);
1928 break;
1929
1930 case 0x16: /* FLOPPY - CHANGE OF DISK STATUS */
1931 DIOC_AH(regs) = 0; /* FIXME - no change */
1932 break;
1933
1934 case 0x17: /* SET DISK TYPE FOR FORMAT */
1935 if (DIOC_DL(regs) < 4)
1936 DIOC_AH(regs) = 0x00; /* successful completion */
1937 else
1938 DIOC_AH(regs) = 0x01; /* error */
1939 break;
1940
1941 case 0x18: /* SET MEDIA TYPE FOR FORMAT */
1942 if (DIOC_DL(regs) < 4)
1943 DIOC_AH(regs) = 0x00; /* successful completion */
1944 else
1945 DIOC_AH(regs) = 0x01; /* error */
1946 break;
1947
1948 case 0x19: /* FIXED DISK - PARK HEADS */
1949 break;
1950
1951 default:
1952 FIXME("Unknown VWIN32 INT13 call AX=%04X\n",DIOC_AX(regs));
1953 }
1954 }
1955
1956 static BOOL DeviceIo_VWin32(DWORD dwIoControlCode,
1957 LPVOID lpvInBuffer, DWORD cbInBuffer,
1958 LPVOID lpvOutBuffer, DWORD cbOutBuffer,
1959 LPDWORD lpcbBytesReturned,
1960 LPOVERLAPPED lpOverlapped)
1961 {
1962 BOOL retv = TRUE;
1963
1964 switch (dwIoControlCode)
1965 {
1966 case VWIN32_DIOC_DOS_INT13:
1967 {
1968 DIOC_REGISTERS *pIn = (DIOC_REGISTERS *)lpvInBuffer;
1969 DIOC_REGISTERS *pOut = (DIOC_REGISTERS *)lpvOutBuffer;
1970
1971 memcpy(pOut, pIn, sizeof (DIOC_REGISTERS));
1972 VWIN32_Int13Handler(pOut);
1973 break;
1974 }
1975
1976 case VWIN32_DIOC_DOS_IOCTL:
1977 case 0x10: /* Int 0x21 call, call it VWIN_DIOC_INT21 ? */
1978 case VWIN32_DIOC_DOS_INT25:
1979 case VWIN32_DIOC_DOS_INT26:
1980 case 0x29: /* Int 0x31 call, call it VWIN_DIOC_INT31 ? */
1981 case VWIN32_DIOC_DOS_DRIVEINFO:
1982 {
1983 CONTEXT86 cxt;
1984 DIOC_REGISTERS *pIn = (DIOC_REGISTERS *)lpvInBuffer;
1985 DIOC_REGISTERS *pOut = (DIOC_REGISTERS *)lpvOutBuffer;
1986
1987 TRACE( "Control '%s': "
1988 "eax=0x%08lx, ebx=0x%08lx, ecx=0x%08lx, "
1989 "edx=0x%08lx, esi=0x%08lx, edi=0x%08lx \n",
1990 (dwIoControlCode == VWIN32_DIOC_DOS_IOCTL)? "VWIN32_DIOC_DOS_IOCTL" :
1991 (dwIoControlCode == VWIN32_DIOC_DOS_INT25)? "VWIN32_DIOC_DOS_INT25" :
1992 (dwIoControlCode == VWIN32_DIOC_DOS_INT26)? "VWIN32_DIOC_DOS_INT26" :
1993 (dwIoControlCode == VWIN32_DIOC_DOS_DRIVEINFO)? "VWIN32_DIOC_DOS_DRIVEINFO" : "???",
1994 pIn->reg_EAX, pIn->reg_EBX, pIn->reg_ECX,
1995 pIn->reg_EDX, pIn->reg_ESI, pIn->reg_EDI );
1996
1997 DIOCRegs_2_CONTEXT( pIn, &cxt );
1998
1999 switch (dwIoControlCode)
2000 {
2001 case VWIN32_DIOC_DOS_IOCTL: DOS3Call( &cxt ); break; /* Call int 21h */
2002 case VWIN32_DIOC_DOS_INT13: INT_Int13Handler( &cxt ); break;
2003 case 0x10: /* Int 0x21 call, call it VWIN_DIOC_INT21 ? */
2004 DOS3Call( &cxt ); break;
2005 case VWIN32_DIOC_DOS_INT25: INT_Int25Handler( &cxt ); break;
2006 case VWIN32_DIOC_DOS_INT26: INT_Int26Handler( &cxt ); break;
2007 case 0x29: /* Int 0x31 call, call it VWIN_DIOC_INT31 ? */
2008 INT_Int31Handler( &cxt ); break;
2009 case VWIN32_DIOC_DOS_DRIVEINFO: DOS3Call( &cxt ); break; /* Call int 21h 730x */
2010 }
2011
2012 CONTEXT_2_DIOCRegs( &cxt, pOut );
2013 }
2014 break;
2015
2016 case VWIN32_DIOC_SIMCTRLC:
2017 FIXME( "Control VWIN32_DIOC_SIMCTRLC not implemented\n");
2018 retv = FALSE;
2019 break;
2020
2021 default:
2022 FIXME( "Unknown Control %ld\n", dwIoControlCode);
2023 retv = FALSE;
2024 break;
2025 }
2026
2027 return retv;
2028 }
2029
2030 /* this is the main multimedia device loader */
2031 static BOOL DeviceIo_MMDEVLDR(DWORD dwIoControlCode,
2032 LPVOID lpvInBuffer, DWORD cbInBuffer,
2033 LPVOID lpvOutBuffer, DWORD cbOutBuffer,
2034 LPDWORD lpcbBytesReturned,
2035 LPOVERLAPPED lpOverlapped)
2036 {
2037 FIXME("(%ld,%p,%ld,%p,%ld,%p,%p): stub\n",
2038 dwIoControlCode,
2039 lpvInBuffer,cbInBuffer,
2040 lpvOutBuffer,cbOutBuffer,
2041 lpcbBytesReturned,
2042 lpOverlapped
2043 );
2044 switch (dwIoControlCode) {
2045 case 5:
2046 /* Hmm. */
2047 *(DWORD*)lpvOutBuffer=0;
2048 *lpcbBytesReturned=4;
2049 return TRUE;
2050 }
2051 return FALSE;
2052 }
2053 /* this is used by some Origin games */
2054 static BOOL DeviceIo_MONODEBG(DWORD dwIoControlCode,
2055 LPVOID lpvInBuffer, DWORD cbInBuffer,
2056 LPVOID lpvOutBuffer, DWORD cbOutBuffer,
2057 LPDWORD lpcbBytesReturned,
2058 LPOVERLAPPED lpOverlapped)
2059 {
2060 switch (dwIoControlCode) {
2061 case 1: /* version */
2062 *(LPDWORD)lpvOutBuffer = 0x20004; /* WC SecretOps */
2063 break;
2064 case 9: /* debug output */
2065 ERR("MONODEBG: %s\n",debugstr_a(lpvInBuffer));
2066 break;
2067 default:
2068 FIXME("(%ld,%p,%ld,%p,%ld,%p,%p): stub\n",
2069 dwIoControlCode,
2070 lpvInBuffer,cbInBuffer,
2071 lpvOutBuffer,cbOutBuffer,
2072 lpcbBytesReturned,
2073 lpOverlapped
2074 );
2075 break;
2076 }
2077 return TRUE;
2078 }
2079 /* pccard */
2080 static BOOL DeviceIo_PCCARD (DWORD dwIoControlCode,
2081 LPVOID lpvInBuffer, DWORD cbInBuffer,
2082 LPVOID lpvOutBuffer, DWORD cbOutBuffer,
2083 LPDWORD lpcbBytesReturned,
2084 LPOVERLAPPED lpOverlapped)
2085 {
2086 switch (dwIoControlCode) {
2087 case 0x0000: /* PCCARD_Get_Version */
2088 case 0x0001: /* PCCARD_Card_Services */
2089 default:
2090 FIXME( "(%ld,%p,%ld,%p,%ld,%p,%p): stub\n",
2091 dwIoControlCode,
2092 lpvInBuffer,cbInBuffer,
2093 lpvOutBuffer,cbOutBuffer,
2094 lpcbBytesReturned,
2095 lpOverlapped
2096 );
2097 break;
2098 }
2099 return FALSE;
2100 }
2101
2102 /***********************************************************************
2103 * OpenVxDHandle (KERNEL32.@)
2104 *
2105 * This function is supposed to return the corresponding Ring 0
2106 * ("kernel") handle for a Ring 3 handle in Win9x.
2107 * Evidently, Wine will have problems with this. But we try anyway,
2108 * maybe it helps...
2109 */
2110 HANDLE WINAPI OpenVxDHandle(HANDLE hHandleRing3)
2111 {
2112 FIXME( "(0x%08x), stub! (returning Ring 3 handle instead of Ring 0)\n", hHandleRing3);
2113 return hHandleRing3;
2114 }
2115
2116 static BOOL DeviceIo_HASP(DWORD dwIoControlCode, LPVOID lpvInBuffer, DWORD cbInBuffer,
2117 LPVOID lpvOutBuffer, DWORD cbOutBuffer,
2118 LPDWORD lpcbBytesReturned,
2119 LPOVERLAPPED lpOverlapped)
2120 {
2121 BOOL retv = TRUE;
2122 FIXME("(%ld,%p,%ld,%p,%ld,%p,%p): stub\n",
2123 dwIoControlCode,
2124 lpvInBuffer,cbInBuffer,
2125 lpvOutBuffer,cbOutBuffer,
2126 lpcbBytesReturned,
2127 lpOverlapped);
2128
2129 return retv;
2130 }
Maarten's multimedia branch