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