?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
- misc. tracing fixes
[wine/multimedia.git] / win32 / device.c
blob860a87fd2387d9b69af210cb68b24b3a576a1ab4
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 #include "callback.h"
48
49 WINE_DEFAULT_DEBUG_CHANNEL(file);
50
51
52 static BOOL DeviceIo_VTDAPI(DWORD dwIoControlCode,
53 LPVOID lpvInBuffer, DWORD cbInBuffer,
54 LPVOID lpvOutBuffer, DWORD cbOutBuffer,
55 LPDWORD lpcbBytesReturned,
56 LPOVERLAPPED lpOverlapped);
57 static BOOL DeviceIo_MONODEBG(DWORD dwIoControlCode,
58 LPVOID lpvInBuffer, DWORD cbInBuffer,
59 LPVOID lpvOutBuffer, DWORD cbOutBuffer,
60 LPDWORD lpcbBytesReturned,
61 LPOVERLAPPED lpOverlapped);
62 static BOOL DeviceIo_MMDEVLDR(DWORD dwIoControlCode,
63 LPVOID lpvInBuffer, DWORD cbInBuffer,
64 LPVOID lpvOutBuffer, DWORD cbOutBuffer,
65 LPDWORD lpcbBytesReturned,
66 LPOVERLAPPED lpOverlapped);
67
68 static DWORD VxDCall_VMM( DWORD service, CONTEXT86 *context );
69
70 static BOOL DeviceIo_IFSMgr(DWORD dwIoControlCode,
71 LPVOID lpvInBuffer, DWORD cbInBuffer,
72 LPVOID lpvOutBuffer, DWORD cbOutBuffer,
73 LPDWORD lpcbBytesReturned,
74 LPOVERLAPPED lpOverlapped);
75
76 static BOOL DeviceIo_VCD(DWORD dwIoControlCode,
77 LPVOID lpvInBuffer, DWORD cbInBuffer,
78 LPVOID lpvOutBuffer, DWORD cbOutBuffer,
79 LPDWORD lpcbBytesReturned,
80 LPOVERLAPPED lpOverlapped);
81
82 static DWORD VxDCall_VWin32( DWORD service, CONTEXT86 *context );
83
84 static BOOL DeviceIo_VWin32(DWORD dwIoControlCode,
85 LPVOID lpvInBuffer, DWORD cbInBuffer,
86 LPVOID lpvOutBuffer, DWORD cbOutBuffer,
87 LPDWORD lpcbBytesReturned,
88 LPOVERLAPPED lpOverlapped);
89
90 static BOOL DeviceIo_PCCARD (DWORD dwIoControlCode,
91 LPVOID lpvInBuffer, DWORD cbInBuffer,
92 LPVOID lpvOutBuffer, DWORD cbOutBuffer,
93 LPDWORD lpcbBytesReturned,
94 LPOVERLAPPED lpOverlapped);
95
96 static BOOL DeviceIo_HASP (DWORD dwIoControlCode,
97 LPVOID lpvInBuffer, DWORD cbInBuffer,
98 LPVOID lpvOutBuffer, DWORD cbOutBuffer,
99 LPDWORD lpcbBytesReturned,
100 LPOVERLAPPED lpOverlapped);
101 /*
102 * VxD names are taken from the Win95 DDK
103 */
104
105 struct VxDInfo
106 {
107 LPCSTR name;
108 WORD id;
109 DWORD (*vxdcall)(DWORD, CONTEXT86 *);
110 BOOL (*deviceio)(DWORD, LPVOID, DWORD,
111 LPVOID, DWORD, LPDWORD, LPOVERLAPPED);
112 };
113
114 static const struct VxDInfo VxDList[] =
115 {
116 /* Standard VxD IDs */
117 { "VMM", 0x0001, VxDCall_VMM, NULL },
118 { "DEBUG", 0x0002, NULL, NULL },
119 { "VPICD", 0x0003, NULL, NULL },
120 { "VDMAD", 0x0004, NULL, NULL },
121 { "VTD", 0x0005, NULL, NULL },
122 { "V86MMGR", 0x0006, NULL, NULL },
123 { "PAGESWAP", 0x0007, NULL, NULL },
124 { "PARITY", 0x0008, NULL, NULL },
125 { "REBOOT", 0x0009, NULL, NULL },
126 { "VDD", 0x000A, NULL, NULL },
127 { "VSD", 0x000B, NULL, NULL },
128 { "VMD", 0x000C, NULL, NULL },
129 { "VKD", 0x000D, NULL, NULL },
130 { "VCD", 0x000E, NULL, DeviceIo_VCD },
131 { "VPD", 0x000F, NULL, NULL },
132 { "BLOCKDEV", 0x0010, NULL, NULL },
133 { "VMCPD", 0x0011, NULL, NULL },
134 { "EBIOS", 0x0012, NULL, NULL },
135 { "BIOSXLAT", 0x0013, NULL, NULL },
136 { "VNETBIOS", 0x0014, NULL, NULL },
137 { "DOSMGR", 0x0015, NULL, NULL },
138 { "WINLOAD", 0x0016, NULL, NULL },
139 { "SHELL", 0x0017, NULL, NULL },
140 { "VMPOLL", 0x0018, NULL, NULL },
141 { "VPROD", 0x0019, NULL, NULL },
142 { "DOSNET", 0x001A, NULL, NULL },
143 { "VFD", 0x001B, NULL, NULL },
144 { "VDD2", 0x001C, NULL, NULL },
145 { "WINDEBUG", 0x001D, NULL, NULL },
146 { "TSRLOAD", 0x001E, NULL, NULL },
147 { "BIOSHOOK", 0x001F, NULL, NULL },
148 { "INT13", 0x0020, NULL, NULL },
149 { "PAGEFILE", 0x0021, NULL, NULL },
150 { "SCSI", 0x0022, NULL, NULL },
151 { "MCA_POS", 0x0023, NULL, NULL },
152 { "SCSIFD", 0x0024, NULL, NULL },
153 { "VPEND", 0x0025, NULL, NULL },
154 { "VPOWERD", 0x0026, NULL, NULL },
155 { "VXDLDR", 0x0027, NULL, NULL },
156 { "NDIS", 0x0028, NULL, NULL },
157 { "BIOS_EXT", 0x0029, NULL, NULL },
158 { "VWIN32", 0x002A, VxDCall_VWin32, DeviceIo_VWin32 },
159 { "VCOMM", 0x002B, NULL, NULL },
160 { "SPOOLER", 0x002C, NULL, NULL },
161 { "WIN32S", 0x002D, NULL, NULL },
162 { "DEBUGCMD", 0x002E, NULL, NULL },
163
164 { "VNB", 0x0031, NULL, NULL },
165 { "SERVER", 0x0032, NULL, NULL },
166 { "CONFIGMG", 0x0033, NULL, NULL },
167 { "DWCFGMG", 0x0034, NULL, NULL },
168 { "SCSIPORT", 0x0035, NULL, NULL },
169 { "VFBACKUP", 0x0036, NULL, NULL },
170 { "ENABLE", 0x0037, NULL, NULL },
171 { "VCOND", 0x0038, NULL, NULL },
172
173 { "EFAX", 0x003A, NULL, NULL },
174 { "DSVXD", 0x003B, NULL, NULL },
175 { "ISAPNP", 0x003C, NULL, NULL },
176 { "BIOS", 0x003D, NULL, NULL },
177 { "WINSOCK", 0x003E, NULL, NULL },
178 { "WSOCK", 0x003E, NULL, NULL },
179 { "WSIPX", 0x003F, NULL, NULL },
180 { "IFSMgr", 0x0040, NULL, DeviceIo_IFSMgr },
181 { "VCDFSD", 0x0041, NULL, NULL },
182 { "MRCI2", 0x0042, NULL, NULL },
183 { "PCI", 0x0043, NULL, NULL },
184 { "PELOADER", 0x0044, NULL, NULL },
185 { "EISA", 0x0045, NULL, NULL },
186 { "DRAGCLI", 0x0046, NULL, NULL },
187 { "DRAGSRV", 0x0047, NULL, NULL },
188 { "PERF", 0x0048, NULL, NULL },
189 { "AWREDIR", 0x0049, NULL, NULL },
190
191 /* Far East support */
192 { "ETEN", 0x0060, NULL, NULL },
193 { "CHBIOS", 0x0061, NULL, NULL },
194 { "VMSGD", 0x0062, NULL, NULL },
195 { "VPPID", 0x0063, NULL, NULL },
196 { "VIME", 0x0064, NULL, NULL },
197 { "VHBIOSD", 0x0065, NULL, NULL },
198
199 /* Multimedia OEM IDs */
200 { "VTDAPI", 0x0442, NULL, DeviceIo_VTDAPI },
201 { "MMDEVLDR", 0x044A, NULL, DeviceIo_MMDEVLDR },
202
203 /* Network Device IDs */
204 { "VNetSup", 0x0480, NULL, NULL },
205 { "VRedir", 0x0481, NULL, NULL },
206 { "VBrowse", 0x0482, NULL, NULL },
207 { "VSHARE", 0x0483, NULL, NULL },
208 { "IFSMgr", 0x0484, NULL, NULL },
209 { "MEMPROBE", 0x0485, NULL, NULL },
210 { "VFAT", 0x0486, NULL, NULL },
211 { "NWLINK", 0x0487, NULL, NULL },
212 { "VNWLINK", 0x0487, NULL, NULL },
213 { "NWSUP", 0x0487, NULL, NULL },
214 { "VTDI", 0x0488, NULL, NULL },
215 { "VIP", 0x0489, NULL, NULL },
216 { "VTCP", 0x048A, NULL, NULL },
217 { "VCache", 0x048B, NULL, NULL },
218 { "VUDP", 0x048C, NULL, NULL },
219 { "VAsync", 0x048D, NULL, NULL },
220 { "NWREDIR", 0x048E, NULL, NULL },
221 { "STAT80", 0x048F, NULL, NULL },
222 { "SCSIPORT", 0x0490, NULL, NULL },
223 { "FILESEC", 0x0491, NULL, NULL },
224 { "NWSERVER", 0x0492, NULL, NULL },
225 { "SECPROV", 0x0493, NULL, NULL },
226 { "NSCL", 0x0494, NULL, NULL },
227 { "WSTCP", 0x0495, NULL, NULL },
228 { "NDIS2SUP", 0x0496, NULL, NULL },
229 { "MSODISUP", 0x0497, NULL, NULL },
230 { "Splitter", 0x0498, NULL, NULL },
231 { "PPP", 0x0499, NULL, NULL },
232 { "VDHCP", 0x049A, NULL, NULL },
233 { "VNBT", 0x049B, NULL, NULL },
234 { "LOGGER", 0x049D, NULL, NULL },
235 { "EFILTER", 0x049E, NULL, NULL },
236 { "FFILTER", 0x049F, NULL, NULL },
237 { "TFILTER", 0x04A0, NULL, NULL },
238 { "AFILTER", 0x04A1, NULL, NULL },
239 { "IRLAMP", 0x04A2, NULL, NULL },
240
241 { "PCCARD", 0x097C, NULL, DeviceIo_PCCARD },
242 { "HASP95", 0x3721, NULL, DeviceIo_HASP },
243
244 /* WINE additions, ids unknown */
245 { "MONODEBG.VXD", 0x4242, NULL, DeviceIo_MONODEBG },
246
247 { NULL, 0, NULL, NULL }
248 };
249
250 /*
251 * VMM VxDCall service names are (mostly) taken from Stan Mitchell's
252 * "Inside the Windows 95 File System"
253 */
254
255 #define N_VMM_SERVICE 41
256
257 LPCSTR VMM_Service_Name[N_VMM_SERVICE] =
258 {
259 "PageReserve", /* 0x0000 */
260 "PageCommit", /* 0x0001 */
261 "PageDecommit", /* 0x0002 */
262 "PagerRegister", /* 0x0003 */
263 "PagerQuery", /* 0x0004 */
264 "HeapAllocate", /* 0x0005 */
265 "ContextCreate", /* 0x0006 */
266 "ContextDestroy", /* 0x0007 */
267 "PageAttach", /* 0x0008 */
268 "PageFlush", /* 0x0009 */
269 "PageFree", /* 0x000A */
270 "ContextSwitch", /* 0x000B */
271 "HeapReAllocate", /* 0x000C */
272 "PageModifyPermissions", /* 0x000D */
273 "PageQuery", /* 0x000E */
274 "GetCurrentContext", /* 0x000F */
275 "HeapFree", /* 0x0010 */
276 "RegOpenKey", /* 0x0011 */
277 "RegCreateKey", /* 0x0012 */
278 "RegCloseKey", /* 0x0013 */
279 "RegDeleteKey", /* 0x0014 */
280 "RegSetValue", /* 0x0015 */
281 "RegDeleteValue", /* 0x0016 */
282 "RegQueryValue", /* 0x0017 */
283 "RegEnumKey", /* 0x0018 */
284 "RegEnumValue", /* 0x0019 */
285 "RegQueryValueEx", /* 0x001A */
286 "RegSetValueEx", /* 0x001B */
287 "RegFlushKey", /* 0x001C */
288 "RegQueryInfoKey", /* 0x001D */
289 "GetDemandPageInfo", /* 0x001E */
290 "BlockOnID", /* 0x001F */
291 "SignalID", /* 0x0020 */
292 "RegLoadKey", /* 0x0021 */
293 "RegUnLoadKey", /* 0x0022 */
294 "RegSaveKey", /* 0x0023 */
295 "RegRemapPreDefKey", /* 0x0024 */
296 "PageChangePager", /* 0x0025 */
297 "RegQueryMultipleValues", /* 0x0026 */
298 "RegReplaceKey", /* 0x0027 */
299 "<KERNEL32.101>" /* 0x0028 -- What does this do??? */
300 };
301
302 /* PageReserve arena values */
303 #define PR_PRIVATE 0x80000400 /* anywhere in private arena */
304 #define PR_SHARED 0x80060000 /* anywhere in shared arena */
305 #define PR_SYSTEM 0x80080000 /* anywhere in system arena */
306
307 /* PageReserve flags */
308 #define PR_FIXED 0x00000008 /* don't move during PageReAllocate */
309 #define PR_4MEG 0x00000001 /* allocate on 4mb boundary */
310 #define PR_STATIC 0x00000010 /* see PageReserve documentation */
311
312 /* PageCommit default pager handle values */
313 #define PD_ZEROINIT 0x00000001 /* swappable zero-initialized pages */
314 #define PD_NOINIT 0x00000002 /* swappable uninitialized pages */
315 #define PD_FIXEDZERO 0x00000003 /* fixed zero-initialized pages */
316 #define PD_FIXED 0x00000004 /* fixed uninitialized pages */
317
318 /* PageCommit flags */
319 #define PC_FIXED 0x00000008 /* pages are permanently locked */
320 #define PC_LOCKED 0x00000080 /* pages are made present and locked */
321 #define PC_LOCKEDIFDP 0x00000100 /* pages are locked if swap via DOS */
322 #define PC_WRITEABLE 0x00020000 /* make the pages writeable */
323 #define PC_USER 0x00040000 /* make the pages ring 3 accessible */
324 #define PC_INCR 0x40000000 /* increment "pagerdata" each page */
325 #define PC_PRESENT 0x80000000 /* make pages initially present */
326 #define PC_STATIC 0x20000000 /* allow commit in PR_STATIC object */
327 #define PC_DIRTY 0x08000000 /* make pages initially dirty */
328 #define PC_CACHEDIS 0x00100000 /* Allocate uncached pages - new for WDM */
329 #define PC_CACHEWT 0x00080000 /* Allocate write through cache pages - new for WDM */
330 #define PC_PAGEFLUSH 0x00008000 /* Touch device mapped pages on alloc - new for WDM */
331
332 /* PageCommitContig additional flags */
333 #define PCC_ZEROINIT 0x00000001 /* zero-initialize new pages */
334 #define PCC_NOLIN 0x10000000 /* don't map to any linear address */
335
336
337
338 HANDLE DEVICE_Open( LPCWSTR filenameW, DWORD access, LPSECURITY_ATTRIBUTES sa )
339 {
340 const struct VxDInfo *info;
341 char filename[MAX_PATH];
342
343 if (!WideCharToMultiByte(CP_ACP, 0, filenameW, -1, filename, MAX_PATH, NULL, NULL))
344 {
345 SetLastError( ERROR_FILE_NOT_FOUND );
346 return 0;
347 }
348
349 for (info = VxDList; info->name; info++)
350 if (!strncasecmp( info->name, filename, strlen(info->name) ))
351 return FILE_CreateDevice( info->id | 0x10000, access, sa );
352
353 FIXME( "Unknown/unsupported VxD %s. Try setting Windows version to 'nt40' or 'win31'.\n",
354 filename);
355 SetLastError( ERROR_FILE_NOT_FOUND );
356 return 0;
357 }
358
359 static DWORD DEVICE_GetClientID( HANDLE handle )
360 {
361 DWORD ret = 0;
362 SERVER_START_REQ( get_device_id )
363 {
364 req->handle = handle;
365 if (!wine_server_call( req )) ret = reply->id;
366 }
367 SERVER_END_REQ;
368 return ret;
369 }
370
371 static const struct VxDInfo *DEVICE_GetInfo( DWORD clientID )
372 {
373 const struct VxDInfo *info = NULL;
374
375 if (clientID & 0x10000)
376 {
377 for (info = VxDList; info->name; info++)
378 if (info->id == LOWORD(clientID)) break;
379 }
380 return info;
381 }
382
383 /****************************************************************************
384 * DeviceIoControl (KERNEL32.@)
385 * This is one of those big ugly nasty procedure which can do
386 * a million and one things when it comes to devices. It can also be
387 * used for VxD communication.
388 *
389 * A return value of FALSE indicates that something has gone wrong which
390 * GetLastError can decipher.
391 */
392 BOOL WINAPI DeviceIoControl(HANDLE hDevice, DWORD dwIoControlCode,
393 LPVOID lpvInBuffer, DWORD cbInBuffer,
394 LPVOID lpvOutBuffer, DWORD cbOutBuffer,
395 LPDWORD lpcbBytesReturned,
396 LPOVERLAPPED lpOverlapped)
397 {
398 DWORD clientID;
399
400 TRACE( "(%p,%ld,%p,%ld,%p,%ld,%p,%p)\n",
401 hDevice,dwIoControlCode,lpvInBuffer,cbInBuffer,
402 lpvOutBuffer,cbOutBuffer,lpcbBytesReturned,lpOverlapped );
403
404 if (!(clientID = DEVICE_GetClientID( hDevice )))
405 {
406 SetLastError( ERROR_INVALID_PARAMETER );
407 return FALSE;
408 }
409
410 /* Check if this is a user defined control code for a VxD */
411 if( HIWORD( dwIoControlCode ) == 0 )
412 {
413 const struct VxDInfo *info;
414 if (!(info = DEVICE_GetInfo( clientID )))
415 {
416 FIXME( "No device found for id %lx\n", clientID);
417 }
418 else if ( info->deviceio )
419 {
420 return info->deviceio( dwIoControlCode,
421 lpvInBuffer, cbInBuffer,
422 lpvOutBuffer, cbOutBuffer,
423 lpcbBytesReturned, lpOverlapped );
424 }
425 else
426 {
427 FIXME( "Unimplemented control %ld for VxD device %s\n",
428 dwIoControlCode, info->name ? info->name : "???" );
429 /* FIXME: this is for invalid calls on W98SE,
430 * but maybe we should use ERROR_CALL_NOT_IMPLEMENTED
431 * instead ? */
432 SetLastError( ERROR_INVALID_FUNCTION );
433 }
434 }
435 else
436 {
437 char str[3];
438
439 strcpy(str, "A:");
440 str[0] += LOBYTE(clientID);
441 if (GetDriveTypeA(str) == DRIVE_CDROM)
442 return CDROM_DeviceIoControl(clientID, hDevice, dwIoControlCode, lpvInBuffer, cbInBuffer,
443 lpvOutBuffer, cbOutBuffer, lpcbBytesReturned,
444 lpOverlapped);
445 else switch( dwIoControlCode )
446 {
447 case FSCTL_DELETE_REPARSE_POINT:
448 case FSCTL_DISMOUNT_VOLUME:
449 case FSCTL_GET_COMPRESSION:
450 case FSCTL_GET_REPARSE_POINT:
451 case FSCTL_LOCK_VOLUME:
452 case FSCTL_QUERY_ALLOCATED_RANGES:
453 case FSCTL_SET_COMPRESSION:
454 case FSCTL_SET_REPARSE_POINT:
455 case FSCTL_SET_SPARSE:
456 case FSCTL_SET_ZERO_DATA:
457 case FSCTL_UNLOCK_VOLUME:
458 case IOCTL_DISK_CHECK_VERIFY:
459 case IOCTL_DISK_EJECT_MEDIA:
460 case IOCTL_DISK_FORMAT_TRACKS:
461 case IOCTL_DISK_GET_DRIVE_GEOMETRY:
462 case IOCTL_DISK_GET_DRIVE_LAYOUT:
463 case IOCTL_DISK_GET_MEDIA_TYPES:
464 case IOCTL_DISK_GET_PARTITION_INFO:
465 case IOCTL_DISK_LOAD_MEDIA:
466 case IOCTL_DISK_MEDIA_REMOVAL:
467 case IOCTL_DISK_PERFORMANCE:
468 case IOCTL_DISK_REASSIGN_BLOCKS:
469 case IOCTL_DISK_SET_DRIVE_LAYOUT:
470 case IOCTL_DISK_SET_PARTITION_INFO:
471 case IOCTL_DISK_VERIFY:
472 case IOCTL_SERIAL_LSRMST_INSERT:
473 case IOCTL_STORAGE_CHECK_VERIFY:
474 case IOCTL_STORAGE_EJECT_MEDIA:
475 case IOCTL_STORAGE_GET_MEDIA_TYPES:
476 case IOCTL_STORAGE_LOAD_MEDIA:
477 case IOCTL_STORAGE_MEDIA_REMOVAL:
478 FIXME( "unimplemented dwIoControlCode=%08lx\n", dwIoControlCode);
479 SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
480 return FALSE;
481 break;
482 default:
483 FIXME( "ignored dwIoControlCode=%08lx\n",dwIoControlCode);
484 SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
485 return FALSE;
486 break;
487 }
488 }
489 return FALSE;
490 }
491
492 /***********************************************************************
493 * DeviceIo_VTDAPI
494 */
495 static BOOL DeviceIo_VTDAPI(DWORD dwIoControlCode, LPVOID lpvInBuffer, DWORD cbInBuffer,
496 LPVOID lpvOutBuffer, DWORD cbOutBuffer,
497 LPDWORD lpcbBytesReturned,
498 LPOVERLAPPED lpOverlapped)
499 {
500 BOOL retv = TRUE;
501
502 switch (dwIoControlCode)
503 {
504 case 5:
505 if (lpvOutBuffer && (cbOutBuffer>=4))
506 *(DWORD*)lpvOutBuffer = GetTickCount();
507
508 if (lpcbBytesReturned)
509 *lpcbBytesReturned = 4;
510
511 break;
512
513 default:
514 FIXME( "Control %ld not implemented\n", dwIoControlCode);
515 retv = FALSE;
516 break;
517 }
518
519 return retv;
520 }
521
522 /***********************************************************************
523 * VxDCall0 (KERNEL32.1)
524 * VxDCall1 (KERNEL32.2)
525 * VxDCall2 (KERNEL32.3)
526 * VxDCall3 (KERNEL32.4)
527 * VxDCall4 (KERNEL32.5)
528 * VxDCall5 (KERNEL32.6)
529 * VxDCall6 (KERNEL32.7)
530 * VxDCall7 (KERNEL32.8)
531 * VxDCall8 (KERNEL32.9)
532 */
533 void VxDCall( DWORD service, CONTEXT86 *context )
534 {
535 DWORD ret = 0xffffffff; /* FIXME */
536 int i;
537
538 TRACE( "(%08lx, ...)\n", service);
539
540 for (i = 0; VxDList[i].name; i++)
541 if (VxDList[i].id == HIWORD(service))
542 break;
543
544 if (!VxDList[i].name)
545 FIXME( "Unknown VxD (%08lx)\n", service);
546 else if (!VxDList[i].vxdcall)
547 FIXME( "Unimplemented VxD (%08lx)\n", service);
548 else
549 ret = VxDList[i].vxdcall( service, context );
550
551 context->Eax = ret;
552 }
553
554
555 /******************************************************************************
556 * The following is a massive duplication of the advapi32 code.
557 * Unfortunately sharing the code is not possible since the native
558 * Win95 advapi32 depends on it. Someday we should probably stop
559 * supporting native Win95 advapi32 altogether...
560 */
561
562
563 #define HKEY_SPECIAL_ROOT_FIRST HKEY_CLASSES_ROOT
564 #define HKEY_SPECIAL_ROOT_LAST HKEY_DYN_DATA
565 #define NB_SPECIAL_ROOT_KEYS ((UINT)HKEY_SPECIAL_ROOT_LAST - (UINT)HKEY_SPECIAL_ROOT_FIRST + 1)
566
567 static HKEY special_root_keys[NB_SPECIAL_ROOT_KEYS];
568
569 static const WCHAR name_CLASSES_ROOT[] =
570 {'M','a','c','h','i','n','e','\\',
571 'S','o','f','t','w','a','r','e','\\',
572 'C','l','a','s','s','e','s',0};
573 static const WCHAR name_LOCAL_MACHINE[] =
574 {'M','a','c','h','i','n','e',0};
575 static const WCHAR name_USERS[] =
576 {'U','s','e','r',0};
577 static const WCHAR name_PERFORMANCE_DATA[] =
578 {'P','e','r','f','D','a','t','a',0};
579 static const WCHAR name_CURRENT_CONFIG[] =
580 {'M','a','c','h','i','n','e','\\',
581 'S','y','s','t','e','m','\\',
582 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
583 'H','a','r','d','w','a','r','e','P','r','o','f','i','l','e','s','\\',
584 'C','u','r','r','e','n','t',0};
585 static const WCHAR name_DYN_DATA[] =
586 {'D','y','n','D','a','t','a',0};
587
588 #define DECL_STR(key) { sizeof(name_##key)-sizeof(WCHAR), sizeof(name_##key), (LPWSTR)name_##key }
589 static UNICODE_STRING root_key_names[NB_SPECIAL_ROOT_KEYS] =
590 {
591 DECL_STR(CLASSES_ROOT),
592 { 0, 0, NULL }, /* HKEY_CURRENT_USER is determined dynamically */
593 DECL_STR(LOCAL_MACHINE),
594 DECL_STR(USERS),
595 DECL_STR(PERFORMANCE_DATA),
596 DECL_STR(CURRENT_CONFIG),
597 DECL_STR(DYN_DATA)
598 };
599 #undef DECL_STR
600
601
602 /* check if value type needs string conversion (Ansi<->Unicode) */
603 inline static int is_string( DWORD type )
604 {
605 return (type == REG_SZ) || (type == REG_EXPAND_SZ) || (type == REG_MULTI_SZ);
606 }
607
608 /* create one of the HKEY_* special root keys */
609 static HKEY create_special_root_hkey( HKEY hkey, DWORD access )
610 {
611 HKEY ret = 0;
612 int idx = (UINT)hkey - (UINT)HKEY_SPECIAL_ROOT_FIRST;
613
614 if (hkey == HKEY_CURRENT_USER)
615 {
616 if (RtlOpenCurrentUser( access, &hkey )) return 0;
617 }
618 else
619 {
620 OBJECT_ATTRIBUTES attr;
621
622 attr.Length = sizeof(attr);
623 attr.RootDirectory = 0;
624 attr.ObjectName = &root_key_names[idx];
625 attr.Attributes = 0;
626 attr.SecurityDescriptor = NULL;
627 attr.SecurityQualityOfService = NULL;
628 if (NtCreateKey( &hkey, access, &attr, 0, NULL, 0, NULL )) return 0;
629 }
630
631 if (!(ret = InterlockedCompareExchangePointer( (PVOID) &special_root_keys[idx], hkey, 0 )))
632 ret = hkey;
633 else
634 NtClose( hkey ); /* somebody beat us to it */
635 return ret;
636 }
637
638 /* map the hkey from special root to normal key if necessary */
639 inline static HKEY get_special_root_hkey( HKEY hkey )
640 {
641 HKEY ret = hkey;
642
643 if ((hkey >= HKEY_SPECIAL_ROOT_FIRST) && (hkey <= HKEY_SPECIAL_ROOT_LAST))
644 {
645 if (!(ret = special_root_keys[(UINT)hkey - (UINT)HKEY_SPECIAL_ROOT_FIRST]))
646 ret = create_special_root_hkey( hkey, KEY_ALL_ACCESS );
647 }
648 return ret;
649 }
650
651
652 /******************************************************************************
653 * VMM_RegCreateKeyA
654 */
655 static DWORD VMM_RegCreateKeyA( HKEY hkey, LPCSTR name, PHKEY retkey )
656 {
657 OBJECT_ATTRIBUTES attr;
658 UNICODE_STRING nameW;
659 ANSI_STRING nameA;
660 NTSTATUS status;
661
662 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
663
664 attr.Length = sizeof(attr);
665 attr.RootDirectory = hkey;
666 attr.ObjectName = &nameW;
667 attr.Attributes = 0;
668 attr.SecurityDescriptor = NULL;
669 attr.SecurityQualityOfService = NULL;
670 RtlInitAnsiString( &nameA, name );
671
672 if (!(status = RtlAnsiStringToUnicodeString( &nameW, &nameA, TRUE )))
673 {
674 status = NtCreateKey( retkey, KEY_ALL_ACCESS, &attr, 0, NULL,
675 REG_OPTION_NON_VOLATILE, NULL );
676 RtlFreeUnicodeString( &nameW );
677 }
678 return RtlNtStatusToDosError( status );
679 }
680
681
682 /******************************************************************************
683 * VMM_RegOpenKeyExA
684 */
685 DWORD WINAPI VMM_RegOpenKeyExA(HKEY hkey, LPCSTR name, DWORD reserved, REGSAM access, PHKEY retkey)
686 {
687 OBJECT_ATTRIBUTES attr;
688 UNICODE_STRING nameW;
689 STRING nameA;
690 NTSTATUS status;
691
692 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
693
694 attr.Length = sizeof(attr);
695 attr.RootDirectory = hkey;
696 attr.ObjectName = &nameW;
697 attr.Attributes = 0;
698 attr.SecurityDescriptor = NULL;
699 attr.SecurityQualityOfService = NULL;
700
701 RtlInitAnsiString( &nameA, name );
702 if (!(status = RtlAnsiStringToUnicodeString( &nameW, &nameA, TRUE )))
703 {
704 status = NtOpenKey( retkey, access, &attr );
705 RtlFreeUnicodeString( &nameW );
706 }
707 return RtlNtStatusToDosError( status );
708 }
709
710
711 /******************************************************************************
712 * VMM_RegCloseKey
713 */
714 static DWORD VMM_RegCloseKey( HKEY hkey )
715 {
716 if (!hkey || hkey >= (HKEY)0x80000000) return ERROR_SUCCESS;
717 return RtlNtStatusToDosError( NtClose( hkey ) );
718 }
719
720
721 /******************************************************************************
722 * VMM_RegDeleteKeyA
723 */
724 static DWORD VMM_RegDeleteKeyA( HKEY hkey, LPCSTR name )
725 {
726 DWORD ret;
727 HKEY tmp;
728
729 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
730
731 if (!name || !*name) return RtlNtStatusToDosError( NtDeleteKey( hkey ) );
732 if (!(ret = VMM_RegOpenKeyExA( hkey, name, 0, 0, &tmp )))
733 {
734 ret = RtlNtStatusToDosError( NtDeleteKey( tmp ) );
735 NtClose( tmp );
736 }
737 return ret;
738 }
739
740
741 /******************************************************************************
742 * VMM_RegSetValueExA
743 */
744 static DWORD VMM_RegSetValueExA( HKEY hkey, LPCSTR name, DWORD reserved, DWORD type,
745 CONST BYTE *data, DWORD count )
746 {
747 UNICODE_STRING nameW;
748 ANSI_STRING nameA;
749 WCHAR *dataW = NULL;
750 NTSTATUS status;
751
752 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
753
754 if (is_string(type))
755 {
756 DWORD lenW;
757
758 if (count)
759 {
760 /* if user forgot to count terminating null, add it (yes NT does this) */
761 if (data[count-1] && !data[count]) count++;
762 }
763 RtlMultiByteToUnicodeSize( &lenW, data, count );
764 if (!(dataW = HeapAlloc( GetProcessHeap(), 0, lenW ))) return ERROR_OUTOFMEMORY;
765 RtlMultiByteToUnicodeN( dataW, lenW, NULL, data, count );
766 count = lenW;
767 data = (BYTE *)dataW;
768 }
769
770 RtlInitAnsiString( &nameA, name );
771 if (!(status = RtlAnsiStringToUnicodeString( &nameW, &nameA, TRUE )))
772 {
773 status = NtSetValueKey( hkey, &nameW, 0, type, data, count );
774 RtlFreeUnicodeString( &nameW );
775 }
776 if (dataW) HeapFree( GetProcessHeap(), 0, dataW );
777 return RtlNtStatusToDosError( status );
778 }
779
780
781 /******************************************************************************
782 * VMM_RegSetValueA
783 */
784 static DWORD VMM_RegSetValueA( HKEY hkey, LPCSTR name, DWORD type, LPCSTR data, DWORD count )
785 {
786 HKEY subkey = hkey;
787 DWORD ret;
788
789 if (type != REG_SZ) return ERROR_INVALID_PARAMETER;
790
791 if (name && name[0]) /* need to create the subkey */
792 {
793 if ((ret = VMM_RegCreateKeyA( hkey, name, &subkey )) != ERROR_SUCCESS) return ret;
794 }
795 ret = VMM_RegSetValueExA( subkey, NULL, 0, REG_SZ, (LPBYTE)data, strlen(data)+1 );
796 if (subkey != hkey) NtClose( subkey );
797 return ret;
798 }
799
800
801 /******************************************************************************
802 * VMM_RegDeleteValueA
803 */
804 static DWORD VMM_RegDeleteValueA( HKEY hkey, LPCSTR name )
805 {
806 UNICODE_STRING nameW;
807 STRING nameA;
808 NTSTATUS status;
809
810 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
811
812 RtlInitAnsiString( &nameA, name );
813 if (!(status = RtlAnsiStringToUnicodeString( &nameW, &nameA, TRUE )))
814 {
815 status = NtDeleteValueKey( hkey, &nameW );
816 RtlFreeUnicodeString( &nameW );
817 }
818 return RtlNtStatusToDosError( status );
819 }
820
821
822 /******************************************************************************
823 * VMM_RegQueryValueExA
824 */
825 static DWORD VMM_RegQueryValueExA( HKEY hkey, LPCSTR name, LPDWORD reserved, LPDWORD type,
826 LPBYTE data, LPDWORD count )
827 {
828 NTSTATUS status;
829 ANSI_STRING nameA;
830 UNICODE_STRING nameW;
831 DWORD total_size;
832 char buffer[256], *buf_ptr = buffer;
833 KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)buffer;
834 static const int info_size = offsetof( KEY_VALUE_PARTIAL_INFORMATION, Data );
835
836 if ((data && !count) || reserved) return ERROR_INVALID_PARAMETER;
837 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
838
839 RtlInitAnsiString( &nameA, name );
840 if ((status = RtlAnsiStringToUnicodeString( &nameW, &nameA, TRUE )))
841 return RtlNtStatusToDosError(status);
842
843 status = NtQueryValueKey( hkey, &nameW, KeyValuePartialInformation,
844 buffer, sizeof(buffer), &total_size );
845 if (status && status != STATUS_BUFFER_OVERFLOW) goto done;
846
847 /* we need to fetch the contents for a string type even if not requested,
848 * because we need to compute the length of the ASCII string. */
849 if (data || is_string(info->Type))
850 {
851 /* retry with a dynamically allocated buffer */
852 while (status == STATUS_BUFFER_OVERFLOW)
853 {
854 if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
855 if (!(buf_ptr = HeapAlloc( GetProcessHeap(), 0, total_size )))
856 {
857 status = STATUS_NO_MEMORY;
858 goto done;
859 }
860 info = (KEY_VALUE_PARTIAL_INFORMATION *)buf_ptr;
861 status = NtQueryValueKey( hkey, &nameW, KeyValuePartialInformation,
862 buf_ptr, total_size, &total_size );
863 }
864
865 if (!status)
866 {
867 if (is_string(info->Type))
868 {
869 DWORD len = WideCharToMultiByte( CP_ACP, 0, (WCHAR *)(buf_ptr + info_size),
870 (total_size - info_size) /sizeof(WCHAR),
871 NULL, 0, NULL, NULL );
872 if (data && len)
873 {
874 if (len > *count) status = STATUS_BUFFER_OVERFLOW;
875 else
876 {
877 WideCharToMultiByte( CP_ACP, 0, (WCHAR *)(buf_ptr + info_size),
878 (total_size - info_size) /sizeof(WCHAR),
879 data, len, NULL, NULL );
880 /* if the type is REG_SZ and data is not 0-terminated
881 * and there is enough space in the buffer NT appends a \0 */
882 if (len < *count && data[len-1]) data[len] = 0;
883 }
884 }
885 total_size = len + info_size;
886 }
887 else if (data)
888 {
889 if (total_size - info_size > *count) status = STATUS_BUFFER_OVERFLOW;
890 else memcpy( data, buf_ptr + info_size, total_size - info_size );
891 }
892 }
893 else if (status != STATUS_BUFFER_OVERFLOW) goto done;
894 }
895
896 if (type) *type = info->Type;
897 if (count) *count = total_size - info_size;
898
899 done:
900 if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
901 RtlFreeUnicodeString( &nameW );
902 return RtlNtStatusToDosError(status);
903 }
904
905
906 /******************************************************************************
907 * VMM_RegQueryValueA
908 */
909 static DWORD VMM_RegQueryValueA( HKEY hkey, LPCSTR name, LPSTR data, LPLONG count )
910 {
911 DWORD ret;
912 HKEY subkey = hkey;
913
914 if (name && name[0])
915 {
916 if ((ret = VMM_RegOpenKeyExA( hkey, name, 0, KEY_ALL_ACCESS, &subkey )) != ERROR_SUCCESS)
917 return ret;
918 }
919 ret = VMM_RegQueryValueExA( subkey, NULL, NULL, NULL, (LPBYTE)data, count );
920 if (subkey != hkey) NtClose( subkey );
921 if (ret == ERROR_FILE_NOT_FOUND)
922 {
923 /* return empty string if default value not found */
924 if (data) *data = 0;
925 if (count) *count = 1;
926 ret = ERROR_SUCCESS;
927 }
928 return ret;
929 }
930
931
932 /******************************************************************************
933 * VMM_RegEnumValueA
934 */
935 static DWORD VMM_RegEnumValueA( HKEY hkey, DWORD index, LPSTR value, LPDWORD val_count,
936 LPDWORD reserved, LPDWORD type, LPBYTE data, LPDWORD count )
937 {
938 NTSTATUS status;
939 DWORD total_size;
940 char buffer[256], *buf_ptr = buffer;
941 KEY_VALUE_FULL_INFORMATION *info = (KEY_VALUE_FULL_INFORMATION *)buffer;
942 static const int info_size = offsetof( KEY_VALUE_FULL_INFORMATION, Name );
943
944 TRACE("(%p,%ld,%p,%p,%p,%p,%p,%p)\n",
945 hkey, index, value, val_count, reserved, type, data, count );
946
947 /* NT only checks count, not val_count */
948 if ((data && !count) || reserved) return ERROR_INVALID_PARAMETER;
949 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
950
951 total_size = info_size + (MAX_PATH + 1) * sizeof(WCHAR);
952 if (data) total_size += *count;
953 total_size = min( sizeof(buffer), total_size );
954
955 status = NtEnumerateValueKey( hkey, index, KeyValueFullInformation,
956 buffer, total_size, &total_size );
957 if (status && status != STATUS_BUFFER_OVERFLOW) goto done;
958
959 /* we need to fetch the contents for a string type even if not requested,
960 * because we need to compute the length of the ASCII string. */
961 if (value || data || is_string(info->Type))
962 {
963 /* retry with a dynamically allocated buffer */
964 while (status == STATUS_BUFFER_OVERFLOW)
965 {
966 if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
967 if (!(buf_ptr = HeapAlloc( GetProcessHeap(), 0, total_size )))
968 return ERROR_NOT_ENOUGH_MEMORY;
969 info = (KEY_VALUE_FULL_INFORMATION *)buf_ptr;
970 status = NtEnumerateValueKey( hkey, index, KeyValueFullInformation,
971 buf_ptr, total_size, &total_size );
972 }
973
974 if (status) goto done;
975
976 if (is_string(info->Type))
977 {
978 DWORD len;
979 RtlUnicodeToMultiByteSize( &len, (WCHAR *)(buf_ptr + info->DataOffset),
980 total_size - info->DataOffset );
981 if (data && len)
982 {
983 if (len > *count) status = STATUS_BUFFER_OVERFLOW;
984 else
985 {
986 RtlUnicodeToMultiByteN( data, len, NULL, (WCHAR *)(buf_ptr + info->DataOffset),
987 total_size - info->DataOffset );
988 /* if the type is REG_SZ and data is not 0-terminated
989 * and there is enough space in the buffer NT appends a \0 */
990 if (len < *count && data[len-1]) data[len] = 0;
991 }
992 }
993 info->DataLength = len;
994 }
995 else if (data)
996 {
997 if (total_size - info->DataOffset > *count) status = STATUS_BUFFER_OVERFLOW;
998 else memcpy( data, buf_ptr + info->DataOffset, total_size - info->DataOffset );
999 }
1000
1001 if (value && !status)
1002 {
1003 DWORD len;
1004
1005 RtlUnicodeToMultiByteSize( &len, info->Name, info->NameLength );
1006 if (len >= *val_count)
1007 {
1008 status = STATUS_BUFFER_OVERFLOW;
1009 if (*val_count)
1010 {
1011 len = *val_count - 1;
1012 RtlUnicodeToMultiByteN( value, len, NULL, info->Name, info->NameLength );
1013 value[len] = 0;
1014 }
1015 }
1016 else
1017 {
1018 RtlUnicodeToMultiByteN( value, len, NULL, info->Name, info->NameLength );
1019 value[len] = 0;
1020 *val_count = len;
1021 }
1022 }
1023 }
1024 else status = STATUS_SUCCESS;
1025
1026 if (type) *type = info->Type;
1027 if (count) *count = info->DataLength;
1028
1029 done:
1030 if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
1031 return RtlNtStatusToDosError(status);
1032 }
1033
1034
1035 /******************************************************************************
1036 * VMM_RegEnumKeyA
1037 */
1038 static DWORD VMM_RegEnumKeyA( HKEY hkey, DWORD index, LPSTR name, DWORD name_len )
1039 {
1040 NTSTATUS status;
1041 char buffer[256], *buf_ptr = buffer;
1042 KEY_NODE_INFORMATION *info = (KEY_NODE_INFORMATION *)buffer;
1043 DWORD total_size;
1044
1045 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
1046
1047 status = NtEnumerateKey( hkey, index, KeyNodeInformation,
1048 buffer, sizeof(buffer), &total_size );
1049
1050 while (status == STATUS_BUFFER_OVERFLOW)
1051 {
1052 /* retry with a dynamically allocated buffer */
1053 if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
1054 if (!(buf_ptr = HeapAlloc( GetProcessHeap(), 0, total_size )))
1055 return ERROR_NOT_ENOUGH_MEMORY;
1056 info = (KEY_NODE_INFORMATION *)buf_ptr;
1057 status = NtEnumerateKey( hkey, index, KeyNodeInformation,
1058 buf_ptr, total_size, &total_size );
1059 }
1060
1061 if (!status)
1062 {
1063 DWORD len;
1064
1065 RtlUnicodeToMultiByteSize( &len, info->Name, info->NameLength );
1066 if (len >= name_len) status = STATUS_BUFFER_OVERFLOW;
1067 else
1068 {
1069 RtlUnicodeToMultiByteN( name, len, NULL, info->Name, info->NameLength );
1070 name[len] = 0;
1071 }
1072 }
1073
1074 if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
1075 return RtlNtStatusToDosError( status );
1076 }
1077
1078
1079 /******************************************************************************
1080 * VMM_RegQueryInfoKeyA
1081 *
1082 * NOTE: This VxDCall takes only a subset of the parameters that the
1083 * corresponding Win32 API call does. The implementation in Win95
1084 * ADVAPI32 sets all output parameters not mentioned here to zero.
1085 */
1086 static DWORD VMM_RegQueryInfoKeyA( HKEY hkey, LPDWORD subkeys, LPDWORD max_subkey,
1087 LPDWORD values, LPDWORD max_value, LPDWORD max_data )
1088 {
1089 NTSTATUS status;
1090 KEY_FULL_INFORMATION info;
1091 DWORD total_size;
1092
1093 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
1094
1095 status = NtQueryKey( hkey, KeyFullInformation, &info, sizeof(info), &total_size );
1096 if (status && status != STATUS_BUFFER_OVERFLOW) return RtlNtStatusToDosError( status );
1097
1098 if (subkeys) *subkeys = info.SubKeys;
1099 if (max_subkey) *max_subkey = info.MaxNameLen;
1100 if (values) *values = info.Values;
1101 if (max_value) *max_value = info.MaxValueNameLen;
1102 if (max_data) *max_data = info.MaxValueDataLen;
1103 return ERROR_SUCCESS;
1104 }
1105
1106
1107 /***********************************************************************
1108 * VxDCall_VMM
1109 */
1110 static DWORD VxDCall_VMM( DWORD service, CONTEXT86 *context )
1111 {
1112 switch ( LOWORD(service) )
1113 {
1114 case 0x0011: /* RegOpenKey */
1115 {
1116 HKEY hkey = (HKEY) stack32_pop( context );
1117 LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
1118 PHKEY retkey = (PHKEY)stack32_pop( context );
1119 return VMM_RegOpenKeyExA( hkey, lpszSubKey, 0, KEY_ALL_ACCESS, retkey );
1120 }
1121
1122 case 0x0012: /* RegCreateKey */
1123 {
1124 HKEY hkey = (HKEY) stack32_pop( context );
1125 LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
1126 PHKEY retkey = (PHKEY)stack32_pop( context );
1127 return VMM_RegCreateKeyA( hkey, lpszSubKey, retkey );
1128 }
1129
1130 case 0x0013: /* RegCloseKey */
1131 {
1132 HKEY hkey = (HKEY)stack32_pop( context );
1133 return VMM_RegCloseKey( hkey );
1134 }
1135
1136 case 0x0014: /* RegDeleteKey */
1137 {
1138 HKEY hkey = (HKEY) stack32_pop( context );
1139 LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
1140 return VMM_RegDeleteKeyA( hkey, lpszSubKey );
1141 }
1142
1143 case 0x0015: /* RegSetValue */
1144 {
1145 HKEY hkey = (HKEY) stack32_pop( context );
1146 LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
1147 DWORD dwType = (DWORD) stack32_pop( context );
1148 LPCSTR lpszData = (LPCSTR)stack32_pop( context );
1149 DWORD cbData = (DWORD) stack32_pop( context );
1150 return VMM_RegSetValueA( hkey, lpszSubKey, dwType, lpszData, cbData );
1151 }
1152
1153 case 0x0016: /* RegDeleteValue */
1154 {
1155 HKEY hkey = (HKEY) stack32_pop( context );
1156 LPSTR lpszValue = (LPSTR)stack32_pop( context );
1157 return VMM_RegDeleteValueA( hkey, lpszValue );
1158 }
1159
1160 case 0x0017: /* RegQueryValue */
1161 {
1162 HKEY hkey = (HKEY) stack32_pop( context );
1163 LPSTR lpszSubKey = (LPSTR) stack32_pop( context );
1164 LPSTR lpszData = (LPSTR) stack32_pop( context );
1165 LPDWORD lpcbData = (LPDWORD)stack32_pop( context );
1166 return VMM_RegQueryValueA( hkey, lpszSubKey, lpszData, lpcbData );
1167 }
1168
1169 case 0x0018: /* RegEnumKey */
1170 {
1171 HKEY hkey = (HKEY) stack32_pop( context );
1172 DWORD iSubkey = (DWORD)stack32_pop( context );
1173 LPSTR lpszName = (LPSTR)stack32_pop( context );
1174 DWORD lpcchName = (DWORD)stack32_pop( context );
1175 return VMM_RegEnumKeyA( hkey, iSubkey, lpszName, lpcchName );
1176 }
1177
1178 case 0x0019: /* RegEnumValue */
1179 {
1180 HKEY hkey = (HKEY) stack32_pop( context );
1181 DWORD iValue = (DWORD) stack32_pop( context );
1182 LPSTR lpszValue = (LPSTR) stack32_pop( context );
1183 LPDWORD lpcchValue = (LPDWORD)stack32_pop( context );
1184 LPDWORD lpReserved = (LPDWORD)stack32_pop( context );
1185 LPDWORD lpdwType = (LPDWORD)stack32_pop( context );
1186 LPBYTE lpbData = (LPBYTE) stack32_pop( context );
1187 LPDWORD lpcbData = (LPDWORD)stack32_pop( context );
1188 return VMM_RegEnumValueA( hkey, iValue, lpszValue, lpcchValue,
1189 lpReserved, lpdwType, lpbData, lpcbData );
1190 }
1191
1192 case 0x001A: /* RegQueryValueEx */
1193 {
1194 HKEY hkey = (HKEY) stack32_pop( context );
1195 LPSTR lpszValue = (LPSTR) stack32_pop( context );
1196 LPDWORD lpReserved = (LPDWORD)stack32_pop( context );
1197 LPDWORD lpdwType = (LPDWORD)stack32_pop( context );
1198 LPBYTE lpbData = (LPBYTE) stack32_pop( context );
1199 LPDWORD lpcbData = (LPDWORD)stack32_pop( context );
1200 return VMM_RegQueryValueExA( hkey, lpszValue, lpReserved,
1201 lpdwType, lpbData, lpcbData );
1202 }
1203
1204 case 0x001B: /* RegSetValueEx */
1205 {
1206 HKEY hkey = (HKEY) stack32_pop( context );
1207 LPSTR lpszValue = (LPSTR) stack32_pop( context );
1208 DWORD dwReserved = (DWORD) stack32_pop( context );
1209 DWORD dwType = (DWORD) stack32_pop( context );
1210 LPBYTE lpbData = (LPBYTE)stack32_pop( context );
1211 DWORD cbData = (DWORD) stack32_pop( context );
1212 return VMM_RegSetValueExA( hkey, lpszValue, dwReserved,
1213 dwType, lpbData, cbData );
1214 }
1215
1216 case 0x001C: /* RegFlushKey */
1217 {
1218 HKEY hkey = (HKEY)stack32_pop( context );
1219 FIXME( "RegFlushKey(%p): stub\n", hkey );
1220 return ERROR_SUCCESS;
1221 }
1222
1223 case 0x001D: /* RegQueryInfoKey */
1224 {
1225 /* NOTE: This VxDCall takes only a subset of the parameters that the
1226 corresponding Win32 API call does. The implementation in Win95
1227 ADVAPI32 sets all output parameters not mentioned here to zero. */
1228
1229 HKEY hkey = (HKEY) stack32_pop( context );
1230 LPDWORD lpcSubKeys = (LPDWORD)stack32_pop( context );
1231 LPDWORD lpcchMaxSubKey = (LPDWORD)stack32_pop( context );
1232 LPDWORD lpcValues = (LPDWORD)stack32_pop( context );
1233 LPDWORD lpcchMaxValueName = (LPDWORD)stack32_pop( context );
1234 LPDWORD lpcchMaxValueData = (LPDWORD)stack32_pop( context );
1235 return VMM_RegQueryInfoKeyA( hkey, lpcSubKeys, lpcchMaxSubKey,
1236 lpcValues, lpcchMaxValueName, lpcchMaxValueData );
1237 }
1238
1239 case 0x0021: /* RegLoadKey */
1240 {
1241 HKEY hkey = (HKEY) stack32_pop( context );
1242 LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
1243 LPCSTR lpszFile = (LPCSTR)stack32_pop( context );
1244 FIXME("RegLoadKey(%p,%s,%s): stub\n",hkey, debugstr_a(lpszSubKey), debugstr_a(lpszFile));
1245 return ERROR_SUCCESS;
1246 }
1247
1248 case 0x0022: /* RegUnLoadKey */
1249 {
1250 HKEY hkey = (HKEY) stack32_pop( context );
1251 LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
1252 FIXME("RegUnLoadKey(%p,%s): stub\n",hkey, debugstr_a(lpszSubKey));
1253 return ERROR_SUCCESS;
1254 }
1255
1256 case 0x0023: /* RegSaveKey */
1257 {
1258 HKEY hkey = (HKEY) stack32_pop( context );
1259 LPCSTR lpszFile = (LPCSTR)stack32_pop( context );
1260 LPSECURITY_ATTRIBUTES sa = (LPSECURITY_ATTRIBUTES)stack32_pop( context );
1261 FIXME("RegSaveKey(%p,%s,%p): stub\n",hkey, debugstr_a(lpszFile),sa);
1262 return ERROR_SUCCESS;
1263 }
1264
1265 #if 0 /* Functions are not yet implemented in misc/registry.c */
1266 case 0x0024: /* RegRemapPreDefKey */
1267 case 0x0026: /* RegQueryMultipleValues */
1268 #endif
1269
1270 case 0x0027: /* RegReplaceKey */
1271 {
1272 HKEY hkey = (HKEY) stack32_pop( context );
1273 LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
1274 LPCSTR lpszNewFile= (LPCSTR)stack32_pop( context );
1275 LPCSTR lpszOldFile= (LPCSTR)stack32_pop( context );
1276 FIXME("RegReplaceKey(%p,%s,%s,%s): stub\n", hkey, debugstr_a(lpszSubKey),
1277 debugstr_a(lpszNewFile),debugstr_a(lpszOldFile));
1278 return ERROR_SUCCESS;
1279 }
1280
1281 case 0x0000: /* PageReserve */
1282 {
1283 LPVOID address;
1284 LPVOID ret;
1285 DWORD psize = getpagesize();
1286 ULONG page = (ULONG) stack32_pop( context );
1287 ULONG npages = (ULONG) stack32_pop( context );
1288 ULONG flags = (ULONG) stack32_pop( context );
1289
1290 TRACE("PageReserve: page: %08lx, npages: %08lx, flags: %08lx partial stub!\n",
1291 page, npages, flags );
1292
1293 if ( page == PR_SYSTEM ) {
1294 ERR("Can't reserve ring 1 memory\n");
1295 return -1;
1296 }
1297 /* FIXME: This has to be handled separately for the separate
1298 address-spaces we now have */
1299 if ( page == PR_PRIVATE || page == PR_SHARED ) page = 0;
1300 /* FIXME: Handle flags in some way */
1301 address = (LPVOID )(page * psize);
1302 ret = VirtualAlloc ( address, ( npages * psize ), MEM_RESERVE, 0 );
1303 TRACE("PageReserve: returning: %08lx\n", (DWORD )ret );
1304 if ( ret == NULL )
1305 return -1;
1306 else
1307 return (DWORD )ret;
1308 }
1309
1310 case 0x0001: /* PageCommit */
1311 {
1312 LPVOID address;
1313 LPVOID ret;
1314 DWORD virt_perm;
1315 DWORD psize = getpagesize();
1316 ULONG page = (ULONG) stack32_pop( context );
1317 ULONG npages = (ULONG) stack32_pop( context );
1318 ULONG hpd = (ULONG) stack32_pop( context );
1319 ULONG pagerdata = (ULONG) stack32_pop( context );
1320 ULONG flags = (ULONG) stack32_pop( context );
1321
1322 TRACE("PageCommit: page: %08lx, npages: %08lx, hpd: %08lx pagerdata: "
1323 "%08lx, flags: %08lx partial stub\n",
1324 page, npages, hpd, pagerdata, flags );
1325
1326 if ( flags & PC_USER )
1327 if ( flags & PC_WRITEABLE )
1328 virt_perm = PAGE_EXECUTE_READWRITE;
1329 else
1330 virt_perm = PAGE_EXECUTE_READ;
1331 else
1332 virt_perm = PAGE_NOACCESS;
1333
1334 address = (LPVOID )(page * psize);
1335 ret = VirtualAlloc ( address, ( npages * psize ), MEM_COMMIT, virt_perm );
1336 TRACE("PageCommit: Returning: %08lx\n", (DWORD )ret );
1337 return (DWORD )ret;
1338
1339 }
1340 case 0x0002: /* PageDecommit */
1341 {
1342 LPVOID address;
1343 BOOL ret;
1344 DWORD psize = getpagesize();
1345 ULONG page = (ULONG) stack32_pop( context );
1346 ULONG npages = (ULONG) stack32_pop( context );
1347 ULONG flags = (ULONG) stack32_pop( context );
1348
1349 TRACE("PageDecommit: page: %08lx, npages: %08lx, flags: %08lx partial stub\n",
1350 page, npages, flags );
1351 address = (LPVOID )( page * psize );
1352 ret = VirtualFree ( address, ( npages * psize ), MEM_DECOMMIT );
1353 TRACE("PageDecommit: Returning: %s\n", ret ? "TRUE" : "FALSE" );
1354 return ret;
1355 }
1356 case 0x000d: /* PageModifyPermissions */
1357 {
1358 DWORD pg_old_perm;
1359 DWORD pg_new_perm;
1360 DWORD virt_old_perm;
1361 DWORD virt_new_perm;
1362 MEMORY_BASIC_INFORMATION mbi;
1363 LPVOID address;
1364 DWORD psize = getpagesize();
1365 ULONG page = stack32_pop ( context );
1366 ULONG npages = stack32_pop ( context );
1367 ULONG permand = stack32_pop ( context );
1368 ULONG permor = stack32_pop ( context );
1369
1370 TRACE("PageModifyPermissions %08lx %08lx %08lx %08lx partial stub\n",
1371 page, npages, permand, permor );
1372 address = (LPVOID )( page * psize );
1373
1374 VirtualQuery ( address, &mbi, sizeof ( MEMORY_BASIC_INFORMATION ));
1375 virt_old_perm = mbi.Protect;
1376
1377 switch ( virt_old_perm & mbi.Protect ) {
1378 case PAGE_READONLY:
1379 case PAGE_EXECUTE:
1380 case PAGE_EXECUTE_READ:
1381 pg_old_perm = PC_USER;
1382 break;
1383 case PAGE_READWRITE:
1384 case PAGE_WRITECOPY:
1385 case PAGE_EXECUTE_READWRITE:
1386 case PAGE_EXECUTE_WRITECOPY:
1387 pg_old_perm = PC_USER | PC_WRITEABLE;
1388 break;
1389 case PAGE_NOACCESS:
1390 default:
1391 pg_old_perm = 0;
1392 break;
1393 }
1394 pg_new_perm = pg_old_perm;
1395 pg_new_perm &= permand & ~PC_STATIC;
1396 pg_new_perm |= permor & ~PC_STATIC;
1397
1398 virt_new_perm = ( virt_old_perm ) & ~0xff;
1399 if ( pg_new_perm & PC_USER )
1400 {
1401 if ( pg_new_perm & PC_WRITEABLE )
1402 virt_new_perm |= PAGE_EXECUTE_READWRITE;
1403 else
1404 virt_new_perm |= PAGE_EXECUTE_READ;
1405 }
1406
1407 if ( ! VirtualProtect ( address, ( npages * psize ), virt_new_perm, &virt_old_perm ) ) {
1408 ERR("Can't change page permissions for %08lx\n", (DWORD )address );
1409 return 0xffffffff;
1410 }
1411 TRACE("Returning: %08lx\n", pg_old_perm );
1412 return pg_old_perm;
1413 }
1414 case 0x000a: /* PageFree */
1415 {
1416 BOOL ret;
1417 LPVOID hmem = (LPVOID) stack32_pop( context );
1418 DWORD flags = (DWORD ) stack32_pop( context );
1419
1420 TRACE("PageFree: hmem: %08lx, flags: %08lx partial stub\n",
1421 (DWORD )hmem, flags );
1422
1423 ret = VirtualFree ( hmem, 0, MEM_RELEASE );
1424 context->Eax = ret;
1425 TRACE("Returning: %d\n", ret );
1426
1427 return 0;
1428 }
1429 case 0x001e: /* GetDemandPageInfo */
1430 {
1431 DWORD dinfo = (DWORD)stack32_pop( context );
1432 DWORD flags = (DWORD)stack32_pop( context );
1433
1434 /* GetDemandPageInfo is supposed to fill out the struct at
1435 * "dinfo" with various low-level memory management information.
1436 * Apps are certainly not supposed to call this, although it's
1437 * demoed and documented by Pietrek on pages 441-443 of "Windows
1438 * 95 System Programming Secrets" if any program needs a real
1439 * implementation of this.
1440 */
1441
1442 FIXME("GetDemandPageInfo(%08lx %08lx): stub!\n", dinfo, flags);
1443
1444 return 0;
1445 }
1446 default:
1447 if (LOWORD(service) < N_VMM_SERVICE)
1448 FIXME( "Unimplemented service %s (%08lx)\n",
1449 VMM_Service_Name[LOWORD(service)], service);
1450 else
1451 FIXME( "Unknown service %08lx\n", service);
1452 break;
1453 }
1454
1455 return 0xffffffff; /* FIXME */
1456 }
1457
1458 /***********************************************************************
1459 * DeviceIo_IFSMgr
1460 * NOTES
1461 * These ioctls are used by 'MSNET32.DLL'.
1462 *
1463 * I have been unable to uncover any documentation about the ioctls so
1464 * the implementation of the cases IFS_IOCTL_21 and IFS_IOCTL_2F are
1465 * based on reasonable guesses on information found in the Windows 95 DDK.
1466 *
1467 */
1468
1469 /*
1470 * IFSMgr DeviceIO service
1471 */
1472
1473 #define IFS_IOCTL_21 100
1474 #define IFS_IOCTL_2F 101
1475 #define IFS_IOCTL_GET_RES 102
1476 #define IFS_IOCTL_GET_NETPRO_NAME_A 103
1477
1478 struct win32apireq {
1479 unsigned long ar_proid;
1480 unsigned long ar_eax;
1481 unsigned long ar_ebx;
1482 unsigned long ar_ecx;
1483 unsigned long ar_edx;
1484 unsigned long ar_esi;
1485 unsigned long ar_edi;
1486 unsigned long ar_ebp;
1487 unsigned short ar_error;
1488 unsigned short ar_pad;
1489 };
1490
1491 static void win32apieq_2_CONTEXT(struct win32apireq *pIn,CONTEXT86 *pCxt)
1492 {
1493 memset(pCxt,0,sizeof(*pCxt));
1494
1495 pCxt->ContextFlags=CONTEXT86_INTEGER|CONTEXT86_CONTROL;
1496 pCxt->Eax = pIn->ar_eax;
1497 pCxt->Ebx = pIn->ar_ebx;
1498 pCxt->Ecx = pIn->ar_ecx;
1499 pCxt->Edx = pIn->ar_edx;
1500 pCxt->Esi = pIn->ar_esi;
1501 pCxt->Edi = pIn->ar_edi;
1502
1503 /* FIXME: Only partial CONTEXT86_CONTROL */
1504 pCxt->Ebp = pIn->ar_ebp;
1505
1506 /* FIXME: pIn->ar_proid ignored */
1507 /* FIXME: pIn->ar_error ignored */
1508 /* FIXME: pIn->ar_pad ignored */
1509 }
1510
1511 static void CONTEXT_2_win32apieq(CONTEXT86 *pCxt,struct win32apireq *pOut)
1512 {
1513 memset(pOut,0,sizeof(struct win32apireq));
1514
1515 pOut->ar_eax = pCxt->Eax;
1516 pOut->ar_ebx = pCxt->Ebx;
1517 pOut->ar_ecx = pCxt->Ecx;
1518 pOut->ar_edx = pCxt->Edx;
1519 pOut->ar_esi = pCxt->Esi;
1520 pOut->ar_edi = pCxt->Edi;
1521
1522 /* FIXME: Only partial CONTEXT86_CONTROL */
1523 pOut->ar_ebp = pCxt->Ebp;
1524
1525 /* FIXME: pOut->ar_proid ignored */
1526 /* FIXME: pOut->ar_error ignored */
1527 /* FIXME: pOut->ar_pad ignored */
1528 }
1529
1530 static BOOL DeviceIo_IFSMgr(DWORD dwIoControlCode, LPVOID lpvInBuffer, DWORD cbInBuffer,
1531 LPVOID lpvOutBuffer, DWORD cbOutBuffer,
1532 LPDWORD lpcbBytesReturned,
1533 LPOVERLAPPED lpOverlapped)
1534 {
1535 BOOL retv = TRUE;
1536 TRACE("(%ld,%p,%ld,%p,%ld,%p,%p): stub\n",
1537 dwIoControlCode,
1538 lpvInBuffer,cbInBuffer,
1539 lpvOutBuffer,cbOutBuffer,
1540 lpcbBytesReturned,
1541 lpOverlapped);
1542
1543 switch (dwIoControlCode)
1544 {
1545 case IFS_IOCTL_21:
1546 case IFS_IOCTL_2F:{
1547 CONTEXT86 cxt;
1548 struct win32apireq *pIn=(struct win32apireq *) lpvInBuffer;
1549 struct win32apireq *pOut=(struct win32apireq *) lpvOutBuffer;
1550
1551 TRACE(
1552 "Control '%s': "
1553 "proid=0x%08lx, eax=0x%08lx, ebx=0x%08lx, ecx=0x%08lx, "
1554 "edx=0x%08lx, esi=0x%08lx, edi=0x%08lx, ebp=0x%08lx, "
1555 "error=0x%04x, pad=0x%04x\n",
1556 (dwIoControlCode==IFS_IOCTL_21)?"IFS_IOCTL_21":"IFS_IOCTL_2F",
1557 pIn->ar_proid, pIn->ar_eax, pIn->ar_ebx, pIn->ar_ecx,
1558 pIn->ar_edx, pIn->ar_esi, pIn->ar_edi, pIn->ar_ebp,
1559 pIn->ar_error, pIn->ar_pad
1560 );
1561
1562 win32apieq_2_CONTEXT(pIn,&cxt);
1563
1564 if(dwIoControlCode==IFS_IOCTL_21)
1565 {
1566 if(Dosvm.CallBuiltinHandler || DPMI_LoadDosSystem())
1567 Dosvm.CallBuiltinHandler( &cxt, 0x21 );
1568 }
1569 else
1570 {
1571 if(Dosvm.CallBuiltinHandler || DPMI_LoadDosSystem())
1572 Dosvm.CallBuiltinHandler( &cxt, 0x2f );
1573 }
1574
1575 CONTEXT_2_win32apieq(&cxt,pOut);
1576
1577 retv = TRUE;
1578 } break;
1579 case IFS_IOCTL_GET_RES:{
1580 FIXME( "Control 'IFS_IOCTL_GET_RES' not implemented\n");
1581 retv = FALSE;
1582 } break;
1583 case IFS_IOCTL_GET_NETPRO_NAME_A:{
1584 FIXME( "Control 'IFS_IOCTL_GET_NETPRO_NAME_A' not implemented\n");
1585 retv = FALSE;
1586 } break;
1587 default:
1588 FIXME( "Control %ld not implemented\n", dwIoControlCode);
1589 retv = FALSE;
1590 }
1591
1592 return retv;
1593 }
1594
1595 /********************************************************************************
1596 * VxDCall_VWin32
1597 *
1598 * Service numbers taken from page 448 of Pietrek's "Windows 95 System
1599 * Programming Secrets". Parameters from experimentation on real Win98.
1600 *
1601 */
1602
1603 static DWORD VxDCall_VWin32( DWORD service, CONTEXT86 *context )
1604 {
1605 switch ( LOWORD(service) )
1606 {
1607 case 0x0000: /* GetVersion */
1608 {
1609 DWORD vers = GetVersion();
1610 return (LOBYTE(vers) << 8) | HIBYTE(vers);
1611 }
1612 break;
1613
1614 case 0x0020: /* Get VMCPD Version */
1615 {
1616 DWORD parm = (DWORD) stack32_pop(context);
1617
1618 FIXME("Get VMCPD Version(%08lx): partial stub!\n", parm);
1619
1620 /* FIXME: This is what Win98 returns, it may
1621 * not be correct in all situations.
1622 * It makes Bleem! happy though.
1623 */
1624
1625 return 0x0405;
1626 }
1627
1628 case 0x0029: /* Int31/DPMI dispatch */
1629 {
1630 DWORD callnum = (DWORD) stack32_pop(context);
1631 DWORD parm = (DWORD) stack32_pop(context);
1632
1633 TRACE("Int31/DPMI dispatch(%08lx)\n", callnum);
1634
1635 SET_AX( context, callnum );
1636 SET_CX( context, parm );
1637 if(Dosvm.CallBuiltinHandler || DPMI_LoadDosSystem())
1638 Dosvm.CallBuiltinHandler( context, 0x31 );
1639
1640 return LOWORD(context->Eax);
1641 }
1642 break;
1643
1644 case 0x002a: /* Int41 dispatch - parm = int41 service number */
1645 {
1646 DWORD callnum = (DWORD) stack32_pop(context);
1647
1648 return callnum; /* FIXME: should really call INT_Int41Handler() */
1649 }
1650 break;
1651
1652 default:
1653 FIXME("Unknown VWin32 service %08lx\n", service);
1654 break;
1655 }
1656
1657 return 0xffffffff;
1658 }
1659
1660
1661 /***********************************************************************
1662 * DeviceIo_VCD
1663 */
1664 static BOOL DeviceIo_VCD(DWORD dwIoControlCode,
1665 LPVOID lpvInBuffer, DWORD cbInBuffer,
1666 LPVOID lpvOutBuffer, DWORD cbOutBuffer,
1667 LPDWORD lpcbBytesReturned,
1668 LPOVERLAPPED lpOverlapped)
1669 {
1670 BOOL retv = TRUE;
1671
1672 switch (dwIoControlCode)
1673 {
1674 case IOCTL_SERIAL_LSRMST_INSERT:
1675 {
1676 FIXME( "IOCTL_SERIAL_LSRMST_INSERT NIY !\n");
1677 retv = FALSE;
1678 }
1679 break;
1680
1681 default:
1682 FIXME( "Unknown Control %ld\n", dwIoControlCode);
1683 retv = FALSE;
1684 break;
1685 }
1686
1687 return retv;
1688 }
1689
1690
1691 /***********************************************************************
1692 * DeviceIo_VWin32
1693 */
1694
1695 static void DIOCRegs_2_CONTEXT( DIOC_REGISTERS *pIn, CONTEXT86 *pCxt )
1696 {
1697 memset( pCxt, 0, sizeof(*pCxt) );
1698 /* Note: segment registers == 0 means that CTX_SEG_OFF_TO_LIN
1699 will interpret 32-bit register contents as linear pointers */
1700
1701 pCxt->ContextFlags=CONTEXT86_INTEGER|CONTEXT86_CONTROL;
1702 pCxt->Eax = pIn->reg_EAX;
1703 pCxt->Ebx = pIn->reg_EBX;
1704 pCxt->Ecx = pIn->reg_ECX;
1705 pCxt->Edx = pIn->reg_EDX;
1706 pCxt->Esi = pIn->reg_ESI;
1707 pCxt->Edi = pIn->reg_EDI;
1708
1709 /* FIXME: Only partial CONTEXT86_CONTROL */
1710 pCxt->EFlags = pIn->reg_Flags;
1711 }
1712
1713 static void CONTEXT_2_DIOCRegs( CONTEXT86 *pCxt, DIOC_REGISTERS *pOut )
1714 {
1715 memset( pOut, 0, sizeof(DIOC_REGISTERS) );
1716
1717 pOut->reg_EAX = pCxt->Eax;
1718 pOut->reg_EBX = pCxt->Ebx;
1719 pOut->reg_ECX = pCxt->Ecx;
1720 pOut->reg_EDX = pCxt->Edx;
1721 pOut->reg_ESI = pCxt->Esi;
1722 pOut->reg_EDI = pCxt->Edi;
1723
1724 /* FIXME: Only partial CONTEXT86_CONTROL */
1725 pOut->reg_Flags = pCxt->EFlags;
1726 }
1727
1728 #define DIOC_AH(regs) (((unsigned char*)&((regs)->reg_EAX))[1])
1729 #define DIOC_AL(regs) (((unsigned char*)&((regs)->reg_EAX))[0])
1730 #define DIOC_BH(regs) (((unsigned char*)&((regs)->reg_EBX))[1])
1731 #define DIOC_BL(regs) (((unsigned char*)&((regs)->reg_EBX))[0])
1732 #define DIOC_DH(regs) (((unsigned char*)&((regs)->reg_EDX))[1])
1733 #define DIOC_DL(regs) (((unsigned char*)&((regs)->reg_EDX))[0])
1734
1735 #define DIOC_AX(regs) (((unsigned short*)&((regs)->reg_EAX))[0])
1736 #define DIOC_BX(regs) (((unsigned short*)&((regs)->reg_EBX))[0])
1737 #define DIOC_CX(regs) (((unsigned short*)&((regs)->reg_ECX))[0])
1738 #define DIOC_DX(regs) (((unsigned short*)&((regs)->reg_EDX))[0])
1739
1740 #define DIOC_SET_CARRY(regs) (((regs)->reg_Flags)|=0x00000001)
1741
1742 static BOOL DeviceIo_VWin32(DWORD dwIoControlCode,
1743 LPVOID lpvInBuffer, DWORD cbInBuffer,
1744 LPVOID lpvOutBuffer, DWORD cbOutBuffer,
1745 LPDWORD lpcbBytesReturned,
1746 LPOVERLAPPED lpOverlapped)
1747 {
1748 BOOL retv = TRUE;
1749
1750 switch (dwIoControlCode)
1751 {
1752 case VWIN32_DIOC_DOS_IOCTL:
1753 case 0x10: /* Int 0x21 call, call it VWIN_DIOC_INT21 ? */
1754 case VWIN32_DIOC_DOS_INT13:
1755 case VWIN32_DIOC_DOS_INT25:
1756 case VWIN32_DIOC_DOS_INT26:
1757 case 0x29: /* Int 0x31 call, call it VWIN_DIOC_INT31 ? */
1758 case VWIN32_DIOC_DOS_DRIVEINFO:
1759 {
1760 CONTEXT86 cxt;
1761 DIOC_REGISTERS *pIn = (DIOC_REGISTERS *)lpvInBuffer;
1762 DIOC_REGISTERS *pOut = (DIOC_REGISTERS *)lpvOutBuffer;
1763 BYTE intnum = 0;
1764
1765 TRACE( "Control '%s': "
1766 "eax=0x%08lx, ebx=0x%08lx, ecx=0x%08lx, "
1767 "edx=0x%08lx, esi=0x%08lx, edi=0x%08lx \n",
1768 (dwIoControlCode == VWIN32_DIOC_DOS_IOCTL)? "VWIN32_DIOC_DOS_IOCTL" :
1769 (dwIoControlCode == VWIN32_DIOC_DOS_INT25)? "VWIN32_DIOC_DOS_INT25" :
1770 (dwIoControlCode == VWIN32_DIOC_DOS_INT26)? "VWIN32_DIOC_DOS_INT26" :
1771 (dwIoControlCode == VWIN32_DIOC_DOS_DRIVEINFO)? "VWIN32_DIOC_DOS_DRIVEINFO" : "???",
1772 pIn->reg_EAX, pIn->reg_EBX, pIn->reg_ECX,
1773 pIn->reg_EDX, pIn->reg_ESI, pIn->reg_EDI );
1774
1775 DIOCRegs_2_CONTEXT( pIn, &cxt );
1776
1777 switch (dwIoControlCode)
1778 {
1779 case VWIN32_DIOC_DOS_IOCTL: /* Call int 21h */
1780 case 0x10: /* Int 0x21 call, call it VWIN_DIOC_INT21 ? */
1781 case VWIN32_DIOC_DOS_DRIVEINFO: /* Call int 21h 730x */
1782 intnum = 0x21;
1783 break;
1784 case VWIN32_DIOC_DOS_INT13:
1785 intnum = 0x13;
1786 break;
1787 case VWIN32_DIOC_DOS_INT25:
1788 intnum = 0x25;
1789 break;
1790 case VWIN32_DIOC_DOS_INT26:
1791 intnum = 0x26;
1792 break;
1793 case 0x29: /* Int 0x31 call, call it VWIN_DIOC_INT31 ? */
1794 intnum = 0x31;
1795 break;
1796 }
1797
1798 if(Dosvm.CallBuiltinHandler || DPMI_LoadDosSystem())
1799 Dosvm.CallBuiltinHandler( &cxt, intnum );
1800
1801 CONTEXT_2_DIOCRegs( &cxt, pOut );
1802 }
1803 break;
1804
1805 case VWIN32_DIOC_SIMCTRLC:
1806 FIXME( "Control VWIN32_DIOC_SIMCTRLC not implemented\n");
1807 retv = FALSE;
1808 break;
1809
1810 default:
1811 FIXME( "Unknown Control %ld\n", dwIoControlCode);
1812 retv = FALSE;
1813 break;
1814 }
1815
1816 return retv;
1817 }
1818
1819 /* this is the main multimedia device loader */
1820 static BOOL DeviceIo_MMDEVLDR(DWORD dwIoControlCode,
1821 LPVOID lpvInBuffer, DWORD cbInBuffer,
1822 LPVOID lpvOutBuffer, DWORD cbOutBuffer,
1823 LPDWORD lpcbBytesReturned,
1824 LPOVERLAPPED lpOverlapped)
1825 {
1826 FIXME("(%ld,%p,%ld,%p,%ld,%p,%p): stub\n",
1827 dwIoControlCode,
1828 lpvInBuffer,cbInBuffer,
1829 lpvOutBuffer,cbOutBuffer,
1830 lpcbBytesReturned,
1831 lpOverlapped
1832 );
1833 switch (dwIoControlCode) {
1834 case 5:
1835 /* Hmm. */
1836 *(DWORD*)lpvOutBuffer=0;
1837 *lpcbBytesReturned=4;
1838 return TRUE;
1839 }
1840 return FALSE;
1841 }
1842 /* this is used by some Origin games */
1843 static BOOL DeviceIo_MONODEBG(DWORD dwIoControlCode,
1844 LPVOID lpvInBuffer, DWORD cbInBuffer,
1845 LPVOID lpvOutBuffer, DWORD cbOutBuffer,
1846 LPDWORD lpcbBytesReturned,
1847 LPOVERLAPPED lpOverlapped)
1848 {
1849 switch (dwIoControlCode) {
1850 case 1: /* version */
1851 *(LPDWORD)lpvOutBuffer = 0x20004; /* WC SecretOps */
1852 break;
1853 case 9: /* debug output */
1854 ERR("MONODEBG: %s\n",debugstr_a(lpvInBuffer));
1855 break;
1856 default:
1857 FIXME("(%ld,%p,%ld,%p,%ld,%p,%p): stub\n",
1858 dwIoControlCode,
1859 lpvInBuffer,cbInBuffer,
1860 lpvOutBuffer,cbOutBuffer,
1861 lpcbBytesReturned,
1862 lpOverlapped
1863 );
1864 break;
1865 }
1866 return TRUE;
1867 }
1868 /* pccard */
1869 static BOOL DeviceIo_PCCARD (DWORD dwIoControlCode,
1870 LPVOID lpvInBuffer, DWORD cbInBuffer,
1871 LPVOID lpvOutBuffer, DWORD cbOutBuffer,
1872 LPDWORD lpcbBytesReturned,
1873 LPOVERLAPPED lpOverlapped)
1874 {
1875 switch (dwIoControlCode) {
1876 case 0x0000: /* PCCARD_Get_Version */
1877 case 0x0001: /* PCCARD_Card_Services */
1878 default:
1879 FIXME( "(%ld,%p,%ld,%p,%ld,%p,%p): stub\n",
1880 dwIoControlCode,
1881 lpvInBuffer,cbInBuffer,
1882 lpvOutBuffer,cbOutBuffer,
1883 lpcbBytesReturned,
1884 lpOverlapped
1885 );
1886 break;
1887 }
1888 return FALSE;
1889 }
1890
1891 /***********************************************************************
1892 * OpenVxDHandle (KERNEL32.@)
1893 *
1894 * This function is supposed to return the corresponding Ring 0
1895 * ("kernel") handle for a Ring 3 handle in Win9x.
1896 * Evidently, Wine will have problems with this. But we try anyway,
1897 * maybe it helps...
1898 */
1899 HANDLE WINAPI OpenVxDHandle(HANDLE hHandleRing3)
1900 {
1901 FIXME( "(%p), stub! (returning Ring 3 handle instead of Ring 0)\n", hHandleRing3);
1902 return hHandleRing3;
1903 }
1904
1905 static BOOL DeviceIo_HASP(DWORD dwIoControlCode, LPVOID lpvInBuffer, DWORD cbInBuffer,
1906 LPVOID lpvOutBuffer, DWORD cbOutBuffer,
1907 LPDWORD lpcbBytesReturned,
1908 LPOVERLAPPED lpOverlapped)
1909 {
1910 BOOL retv = TRUE;
1911 FIXME("(%ld,%p,%ld,%p,%ld,%p,%p): stub\n",
1912 dwIoControlCode,
1913 lpvInBuffer,cbInBuffer,
1914 lpvOutBuffer,cbOutBuffer,
1915 lpcbBytesReturned,
1916 lpOverlapped);
1917
1918 return retv;
1919 }
Maarten's multimedia branch