?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Added check for unhide option.
[wine.git] / dlls / kernel / vxd.c
blobbddbf5a2e64b09c5345830a7944541680ccbeb30
1 /*
2 * Win32 VxD 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
34 #include "windef.h"
35 #include "winbase.h"
36 #include "winreg.h"
37 #include "winerror.h"
38 #include "winnls.h"
39 #include "ntstatus.h"
40 #include "winnt.h"
41 #include "winternl.h"
42 #include "wine/winbase16.h"
43 #include "kernel_private.h"
44 #include "wine/debug.h"
45
46 WINE_DEFAULT_DEBUG_CHANNEL(vxd);
47
48 /*
49 * VMM VxDCall service names are (mostly) taken from Stan Mitchell's
50 * "Inside the Windows 95 File System"
51 */
52
53 #define N_VMM_SERVICE 41
54
55 static const char * const VMM_Service_Name[N_VMM_SERVICE] =
56 {
57 "PageReserve", /* 0x0000 */
58 "PageCommit", /* 0x0001 */
59 "PageDecommit", /* 0x0002 */
60 "PagerRegister", /* 0x0003 */
61 "PagerQuery", /* 0x0004 */
62 "HeapAllocate", /* 0x0005 */
63 "ContextCreate", /* 0x0006 */
64 "ContextDestroy", /* 0x0007 */
65 "PageAttach", /* 0x0008 */
66 "PageFlush", /* 0x0009 */
67 "PageFree", /* 0x000A */
68 "ContextSwitch", /* 0x000B */
69 "HeapReAllocate", /* 0x000C */
70 "PageModifyPermissions", /* 0x000D */
71 "PageQuery", /* 0x000E */
72 "GetCurrentContext", /* 0x000F */
73 "HeapFree", /* 0x0010 */
74 "RegOpenKey", /* 0x0011 */
75 "RegCreateKey", /* 0x0012 */
76 "RegCloseKey", /* 0x0013 */
77 "RegDeleteKey", /* 0x0014 */
78 "RegSetValue", /* 0x0015 */
79 "RegDeleteValue", /* 0x0016 */
80 "RegQueryValue", /* 0x0017 */
81 "RegEnumKey", /* 0x0018 */
82 "RegEnumValue", /* 0x0019 */
83 "RegQueryValueEx", /* 0x001A */
84 "RegSetValueEx", /* 0x001B */
85 "RegFlushKey", /* 0x001C */
86 "RegQueryInfoKey", /* 0x001D */
87 "GetDemandPageInfo", /* 0x001E */
88 "BlockOnID", /* 0x001F */
89 "SignalID", /* 0x0020 */
90 "RegLoadKey", /* 0x0021 */
91 "RegUnLoadKey", /* 0x0022 */
92 "RegSaveKey", /* 0x0023 */
93 "RegRemapPreDefKey", /* 0x0024 */
94 "PageChangePager", /* 0x0025 */
95 "RegQueryMultipleValues", /* 0x0026 */
96 "RegReplaceKey", /* 0x0027 */
97 "<KERNEL32.101>" /* 0x0028 -- What does this do??? */
98 };
99
100 /* PageReserve arena values */
101 #define PR_PRIVATE 0x80000400 /* anywhere in private arena */
102 #define PR_SHARED 0x80060000 /* anywhere in shared arena */
103 #define PR_SYSTEM 0x80080000 /* anywhere in system arena */
104
105 /* PageReserve flags */
106 #define PR_FIXED 0x00000008 /* don't move during PageReAllocate */
107 #define PR_4MEG 0x00000001 /* allocate on 4mb boundary */
108 #define PR_STATIC 0x00000010 /* see PageReserve documentation */
109
110 /* PageCommit default pager handle values */
111 #define PD_ZEROINIT 0x00000001 /* swappable zero-initialized pages */
112 #define PD_NOINIT 0x00000002 /* swappable uninitialized pages */
113 #define PD_FIXEDZERO 0x00000003 /* fixed zero-initialized pages */
114 #define PD_FIXED 0x00000004 /* fixed uninitialized pages */
115
116 /* PageCommit flags */
117 #define PC_FIXED 0x00000008 /* pages are permanently locked */
118 #define PC_LOCKED 0x00000080 /* pages are made present and locked */
119 #define PC_LOCKEDIFDP 0x00000100 /* pages are locked if swap via DOS */
120 #define PC_WRITEABLE 0x00020000 /* make the pages writeable */
121 #define PC_USER 0x00040000 /* make the pages ring 3 accessible */
122 #define PC_INCR 0x40000000 /* increment "pagerdata" each page */
123 #define PC_PRESENT 0x80000000 /* make pages initially present */
124 #define PC_STATIC 0x20000000 /* allow commit in PR_STATIC object */
125 #define PC_DIRTY 0x08000000 /* make pages initially dirty */
126 #define PC_CACHEDIS 0x00100000 /* Allocate uncached pages - new for WDM */
127 #define PC_CACHEWT 0x00080000 /* Allocate write through cache pages - new for WDM */
128 #define PC_PAGEFLUSH 0x00008000 /* Touch device mapped pages on alloc - new for WDM */
129
130 /* PageCommitContig additional flags */
131 #define PCC_ZEROINIT 0x00000001 /* zero-initialize new pages */
132 #define PCC_NOLIN 0x10000000 /* don't map to any linear address */
133
134
135 /* Pop a DWORD from the 32-bit stack */
136 static inline DWORD stack32_pop( CONTEXT86 *context )
137 {
138 DWORD ret = *(DWORD *)context->Esp;
139 context->Esp += sizeof(DWORD);
140 return ret;
141 }
142
143
144 /******************************************************************************
145 * The following is a massive duplication of the advapi32 code.
146 * Unfortunately sharing the code is not possible since the native
147 * Win95 advapi32 depends on it. Someday we should probably stop
148 * supporting native Win95 advapi32 altogether...
149 */
150
151
152 #define HKEY_SPECIAL_ROOT_FIRST HKEY_CLASSES_ROOT
153 #define HKEY_SPECIAL_ROOT_LAST HKEY_DYN_DATA
154 #define NB_SPECIAL_ROOT_KEYS ((UINT)HKEY_SPECIAL_ROOT_LAST - (UINT)HKEY_SPECIAL_ROOT_FIRST + 1)
155
156 static HKEY special_root_keys[NB_SPECIAL_ROOT_KEYS];
157
158 static const WCHAR name_CLASSES_ROOT[] =
159 {'M','a','c','h','i','n','e','\\',
160 'S','o','f','t','w','a','r','e','\\',
161 'C','l','a','s','s','e','s',0};
162 static const WCHAR name_LOCAL_MACHINE[] =
163 {'M','a','c','h','i','n','e',0};
164 static const WCHAR name_USERS[] =
165 {'U','s','e','r',0};
166 static const WCHAR name_PERFORMANCE_DATA[] =
167 {'P','e','r','f','D','a','t','a',0};
168 static const WCHAR name_CURRENT_CONFIG[] =
169 {'M','a','c','h','i','n','e','\\',
170 'S','y','s','t','e','m','\\',
171 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
172 'H','a','r','d','w','a','r','e','P','r','o','f','i','l','e','s','\\',
173 'C','u','r','r','e','n','t',0};
174 static const WCHAR name_DYN_DATA[] =
175 {'D','y','n','D','a','t','a',0};
176
177 #define DECL_STR(key) { sizeof(name_##key)-sizeof(WCHAR), sizeof(name_##key), (LPWSTR)name_##key }
178 static UNICODE_STRING root_key_names[NB_SPECIAL_ROOT_KEYS] =
179 {
180 DECL_STR(CLASSES_ROOT),
181 { 0, 0, NULL }, /* HKEY_CURRENT_USER is determined dynamically */
182 DECL_STR(LOCAL_MACHINE),
183 DECL_STR(USERS),
184 DECL_STR(PERFORMANCE_DATA),
185 DECL_STR(CURRENT_CONFIG),
186 DECL_STR(DYN_DATA)
187 };
188 #undef DECL_STR
189
190
191 /* check if value type needs string conversion (Ansi<->Unicode) */
192 inline static int is_string( DWORD type )
193 {
194 return (type == REG_SZ) || (type == REG_EXPAND_SZ) || (type == REG_MULTI_SZ);
195 }
196
197 /* create one of the HKEY_* special root keys */
198 static HKEY create_special_root_hkey( HKEY hkey, DWORD access )
199 {
200 HKEY ret = 0;
201 int idx = (UINT)hkey - (UINT)HKEY_SPECIAL_ROOT_FIRST;
202
203 if (hkey == HKEY_CURRENT_USER)
204 {
205 if (RtlOpenCurrentUser( access, &hkey )) return 0;
206 }
207 else
208 {
209 OBJECT_ATTRIBUTES attr;
210
211 attr.Length = sizeof(attr);
212 attr.RootDirectory = 0;
213 attr.ObjectName = &root_key_names[idx];
214 attr.Attributes = 0;
215 attr.SecurityDescriptor = NULL;
216 attr.SecurityQualityOfService = NULL;
217 if (NtCreateKey( &hkey, access, &attr, 0, NULL, 0, NULL )) return 0;
218 }
219
220 if (!(ret = InterlockedCompareExchangePointer( (PVOID) &special_root_keys[idx], hkey, 0 )))
221 ret = hkey;
222 else
223 NtClose( hkey ); /* somebody beat us to it */
224 return ret;
225 }
226
227 /* map the hkey from special root to normal key if necessary */
228 inline static HKEY get_special_root_hkey( HKEY hkey )
229 {
230 HKEY ret = hkey;
231
232 if ((hkey >= HKEY_SPECIAL_ROOT_FIRST) && (hkey <= HKEY_SPECIAL_ROOT_LAST))
233 {
234 if (!(ret = special_root_keys[(UINT)hkey - (UINT)HKEY_SPECIAL_ROOT_FIRST]))
235 ret = create_special_root_hkey( hkey, KEY_ALL_ACCESS );
236 }
237 return ret;
238 }
239
240
241 /******************************************************************************
242 * VMM_RegCreateKeyA
243 */
244 static DWORD VMM_RegCreateKeyA( HKEY hkey, LPCSTR name, PHKEY retkey )
245 {
246 OBJECT_ATTRIBUTES attr;
247 UNICODE_STRING nameW;
248 ANSI_STRING nameA;
249 NTSTATUS status;
250
251 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
252
253 attr.Length = sizeof(attr);
254 attr.RootDirectory = hkey;
255 attr.ObjectName = &nameW;
256 attr.Attributes = 0;
257 attr.SecurityDescriptor = NULL;
258 attr.SecurityQualityOfService = NULL;
259 RtlInitAnsiString( &nameA, name );
260
261 if (!(status = RtlAnsiStringToUnicodeString( &nameW, &nameA, TRUE )))
262 {
263 status = NtCreateKey( retkey, KEY_ALL_ACCESS, &attr, 0, NULL,
264 REG_OPTION_NON_VOLATILE, NULL );
265 RtlFreeUnicodeString( &nameW );
266 }
267 return RtlNtStatusToDosError( status );
268 }
269
270
271 /******************************************************************************
272 * VMM_RegOpenKeyExA
273 */
274 DWORD WINAPI VMM_RegOpenKeyExA(HKEY hkey, LPCSTR name, DWORD reserved, REGSAM access, PHKEY retkey)
275 {
276 OBJECT_ATTRIBUTES attr;
277 UNICODE_STRING nameW;
278 STRING nameA;
279 NTSTATUS status;
280
281 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
282
283 attr.Length = sizeof(attr);
284 attr.RootDirectory = hkey;
285 attr.ObjectName = &nameW;
286 attr.Attributes = 0;
287 attr.SecurityDescriptor = NULL;
288 attr.SecurityQualityOfService = NULL;
289
290 RtlInitAnsiString( &nameA, name );
291 if (!(status = RtlAnsiStringToUnicodeString( &nameW, &nameA, TRUE )))
292 {
293 status = NtOpenKey( retkey, access, &attr );
294 RtlFreeUnicodeString( &nameW );
295 }
296 return RtlNtStatusToDosError( status );
297 }
298
299
300 /******************************************************************************
301 * VMM_RegCloseKey
302 */
303 static DWORD VMM_RegCloseKey( HKEY hkey )
304 {
305 if (!hkey || hkey >= (HKEY)0x80000000) return ERROR_SUCCESS;
306 return RtlNtStatusToDosError( NtClose( hkey ) );
307 }
308
309 /******************************************************************************
310 * VMM_RegFlushKey
311 */
312 static DWORD VMM_RegFlushKey( HKEY hkey )
313 {
314 return RtlNtStatusToDosError( NtFlushKey( hkey ) );
315 }
316
317
318 /******************************************************************************
319 * VMM_RegDeleteKeyA
320 */
321 static DWORD VMM_RegDeleteKeyA( HKEY hkey, LPCSTR name )
322 {
323 DWORD ret;
324 HKEY tmp;
325
326 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
327
328 if (!name || !*name) return RtlNtStatusToDosError( NtDeleteKey( hkey ) );
329 if (!(ret = VMM_RegOpenKeyExA( hkey, name, 0, 0, &tmp )))
330 {
331 ret = RtlNtStatusToDosError( NtDeleteKey( tmp ) );
332 NtClose( tmp );
333 }
334 return ret;
335 }
336
337
338 /******************************************************************************
339 * VMM_RegSetValueExA
340 */
341 static DWORD VMM_RegSetValueExA( HKEY hkey, LPCSTR name, DWORD reserved, DWORD type,
342 CONST BYTE *data, DWORD count )
343 {
344 UNICODE_STRING nameW;
345 ANSI_STRING nameA;
346 WCHAR *dataW = NULL;
347 NTSTATUS status;
348
349 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
350
351 if (is_string(type))
352 {
353 DWORD lenW;
354
355 if (count)
356 {
357 /* if user forgot to count terminating null, add it (yes NT does this) */
358 if (data[count-1] && !data[count]) count++;
359 }
360 RtlMultiByteToUnicodeSize( &lenW, data, count );
361 if (!(dataW = HeapAlloc( GetProcessHeap(), 0, lenW ))) return ERROR_OUTOFMEMORY;
362 RtlMultiByteToUnicodeN( dataW, lenW, NULL, data, count );
363 count = lenW;
364 data = (BYTE *)dataW;
365 }
366
367 RtlInitAnsiString( &nameA, name );
368 if (!(status = RtlAnsiStringToUnicodeString( &nameW, &nameA, TRUE )))
369 {
370 status = NtSetValueKey( hkey, &nameW, 0, type, data, count );
371 RtlFreeUnicodeString( &nameW );
372 }
373 if (dataW) HeapFree( GetProcessHeap(), 0, dataW );
374 return RtlNtStatusToDosError( status );
375 }
376
377
378 /******************************************************************************
379 * VMM_RegSetValueA
380 */
381 static DWORD VMM_RegSetValueA( HKEY hkey, LPCSTR name, DWORD type, LPCSTR data, DWORD count )
382 {
383 HKEY subkey = hkey;
384 DWORD ret;
385
386 if (type != REG_SZ) return ERROR_INVALID_PARAMETER;
387
388 if (name && name[0]) /* need to create the subkey */
389 {
390 if ((ret = VMM_RegCreateKeyA( hkey, name, &subkey )) != ERROR_SUCCESS) return ret;
391 }
392 ret = VMM_RegSetValueExA( subkey, NULL, 0, REG_SZ, (LPBYTE)data, strlen(data)+1 );
393 if (subkey != hkey) NtClose( subkey );
394 return ret;
395 }
396
397
398 /******************************************************************************
399 * VMM_RegDeleteValueA
400 */
401 static DWORD VMM_RegDeleteValueA( HKEY hkey, LPCSTR name )
402 {
403 UNICODE_STRING nameW;
404 STRING nameA;
405 NTSTATUS status;
406
407 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
408
409 RtlInitAnsiString( &nameA, name );
410 if (!(status = RtlAnsiStringToUnicodeString( &nameW, &nameA, TRUE )))
411 {
412 status = NtDeleteValueKey( hkey, &nameW );
413 RtlFreeUnicodeString( &nameW );
414 }
415 return RtlNtStatusToDosError( status );
416 }
417
418
419 /******************************************************************************
420 * VMM_RegQueryValueExA
421 */
422 static DWORD VMM_RegQueryValueExA( HKEY hkey, LPCSTR name, LPDWORD reserved, LPDWORD type,
423 LPBYTE data, LPDWORD count )
424 {
425 NTSTATUS status;
426 ANSI_STRING nameA;
427 UNICODE_STRING nameW;
428 DWORD total_size;
429 char buffer[256], *buf_ptr = buffer;
430 KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)buffer;
431 static const int info_size = offsetof( KEY_VALUE_PARTIAL_INFORMATION, Data );
432
433 if ((data && !count) || reserved) return ERROR_INVALID_PARAMETER;
434 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
435
436 RtlInitAnsiString( &nameA, name );
437 if ((status = RtlAnsiStringToUnicodeString( &nameW, &nameA, TRUE )))
438 return RtlNtStatusToDosError(status);
439
440 status = NtQueryValueKey( hkey, &nameW, KeyValuePartialInformation,
441 buffer, sizeof(buffer), &total_size );
442 if (status && status != STATUS_BUFFER_OVERFLOW) goto done;
443
444 /* we need to fetch the contents for a string type even if not requested,
445 * because we need to compute the length of the ASCII string. */
446 if (data || is_string(info->Type))
447 {
448 /* retry with a dynamically allocated buffer */
449 while (status == STATUS_BUFFER_OVERFLOW)
450 {
451 if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
452 if (!(buf_ptr = HeapAlloc( GetProcessHeap(), 0, total_size )))
453 {
454 status = STATUS_NO_MEMORY;
455 goto done;
456 }
457 info = (KEY_VALUE_PARTIAL_INFORMATION *)buf_ptr;
458 status = NtQueryValueKey( hkey, &nameW, KeyValuePartialInformation,
459 buf_ptr, total_size, &total_size );
460 }
461
462 if (!status)
463 {
464 if (is_string(info->Type))
465 {
466 DWORD len = WideCharToMultiByte( CP_ACP, 0, (WCHAR *)(buf_ptr + info_size),
467 (total_size - info_size) /sizeof(WCHAR),
468 NULL, 0, NULL, NULL );
469 if (data && len)
470 {
471 if (len > *count) status = STATUS_BUFFER_OVERFLOW;
472 else
473 {
474 WideCharToMultiByte( CP_ACP, 0, (WCHAR *)(buf_ptr + info_size),
475 (total_size - info_size) /sizeof(WCHAR),
476 data, len, NULL, NULL );
477 /* if the type is REG_SZ and data is not 0-terminated
478 * and there is enough space in the buffer NT appends a \0 */
479 if (len < *count && data[len-1]) data[len] = 0;
480 }
481 }
482 total_size = len + info_size;
483 }
484 else if (data)
485 {
486 if (total_size - info_size > *count) status = STATUS_BUFFER_OVERFLOW;
487 else memcpy( data, buf_ptr + info_size, total_size - info_size );
488 }
489 }
490 else if (status != STATUS_BUFFER_OVERFLOW) goto done;
491 }
492
493 if (type) *type = info->Type;
494 if (count) *count = total_size - info_size;
495
496 done:
497 if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
498 RtlFreeUnicodeString( &nameW );
499 return RtlNtStatusToDosError(status);
500 }
501
502
503 /******************************************************************************
504 * VMM_RegQueryValueA
505 */
506 static DWORD VMM_RegQueryValueA( HKEY hkey, LPCSTR name, LPSTR data, LPLONG count )
507 {
508 DWORD ret;
509 HKEY subkey = hkey;
510
511 if (name && name[0])
512 {
513 if ((ret = VMM_RegOpenKeyExA( hkey, name, 0, KEY_ALL_ACCESS, &subkey )) != ERROR_SUCCESS)
514 return ret;
515 }
516 ret = VMM_RegQueryValueExA( subkey, NULL, NULL, NULL, (LPBYTE)data, count );
517 if (subkey != hkey) NtClose( subkey );
518 if (ret == ERROR_FILE_NOT_FOUND)
519 {
520 /* return empty string if default value not found */
521 if (data) *data = 0;
522 if (count) *count = 1;
523 ret = ERROR_SUCCESS;
524 }
525 return ret;
526 }
527
528
529 /******************************************************************************
530 * VMM_RegEnumValueA
531 */
532 static DWORD VMM_RegEnumValueA( HKEY hkey, DWORD index, LPSTR value, LPDWORD val_count,
533 LPDWORD reserved, LPDWORD type, LPBYTE data, LPDWORD count )
534 {
535 NTSTATUS status;
536 DWORD total_size;
537 char buffer[256], *buf_ptr = buffer;
538 KEY_VALUE_FULL_INFORMATION *info = (KEY_VALUE_FULL_INFORMATION *)buffer;
539 static const int info_size = offsetof( KEY_VALUE_FULL_INFORMATION, Name );
540
541 TRACE("(%p,%ld,%p,%p,%p,%p,%p,%p)\n",
542 hkey, index, value, val_count, reserved, type, data, count );
543
544 /* NT only checks count, not val_count */
545 if ((data && !count) || reserved) return ERROR_INVALID_PARAMETER;
546 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
547
548 total_size = info_size + (MAX_PATH + 1) * sizeof(WCHAR);
549 if (data) total_size += *count;
550 total_size = min( sizeof(buffer), total_size );
551
552 status = NtEnumerateValueKey( hkey, index, KeyValueFullInformation,
553 buffer, total_size, &total_size );
554 if (status && status != STATUS_BUFFER_OVERFLOW) goto done;
555
556 /* we need to fetch the contents for a string type even if not requested,
557 * because we need to compute the length of the ASCII string. */
558 if (value || data || is_string(info->Type))
559 {
560 /* retry with a dynamically allocated buffer */
561 while (status == STATUS_BUFFER_OVERFLOW)
562 {
563 if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
564 if (!(buf_ptr = HeapAlloc( GetProcessHeap(), 0, total_size )))
565 return ERROR_NOT_ENOUGH_MEMORY;
566 info = (KEY_VALUE_FULL_INFORMATION *)buf_ptr;
567 status = NtEnumerateValueKey( hkey, index, KeyValueFullInformation,
568 buf_ptr, total_size, &total_size );
569 }
570
571 if (status) goto done;
572
573 if (is_string(info->Type))
574 {
575 DWORD len;
576 RtlUnicodeToMultiByteSize( &len, (WCHAR *)(buf_ptr + info->DataOffset),
577 total_size - info->DataOffset );
578 if (data && len)
579 {
580 if (len > *count) status = STATUS_BUFFER_OVERFLOW;
581 else
582 {
583 RtlUnicodeToMultiByteN( data, len, NULL, (WCHAR *)(buf_ptr + info->DataOffset),
584 total_size - info->DataOffset );
585 /* if the type is REG_SZ and data is not 0-terminated
586 * and there is enough space in the buffer NT appends a \0 */
587 if (len < *count && data[len-1]) data[len] = 0;
588 }
589 }
590 info->DataLength = len;
591 }
592 else if (data)
593 {
594 if (total_size - info->DataOffset > *count) status = STATUS_BUFFER_OVERFLOW;
595 else memcpy( data, buf_ptr + info->DataOffset, total_size - info->DataOffset );
596 }
597
598 if (value && !status)
599 {
600 DWORD len;
601
602 RtlUnicodeToMultiByteSize( &len, info->Name, info->NameLength );
603 if (len >= *val_count)
604 {
605 status = STATUS_BUFFER_OVERFLOW;
606 if (*val_count)
607 {
608 len = *val_count - 1;
609 RtlUnicodeToMultiByteN( value, len, NULL, info->Name, info->NameLength );
610 value[len] = 0;
611 }
612 }
613 else
614 {
615 RtlUnicodeToMultiByteN( value, len, NULL, info->Name, info->NameLength );
616 value[len] = 0;
617 *val_count = len;
618 }
619 }
620 }
621 else status = STATUS_SUCCESS;
622
623 if (type) *type = info->Type;
624 if (count) *count = info->DataLength;
625
626 done:
627 if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
628 return RtlNtStatusToDosError(status);
629 }
630
631
632 /******************************************************************************
633 * VMM_RegEnumKeyA
634 */
635 static DWORD VMM_RegEnumKeyA( HKEY hkey, DWORD index, LPSTR name, DWORD name_len )
636 {
637 NTSTATUS status;
638 char buffer[256], *buf_ptr = buffer;
639 KEY_NODE_INFORMATION *info = (KEY_NODE_INFORMATION *)buffer;
640 DWORD total_size;
641
642 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
643
644 status = NtEnumerateKey( hkey, index, KeyNodeInformation,
645 buffer, sizeof(buffer), &total_size );
646
647 while (status == STATUS_BUFFER_OVERFLOW)
648 {
649 /* retry with a dynamically allocated buffer */
650 if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
651 if (!(buf_ptr = HeapAlloc( GetProcessHeap(), 0, total_size )))
652 return ERROR_NOT_ENOUGH_MEMORY;
653 info = (KEY_NODE_INFORMATION *)buf_ptr;
654 status = NtEnumerateKey( hkey, index, KeyNodeInformation,
655 buf_ptr, total_size, &total_size );
656 }
657
658 if (!status)
659 {
660 DWORD len;
661
662 RtlUnicodeToMultiByteSize( &len, info->Name, info->NameLength );
663 if (len >= name_len) status = STATUS_BUFFER_OVERFLOW;
664 else
665 {
666 RtlUnicodeToMultiByteN( name, len, NULL, info->Name, info->NameLength );
667 name[len] = 0;
668 }
669 }
670
671 if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
672 return RtlNtStatusToDosError( status );
673 }
674
675
676 /******************************************************************************
677 * VMM_RegQueryInfoKeyA
678 *
679 * NOTE: This VxDCall takes only a subset of the parameters that the
680 * corresponding Win32 API call does. The implementation in Win95
681 * ADVAPI32 sets all output parameters not mentioned here to zero.
682 */
683 static DWORD VMM_RegQueryInfoKeyA( HKEY hkey, LPDWORD subkeys, LPDWORD max_subkey,
684 LPDWORD values, LPDWORD max_value, LPDWORD max_data )
685 {
686 NTSTATUS status;
687 KEY_FULL_INFORMATION info;
688 DWORD total_size;
689
690 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
691
692 status = NtQueryKey( hkey, KeyFullInformation, &info, sizeof(info), &total_size );
693 if (status && status != STATUS_BUFFER_OVERFLOW) return RtlNtStatusToDosError( status );
694
695 if (subkeys) *subkeys = info.SubKeys;
696 if (max_subkey) *max_subkey = info.MaxNameLen;
697 if (values) *values = info.Values;
698 if (max_value) *max_value = info.MaxValueNameLen;
699 if (max_data) *max_data = info.MaxValueDataLen;
700 return ERROR_SUCCESS;
701 }
702
703
704 /***********************************************************************
705 * VxDCall_VMM
706 */
707 static DWORD VxDCall_VMM( DWORD service, CONTEXT86 *context )
708 {
709 switch ( LOWORD(service) )
710 {
711 case 0x0011: /* RegOpenKey */
712 {
713 HKEY hkey = (HKEY) stack32_pop( context );
714 LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
715 PHKEY retkey = (PHKEY)stack32_pop( context );
716 return VMM_RegOpenKeyExA( hkey, lpszSubKey, 0, KEY_ALL_ACCESS, retkey );
717 }
718
719 case 0x0012: /* RegCreateKey */
720 {
721 HKEY hkey = (HKEY) stack32_pop( context );
722 LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
723 PHKEY retkey = (PHKEY)stack32_pop( context );
724 return VMM_RegCreateKeyA( hkey, lpszSubKey, retkey );
725 }
726
727 case 0x0013: /* RegCloseKey */
728 {
729 HKEY hkey = (HKEY)stack32_pop( context );
730 return VMM_RegCloseKey( hkey );
731 }
732
733 case 0x0014: /* RegDeleteKey */
734 {
735 HKEY hkey = (HKEY) stack32_pop( context );
736 LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
737 return VMM_RegDeleteKeyA( hkey, lpszSubKey );
738 }
739
740 case 0x0015: /* RegSetValue */
741 {
742 HKEY hkey = (HKEY) stack32_pop( context );
743 LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
744 DWORD dwType = (DWORD) stack32_pop( context );
745 LPCSTR lpszData = (LPCSTR)stack32_pop( context );
746 DWORD cbData = (DWORD) stack32_pop( context );
747 return VMM_RegSetValueA( hkey, lpszSubKey, dwType, lpszData, cbData );
748 }
749
750 case 0x0016: /* RegDeleteValue */
751 {
752 HKEY hkey = (HKEY) stack32_pop( context );
753 LPSTR lpszValue = (LPSTR)stack32_pop( context );
754 return VMM_RegDeleteValueA( hkey, lpszValue );
755 }
756
757 case 0x0017: /* RegQueryValue */
758 {
759 HKEY hkey = (HKEY) stack32_pop( context );
760 LPSTR lpszSubKey = (LPSTR) stack32_pop( context );
761 LPSTR lpszData = (LPSTR) stack32_pop( context );
762 LPDWORD lpcbData = (LPDWORD)stack32_pop( context );
763 return VMM_RegQueryValueA( hkey, lpszSubKey, lpszData, lpcbData );
764 }
765
766 case 0x0018: /* RegEnumKey */
767 {
768 HKEY hkey = (HKEY) stack32_pop( context );
769 DWORD iSubkey = (DWORD)stack32_pop( context );
770 LPSTR lpszName = (LPSTR)stack32_pop( context );
771 DWORD lpcchName = (DWORD)stack32_pop( context );
772 return VMM_RegEnumKeyA( hkey, iSubkey, lpszName, lpcchName );
773 }
774
775 case 0x0019: /* RegEnumValue */
776 {
777 HKEY hkey = (HKEY) stack32_pop( context );
778 DWORD iValue = (DWORD) stack32_pop( context );
779 LPSTR lpszValue = (LPSTR) stack32_pop( context );
780 LPDWORD lpcchValue = (LPDWORD)stack32_pop( context );
781 LPDWORD lpReserved = (LPDWORD)stack32_pop( context );
782 LPDWORD lpdwType = (LPDWORD)stack32_pop( context );
783 LPBYTE lpbData = (LPBYTE) stack32_pop( context );
784 LPDWORD lpcbData = (LPDWORD)stack32_pop( context );
785 return VMM_RegEnumValueA( hkey, iValue, lpszValue, lpcchValue,
786 lpReserved, lpdwType, lpbData, lpcbData );
787 }
788
789 case 0x001A: /* RegQueryValueEx */
790 {
791 HKEY hkey = (HKEY) stack32_pop( context );
792 LPSTR lpszValue = (LPSTR) stack32_pop( context );
793 LPDWORD lpReserved = (LPDWORD)stack32_pop( context );
794 LPDWORD lpdwType = (LPDWORD)stack32_pop( context );
795 LPBYTE lpbData = (LPBYTE) stack32_pop( context );
796 LPDWORD lpcbData = (LPDWORD)stack32_pop( context );
797 return VMM_RegQueryValueExA( hkey, lpszValue, lpReserved,
798 lpdwType, lpbData, lpcbData );
799 }
800
801 case 0x001B: /* RegSetValueEx */
802 {
803 HKEY hkey = (HKEY) stack32_pop( context );
804 LPSTR lpszValue = (LPSTR) stack32_pop( context );
805 DWORD dwReserved = (DWORD) stack32_pop( context );
806 DWORD dwType = (DWORD) stack32_pop( context );
807 LPBYTE lpbData = (LPBYTE)stack32_pop( context );
808 DWORD cbData = (DWORD) stack32_pop( context );
809 return VMM_RegSetValueExA( hkey, lpszValue, dwReserved,
810 dwType, lpbData, cbData );
811 }
812
813 case 0x001C: /* RegFlushKey */
814 {
815 HKEY hkey = (HKEY)stack32_pop( context );
816 return VMM_RegFlushKey( hkey );
817 }
818
819 case 0x001D: /* RegQueryInfoKey */
820 {
821 /* NOTE: This VxDCall takes only a subset of the parameters that the
822 corresponding Win32 API call does. The implementation in Win95
823 ADVAPI32 sets all output parameters not mentioned here to zero. */
824
825 HKEY hkey = (HKEY) stack32_pop( context );
826 LPDWORD lpcSubKeys = (LPDWORD)stack32_pop( context );
827 LPDWORD lpcchMaxSubKey = (LPDWORD)stack32_pop( context );
828 LPDWORD lpcValues = (LPDWORD)stack32_pop( context );
829 LPDWORD lpcchMaxValueName = (LPDWORD)stack32_pop( context );
830 LPDWORD lpcchMaxValueData = (LPDWORD)stack32_pop( context );
831 return VMM_RegQueryInfoKeyA( hkey, lpcSubKeys, lpcchMaxSubKey,
832 lpcValues, lpcchMaxValueName, lpcchMaxValueData );
833 }
834
835 case 0x0021: /* RegLoadKey */
836 {
837 HKEY hkey = (HKEY) stack32_pop( context );
838 LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
839 LPCSTR lpszFile = (LPCSTR)stack32_pop( context );
840 FIXME("RegLoadKey(%p,%s,%s): stub\n",hkey, debugstr_a(lpszSubKey), debugstr_a(lpszFile));
841 return ERROR_SUCCESS;
842 }
843
844 case 0x0022: /* RegUnLoadKey */
845 {
846 HKEY hkey = (HKEY) stack32_pop( context );
847 LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
848 FIXME("RegUnLoadKey(%p,%s): stub\n",hkey, debugstr_a(lpszSubKey));
849 return ERROR_SUCCESS;
850 }
851
852 case 0x0023: /* RegSaveKey */
853 {
854 HKEY hkey = (HKEY) stack32_pop( context );
855 LPCSTR lpszFile = (LPCSTR)stack32_pop( context );
856 LPSECURITY_ATTRIBUTES sa = (LPSECURITY_ATTRIBUTES)stack32_pop( context );
857 FIXME("RegSaveKey(%p,%s,%p): stub\n",hkey, debugstr_a(lpszFile),sa);
858 return ERROR_SUCCESS;
859 }
860
861 #if 0 /* Functions are not yet implemented in misc/registry.c */
862 case 0x0024: /* RegRemapPreDefKey */
863 case 0x0026: /* RegQueryMultipleValues */
864 #endif
865
866 case 0x0027: /* RegReplaceKey */
867 {
868 HKEY hkey = (HKEY) stack32_pop( context );
869 LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
870 LPCSTR lpszNewFile= (LPCSTR)stack32_pop( context );
871 LPCSTR lpszOldFile= (LPCSTR)stack32_pop( context );
872 FIXME("RegReplaceKey(%p,%s,%s,%s): stub\n", hkey, debugstr_a(lpszSubKey),
873 debugstr_a(lpszNewFile),debugstr_a(lpszOldFile));
874 return ERROR_SUCCESS;
875 }
876
877 case 0x0000: /* PageReserve */
878 {
879 LPVOID address;
880 LPVOID ret;
881 DWORD psize = getpagesize();
882 ULONG page = (ULONG) stack32_pop( context );
883 ULONG npages = (ULONG) stack32_pop( context );
884 ULONG flags = (ULONG) stack32_pop( context );
885
886 TRACE("PageReserve: page: %08lx, npages: %08lx, flags: %08lx partial stub!\n",
887 page, npages, flags );
888
889 if ( page == PR_SYSTEM ) {
890 ERR("Can't reserve ring 1 memory\n");
891 return -1;
892 }
893 /* FIXME: This has to be handled separately for the separate
894 address-spaces we now have */
895 if ( page == PR_PRIVATE || page == PR_SHARED ) page = 0;
896 /* FIXME: Handle flags in some way */
897 address = (LPVOID )(page * psize);
898 ret = VirtualAlloc ( address, ( npages * psize ), MEM_RESERVE, 0 );
899 TRACE("PageReserve: returning: %08lx\n", (DWORD )ret );
900 if ( ret == NULL )
901 return -1;
902 else
903 return (DWORD )ret;
904 }
905
906 case 0x0001: /* PageCommit */
907 {
908 LPVOID address;
909 LPVOID ret;
910 DWORD virt_perm;
911 DWORD psize = getpagesize();
912 ULONG page = (ULONG) stack32_pop( context );
913 ULONG npages = (ULONG) stack32_pop( context );
914 ULONG hpd = (ULONG) stack32_pop( context );
915 ULONG pagerdata = (ULONG) stack32_pop( context );
916 ULONG flags = (ULONG) stack32_pop( context );
917
918 TRACE("PageCommit: page: %08lx, npages: %08lx, hpd: %08lx pagerdata: "
919 "%08lx, flags: %08lx partial stub\n",
920 page, npages, hpd, pagerdata, flags );
921
922 if ( flags & PC_USER )
923 if ( flags & PC_WRITEABLE )
924 virt_perm = PAGE_EXECUTE_READWRITE;
925 else
926 virt_perm = PAGE_EXECUTE_READ;
927 else
928 virt_perm = PAGE_NOACCESS;
929
930 address = (LPVOID )(page * psize);
931 ret = VirtualAlloc ( address, ( npages * psize ), MEM_COMMIT, virt_perm );
932 TRACE("PageCommit: Returning: %08lx\n", (DWORD )ret );
933 return (DWORD )ret;
934
935 }
936 case 0x0002: /* PageDecommit */
937 {
938 LPVOID address;
939 BOOL ret;
940 DWORD psize = getpagesize();
941 ULONG page = (ULONG) stack32_pop( context );
942 ULONG npages = (ULONG) stack32_pop( context );
943 ULONG flags = (ULONG) stack32_pop( context );
944
945 TRACE("PageDecommit: page: %08lx, npages: %08lx, flags: %08lx partial stub\n",
946 page, npages, flags );
947 address = (LPVOID )( page * psize );
948 ret = VirtualFree ( address, ( npages * psize ), MEM_DECOMMIT );
949 TRACE("PageDecommit: Returning: %s\n", ret ? "TRUE" : "FALSE" );
950 return ret;
951 }
952 case 0x000d: /* PageModifyPermissions */
953 {
954 DWORD pg_old_perm;
955 DWORD pg_new_perm;
956 DWORD virt_old_perm;
957 DWORD virt_new_perm;
958 MEMORY_BASIC_INFORMATION mbi;
959 LPVOID address;
960 DWORD psize = getpagesize();
961 ULONG page = stack32_pop ( context );
962 ULONG npages = stack32_pop ( context );
963 ULONG permand = stack32_pop ( context );
964 ULONG permor = stack32_pop ( context );
965
966 TRACE("PageModifyPermissions %08lx %08lx %08lx %08lx partial stub\n",
967 page, npages, permand, permor );
968 address = (LPVOID )( page * psize );
969
970 VirtualQuery ( address, &mbi, sizeof ( MEMORY_BASIC_INFORMATION ));
971 virt_old_perm = mbi.Protect;
972
973 switch ( virt_old_perm & mbi.Protect ) {
974 case PAGE_READONLY:
975 case PAGE_EXECUTE:
976 case PAGE_EXECUTE_READ:
977 pg_old_perm = PC_USER;
978 break;
979 case PAGE_READWRITE:
980 case PAGE_WRITECOPY:
981 case PAGE_EXECUTE_READWRITE:
982 case PAGE_EXECUTE_WRITECOPY:
983 pg_old_perm = PC_USER | PC_WRITEABLE;
984 break;
985 case PAGE_NOACCESS:
986 default:
987 pg_old_perm = 0;
988 break;
989 }
990 pg_new_perm = pg_old_perm;
991 pg_new_perm &= permand & ~PC_STATIC;
992 pg_new_perm |= permor & ~PC_STATIC;
993
994 virt_new_perm = ( virt_old_perm ) & ~0xff;
995 if ( pg_new_perm & PC_USER )
996 {
997 if ( pg_new_perm & PC_WRITEABLE )
998 virt_new_perm |= PAGE_EXECUTE_READWRITE;
999 else
1000 virt_new_perm |= PAGE_EXECUTE_READ;
1001 }
1002
1003 if ( ! VirtualProtect ( address, ( npages * psize ), virt_new_perm, &virt_old_perm ) ) {
1004 ERR("Can't change page permissions for %08lx\n", (DWORD )address );
1005 return 0xffffffff;
1006 }
1007 TRACE("Returning: %08lx\n", pg_old_perm );
1008 return pg_old_perm;
1009 }
1010 case 0x000a: /* PageFree */
1011 {
1012 BOOL ret;
1013 LPVOID hmem = (LPVOID) stack32_pop( context );
1014 DWORD flags = (DWORD ) stack32_pop( context );
1015
1016 TRACE("PageFree: hmem: %08lx, flags: %08lx partial stub\n",
1017 (DWORD )hmem, flags );
1018
1019 ret = VirtualFree ( hmem, 0, MEM_RELEASE );
1020 context->Eax = ret;
1021 TRACE("Returning: %d\n", ret );
1022
1023 return 0;
1024 }
1025 case 0x001e: /* GetDemandPageInfo */
1026 {
1027 DWORD dinfo = (DWORD)stack32_pop( context );
1028 DWORD flags = (DWORD)stack32_pop( context );
1029
1030 /* GetDemandPageInfo is supposed to fill out the struct at
1031 * "dinfo" with various low-level memory management information.
1032 * Apps are certainly not supposed to call this, although it's
1033 * demoed and documented by Pietrek on pages 441-443 of "Windows
1034 * 95 System Programming Secrets" if any program needs a real
1035 * implementation of this.
1036 */
1037
1038 FIXME("GetDemandPageInfo(%08lx %08lx): stub!\n", dinfo, flags);
1039
1040 return 0;
1041 }
1042 default:
1043 if (LOWORD(service) < N_VMM_SERVICE)
1044 FIXME( "Unimplemented service %s (%08lx)\n",
1045 VMM_Service_Name[LOWORD(service)], service);
1046 else
1047 FIXME( "Unknown service %08lx\n", service);
1048 break;
1049 }
1050
1051 return 0xffffffff; /* FIXME */
1052 }
1053
1054
1055 /********************************************************************************
1056 * VxDCall_VWin32
1057 *
1058 * Service numbers taken from page 448 of Pietrek's "Windows 95 System
1059 * Programming Secrets". Parameters from experimentation on real Win98.
1060 *
1061 */
1062
1063 static DWORD VxDCall_VWin32( DWORD service, CONTEXT86 *context )
1064 {
1065 switch ( LOWORD(service) )
1066 {
1067 case 0x0000: /* GetVersion */
1068 {
1069 DWORD vers = GetVersion();
1070 return (LOBYTE(vers) << 8) | HIBYTE(vers);
1071 }
1072 break;
1073
1074 case 0x0020: /* Get VMCPD Version */
1075 {
1076 DWORD parm = (DWORD) stack32_pop(context);
1077
1078 FIXME("Get VMCPD Version(%08lx): partial stub!\n", parm);
1079
1080 /* FIXME: This is what Win98 returns, it may
1081 * not be correct in all situations.
1082 * It makes Bleem! happy though.
1083 */
1084
1085 return 0x0405;
1086 }
1087
1088 case 0x0029: /* Int31/DPMI dispatch */
1089 {
1090 DWORD callnum = (DWORD) stack32_pop(context);
1091 DWORD parm = (DWORD) stack32_pop(context);
1092
1093 TRACE("Int31/DPMI dispatch(%08lx)\n", callnum);
1094
1095 context->Eax = callnum;
1096 context->Ecx = parm;
1097 INSTR_CallBuiltinHandler( context, 0x31 );
1098
1099 return LOWORD(context->Eax);
1100 }
1101 break;
1102
1103 case 0x002a: /* Int41 dispatch - parm = int41 service number */
1104 {
1105 DWORD callnum = (DWORD) stack32_pop(context);
1106
1107 return callnum; /* FIXME: should really call INT_Int41Handler() */
1108 }
1109 break;
1110
1111 default:
1112 FIXME("Unknown VWin32 service %08lx\n", service);
1113 break;
1114 }
1115
1116 return 0xffffffff;
1117 }
1118
1119
1120 /***********************************************************************
1121 * VxDCall0 (KERNEL32.1)
1122 * VxDCall1 (KERNEL32.2)
1123 * VxDCall2 (KERNEL32.3)
1124 * VxDCall3 (KERNEL32.4)
1125 * VxDCall4 (KERNEL32.5)
1126 * VxDCall5 (KERNEL32.6)
1127 * VxDCall6 (KERNEL32.7)
1128 * VxDCall7 (KERNEL32.8)
1129 * VxDCall8 (KERNEL32.9)
1130 */
1131 void VxDCall( DWORD service, CONTEXT86 *context )
1132 {
1133 DWORD ret;
1134
1135 TRACE( "(%08lx, ...)\n", service);
1136
1137 switch(HIWORD(service))
1138 {
1139 case 0x0001: /* VMM */
1140 ret = VxDCall_VMM( service, context );
1141 break;
1142 case 0x002a: /* VWIN32 */
1143 ret = VxDCall_VWin32( service, context );
1144 break;
1145 default:
1146 FIXME( "Unknown/unimplemented VxD (%08lx)\n", service);
1147 ret = 0xffffffff; /* FIXME */
1148 break;
1149 }
1150 context->Eax = ret;
1151 }
1152
1153
1154 /***********************************************************************
1155 * OpenVxDHandle (KERNEL32.@)
1156 *
1157 * This function is supposed to return the corresponding Ring 0
1158 * ("kernel") handle for a Ring 3 handle in Win9x.
1159 * Evidently, Wine will have problems with this. But we try anyway,
1160 * maybe it helps...
1161 */
1162 HANDLE WINAPI OpenVxDHandle(HANDLE hHandleRing3)
1163 {
1164 FIXME( "(%p), stub! (returning Ring 3 handle instead of Ring 0)\n", hHandleRing3);
1165 return hHandleRing3;
1166 }
Windows API implementation