?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add LanguageGroup/GeoID enumeration fns.
[wine/hacks.git] / dlls / kernel / vxd.c
blobdc2db836640b97a57e11c815f3c94a98301512e1
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 "miscemu.h"
43 #include "callback.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 /******************************************************************************
311 * VMM_RegDeleteKeyA
312 */
313 static DWORD VMM_RegDeleteKeyA( HKEY hkey, LPCSTR name )
314 {
315 DWORD ret;
316 HKEY tmp;
317
318 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
319
320 if (!name || !*name) return RtlNtStatusToDosError( NtDeleteKey( hkey ) );
321 if (!(ret = VMM_RegOpenKeyExA( hkey, name, 0, 0, &tmp )))
322 {
323 ret = RtlNtStatusToDosError( NtDeleteKey( tmp ) );
324 NtClose( tmp );
325 }
326 return ret;
327 }
328
329
330 /******************************************************************************
331 * VMM_RegSetValueExA
332 */
333 static DWORD VMM_RegSetValueExA( HKEY hkey, LPCSTR name, DWORD reserved, DWORD type,
334 CONST BYTE *data, DWORD count )
335 {
336 UNICODE_STRING nameW;
337 ANSI_STRING nameA;
338 WCHAR *dataW = NULL;
339 NTSTATUS status;
340
341 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
342
343 if (is_string(type))
344 {
345 DWORD lenW;
346
347 if (count)
348 {
349 /* if user forgot to count terminating null, add it (yes NT does this) */
350 if (data[count-1] && !data[count]) count++;
351 }
352 RtlMultiByteToUnicodeSize( &lenW, data, count );
353 if (!(dataW = HeapAlloc( GetProcessHeap(), 0, lenW ))) return ERROR_OUTOFMEMORY;
354 RtlMultiByteToUnicodeN( dataW, lenW, NULL, data, count );
355 count = lenW;
356 data = (BYTE *)dataW;
357 }
358
359 RtlInitAnsiString( &nameA, name );
360 if (!(status = RtlAnsiStringToUnicodeString( &nameW, &nameA, TRUE )))
361 {
362 status = NtSetValueKey( hkey, &nameW, 0, type, data, count );
363 RtlFreeUnicodeString( &nameW );
364 }
365 if (dataW) HeapFree( GetProcessHeap(), 0, dataW );
366 return RtlNtStatusToDosError( status );
367 }
368
369
370 /******************************************************************************
371 * VMM_RegSetValueA
372 */
373 static DWORD VMM_RegSetValueA( HKEY hkey, LPCSTR name, DWORD type, LPCSTR data, DWORD count )
374 {
375 HKEY subkey = hkey;
376 DWORD ret;
377
378 if (type != REG_SZ) return ERROR_INVALID_PARAMETER;
379
380 if (name && name[0]) /* need to create the subkey */
381 {
382 if ((ret = VMM_RegCreateKeyA( hkey, name, &subkey )) != ERROR_SUCCESS) return ret;
383 }
384 ret = VMM_RegSetValueExA( subkey, NULL, 0, REG_SZ, (LPBYTE)data, strlen(data)+1 );
385 if (subkey != hkey) NtClose( subkey );
386 return ret;
387 }
388
389
390 /******************************************************************************
391 * VMM_RegDeleteValueA
392 */
393 static DWORD VMM_RegDeleteValueA( HKEY hkey, LPCSTR name )
394 {
395 UNICODE_STRING nameW;
396 STRING nameA;
397 NTSTATUS status;
398
399 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
400
401 RtlInitAnsiString( &nameA, name );
402 if (!(status = RtlAnsiStringToUnicodeString( &nameW, &nameA, TRUE )))
403 {
404 status = NtDeleteValueKey( hkey, &nameW );
405 RtlFreeUnicodeString( &nameW );
406 }
407 return RtlNtStatusToDosError( status );
408 }
409
410
411 /******************************************************************************
412 * VMM_RegQueryValueExA
413 */
414 static DWORD VMM_RegQueryValueExA( HKEY hkey, LPCSTR name, LPDWORD reserved, LPDWORD type,
415 LPBYTE data, LPDWORD count )
416 {
417 NTSTATUS status;
418 ANSI_STRING nameA;
419 UNICODE_STRING nameW;
420 DWORD total_size;
421 char buffer[256], *buf_ptr = buffer;
422 KEY_VALUE_PARTIAL_INFORMATION *info = (KEY_VALUE_PARTIAL_INFORMATION *)buffer;
423 static const int info_size = offsetof( KEY_VALUE_PARTIAL_INFORMATION, Data );
424
425 if ((data && !count) || reserved) return ERROR_INVALID_PARAMETER;
426 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
427
428 RtlInitAnsiString( &nameA, name );
429 if ((status = RtlAnsiStringToUnicodeString( &nameW, &nameA, TRUE )))
430 return RtlNtStatusToDosError(status);
431
432 status = NtQueryValueKey( hkey, &nameW, KeyValuePartialInformation,
433 buffer, sizeof(buffer), &total_size );
434 if (status && status != STATUS_BUFFER_OVERFLOW) goto done;
435
436 /* we need to fetch the contents for a string type even if not requested,
437 * because we need to compute the length of the ASCII string. */
438 if (data || is_string(info->Type))
439 {
440 /* retry with a dynamically allocated buffer */
441 while (status == STATUS_BUFFER_OVERFLOW)
442 {
443 if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
444 if (!(buf_ptr = HeapAlloc( GetProcessHeap(), 0, total_size )))
445 {
446 status = STATUS_NO_MEMORY;
447 goto done;
448 }
449 info = (KEY_VALUE_PARTIAL_INFORMATION *)buf_ptr;
450 status = NtQueryValueKey( hkey, &nameW, KeyValuePartialInformation,
451 buf_ptr, total_size, &total_size );
452 }
453
454 if (!status)
455 {
456 if (is_string(info->Type))
457 {
458 DWORD len = WideCharToMultiByte( CP_ACP, 0, (WCHAR *)(buf_ptr + info_size),
459 (total_size - info_size) /sizeof(WCHAR),
460 NULL, 0, NULL, NULL );
461 if (data && len)
462 {
463 if (len > *count) status = STATUS_BUFFER_OVERFLOW;
464 else
465 {
466 WideCharToMultiByte( CP_ACP, 0, (WCHAR *)(buf_ptr + info_size),
467 (total_size - info_size) /sizeof(WCHAR),
468 data, len, NULL, NULL );
469 /* if the type is REG_SZ and data is not 0-terminated
470 * and there is enough space in the buffer NT appends a \0 */
471 if (len < *count && data[len-1]) data[len] = 0;
472 }
473 }
474 total_size = len + info_size;
475 }
476 else if (data)
477 {
478 if (total_size - info_size > *count) status = STATUS_BUFFER_OVERFLOW;
479 else memcpy( data, buf_ptr + info_size, total_size - info_size );
480 }
481 }
482 else if (status != STATUS_BUFFER_OVERFLOW) goto done;
483 }
484
485 if (type) *type = info->Type;
486 if (count) *count = total_size - info_size;
487
488 done:
489 if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
490 RtlFreeUnicodeString( &nameW );
491 return RtlNtStatusToDosError(status);
492 }
493
494
495 /******************************************************************************
496 * VMM_RegQueryValueA
497 */
498 static DWORD VMM_RegQueryValueA( HKEY hkey, LPCSTR name, LPSTR data, LPLONG count )
499 {
500 DWORD ret;
501 HKEY subkey = hkey;
502
503 if (name && name[0])
504 {
505 if ((ret = VMM_RegOpenKeyExA( hkey, name, 0, KEY_ALL_ACCESS, &subkey )) != ERROR_SUCCESS)
506 return ret;
507 }
508 ret = VMM_RegQueryValueExA( subkey, NULL, NULL, NULL, (LPBYTE)data, count );
509 if (subkey != hkey) NtClose( subkey );
510 if (ret == ERROR_FILE_NOT_FOUND)
511 {
512 /* return empty string if default value not found */
513 if (data) *data = 0;
514 if (count) *count = 1;
515 ret = ERROR_SUCCESS;
516 }
517 return ret;
518 }
519
520
521 /******************************************************************************
522 * VMM_RegEnumValueA
523 */
524 static DWORD VMM_RegEnumValueA( HKEY hkey, DWORD index, LPSTR value, LPDWORD val_count,
525 LPDWORD reserved, LPDWORD type, LPBYTE data, LPDWORD count )
526 {
527 NTSTATUS status;
528 DWORD total_size;
529 char buffer[256], *buf_ptr = buffer;
530 KEY_VALUE_FULL_INFORMATION *info = (KEY_VALUE_FULL_INFORMATION *)buffer;
531 static const int info_size = offsetof( KEY_VALUE_FULL_INFORMATION, Name );
532
533 TRACE("(%p,%ld,%p,%p,%p,%p,%p,%p)\n",
534 hkey, index, value, val_count, reserved, type, data, count );
535
536 /* NT only checks count, not val_count */
537 if ((data && !count) || reserved) return ERROR_INVALID_PARAMETER;
538 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
539
540 total_size = info_size + (MAX_PATH + 1) * sizeof(WCHAR);
541 if (data) total_size += *count;
542 total_size = min( sizeof(buffer), total_size );
543
544 status = NtEnumerateValueKey( hkey, index, KeyValueFullInformation,
545 buffer, total_size, &total_size );
546 if (status && status != STATUS_BUFFER_OVERFLOW) goto done;
547
548 /* we need to fetch the contents for a string type even if not requested,
549 * because we need to compute the length of the ASCII string. */
550 if (value || data || is_string(info->Type))
551 {
552 /* retry with a dynamically allocated buffer */
553 while (status == STATUS_BUFFER_OVERFLOW)
554 {
555 if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
556 if (!(buf_ptr = HeapAlloc( GetProcessHeap(), 0, total_size )))
557 return ERROR_NOT_ENOUGH_MEMORY;
558 info = (KEY_VALUE_FULL_INFORMATION *)buf_ptr;
559 status = NtEnumerateValueKey( hkey, index, KeyValueFullInformation,
560 buf_ptr, total_size, &total_size );
561 }
562
563 if (status) goto done;
564
565 if (is_string(info->Type))
566 {
567 DWORD len;
568 RtlUnicodeToMultiByteSize( &len, (WCHAR *)(buf_ptr + info->DataOffset),
569 total_size - info->DataOffset );
570 if (data && len)
571 {
572 if (len > *count) status = STATUS_BUFFER_OVERFLOW;
573 else
574 {
575 RtlUnicodeToMultiByteN( data, len, NULL, (WCHAR *)(buf_ptr + info->DataOffset),
576 total_size - info->DataOffset );
577 /* if the type is REG_SZ and data is not 0-terminated
578 * and there is enough space in the buffer NT appends a \0 */
579 if (len < *count && data[len-1]) data[len] = 0;
580 }
581 }
582 info->DataLength = len;
583 }
584 else if (data)
585 {
586 if (total_size - info->DataOffset > *count) status = STATUS_BUFFER_OVERFLOW;
587 else memcpy( data, buf_ptr + info->DataOffset, total_size - info->DataOffset );
588 }
589
590 if (value && !status)
591 {
592 DWORD len;
593
594 RtlUnicodeToMultiByteSize( &len, info->Name, info->NameLength );
595 if (len >= *val_count)
596 {
597 status = STATUS_BUFFER_OVERFLOW;
598 if (*val_count)
599 {
600 len = *val_count - 1;
601 RtlUnicodeToMultiByteN( value, len, NULL, info->Name, info->NameLength );
602 value[len] = 0;
603 }
604 }
605 else
606 {
607 RtlUnicodeToMultiByteN( value, len, NULL, info->Name, info->NameLength );
608 value[len] = 0;
609 *val_count = len;
610 }
611 }
612 }
613 else status = STATUS_SUCCESS;
614
615 if (type) *type = info->Type;
616 if (count) *count = info->DataLength;
617
618 done:
619 if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
620 return RtlNtStatusToDosError(status);
621 }
622
623
624 /******************************************************************************
625 * VMM_RegEnumKeyA
626 */
627 static DWORD VMM_RegEnumKeyA( HKEY hkey, DWORD index, LPSTR name, DWORD name_len )
628 {
629 NTSTATUS status;
630 char buffer[256], *buf_ptr = buffer;
631 KEY_NODE_INFORMATION *info = (KEY_NODE_INFORMATION *)buffer;
632 DWORD total_size;
633
634 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
635
636 status = NtEnumerateKey( hkey, index, KeyNodeInformation,
637 buffer, sizeof(buffer), &total_size );
638
639 while (status == STATUS_BUFFER_OVERFLOW)
640 {
641 /* retry with a dynamically allocated buffer */
642 if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
643 if (!(buf_ptr = HeapAlloc( GetProcessHeap(), 0, total_size )))
644 return ERROR_NOT_ENOUGH_MEMORY;
645 info = (KEY_NODE_INFORMATION *)buf_ptr;
646 status = NtEnumerateKey( hkey, index, KeyNodeInformation,
647 buf_ptr, total_size, &total_size );
648 }
649
650 if (!status)
651 {
652 DWORD len;
653
654 RtlUnicodeToMultiByteSize( &len, info->Name, info->NameLength );
655 if (len >= name_len) status = STATUS_BUFFER_OVERFLOW;
656 else
657 {
658 RtlUnicodeToMultiByteN( name, len, NULL, info->Name, info->NameLength );
659 name[len] = 0;
660 }
661 }
662
663 if (buf_ptr != buffer) HeapFree( GetProcessHeap(), 0, buf_ptr );
664 return RtlNtStatusToDosError( status );
665 }
666
667
668 /******************************************************************************
669 * VMM_RegQueryInfoKeyA
670 *
671 * NOTE: This VxDCall takes only a subset of the parameters that the
672 * corresponding Win32 API call does. The implementation in Win95
673 * ADVAPI32 sets all output parameters not mentioned here to zero.
674 */
675 static DWORD VMM_RegQueryInfoKeyA( HKEY hkey, LPDWORD subkeys, LPDWORD max_subkey,
676 LPDWORD values, LPDWORD max_value, LPDWORD max_data )
677 {
678 NTSTATUS status;
679 KEY_FULL_INFORMATION info;
680 DWORD total_size;
681
682 if (!(hkey = get_special_root_hkey( hkey ))) return ERROR_INVALID_HANDLE;
683
684 status = NtQueryKey( hkey, KeyFullInformation, &info, sizeof(info), &total_size );
685 if (status && status != STATUS_BUFFER_OVERFLOW) return RtlNtStatusToDosError( status );
686
687 if (subkeys) *subkeys = info.SubKeys;
688 if (max_subkey) *max_subkey = info.MaxNameLen;
689 if (values) *values = info.Values;
690 if (max_value) *max_value = info.MaxValueNameLen;
691 if (max_data) *max_data = info.MaxValueDataLen;
692 return ERROR_SUCCESS;
693 }
694
695
696 /***********************************************************************
697 * VxDCall_VMM
698 */
699 static DWORD VxDCall_VMM( DWORD service, CONTEXT86 *context )
700 {
701 switch ( LOWORD(service) )
702 {
703 case 0x0011: /* RegOpenKey */
704 {
705 HKEY hkey = (HKEY) stack32_pop( context );
706 LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
707 PHKEY retkey = (PHKEY)stack32_pop( context );
708 return VMM_RegOpenKeyExA( hkey, lpszSubKey, 0, KEY_ALL_ACCESS, retkey );
709 }
710
711 case 0x0012: /* RegCreateKey */
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_RegCreateKeyA( hkey, lpszSubKey, retkey );
717 }
718
719 case 0x0013: /* RegCloseKey */
720 {
721 HKEY hkey = (HKEY)stack32_pop( context );
722 return VMM_RegCloseKey( hkey );
723 }
724
725 case 0x0014: /* RegDeleteKey */
726 {
727 HKEY hkey = (HKEY) stack32_pop( context );
728 LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
729 return VMM_RegDeleteKeyA( hkey, lpszSubKey );
730 }
731
732 case 0x0015: /* RegSetValue */
733 {
734 HKEY hkey = (HKEY) stack32_pop( context );
735 LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
736 DWORD dwType = (DWORD) stack32_pop( context );
737 LPCSTR lpszData = (LPCSTR)stack32_pop( context );
738 DWORD cbData = (DWORD) stack32_pop( context );
739 return VMM_RegSetValueA( hkey, lpszSubKey, dwType, lpszData, cbData );
740 }
741
742 case 0x0016: /* RegDeleteValue */
743 {
744 HKEY hkey = (HKEY) stack32_pop( context );
745 LPSTR lpszValue = (LPSTR)stack32_pop( context );
746 return VMM_RegDeleteValueA( hkey, lpszValue );
747 }
748
749 case 0x0017: /* RegQueryValue */
750 {
751 HKEY hkey = (HKEY) stack32_pop( context );
752 LPSTR lpszSubKey = (LPSTR) stack32_pop( context );
753 LPSTR lpszData = (LPSTR) stack32_pop( context );
754 LPDWORD lpcbData = (LPDWORD)stack32_pop( context );
755 return VMM_RegQueryValueA( hkey, lpszSubKey, lpszData, lpcbData );
756 }
757
758 case 0x0018: /* RegEnumKey */
759 {
760 HKEY hkey = (HKEY) stack32_pop( context );
761 DWORD iSubkey = (DWORD)stack32_pop( context );
762 LPSTR lpszName = (LPSTR)stack32_pop( context );
763 DWORD lpcchName = (DWORD)stack32_pop( context );
764 return VMM_RegEnumKeyA( hkey, iSubkey, lpszName, lpcchName );
765 }
766
767 case 0x0019: /* RegEnumValue */
768 {
769 HKEY hkey = (HKEY) stack32_pop( context );
770 DWORD iValue = (DWORD) stack32_pop( context );
771 LPSTR lpszValue = (LPSTR) stack32_pop( context );
772 LPDWORD lpcchValue = (LPDWORD)stack32_pop( context );
773 LPDWORD lpReserved = (LPDWORD)stack32_pop( context );
774 LPDWORD lpdwType = (LPDWORD)stack32_pop( context );
775 LPBYTE lpbData = (LPBYTE) stack32_pop( context );
776 LPDWORD lpcbData = (LPDWORD)stack32_pop( context );
777 return VMM_RegEnumValueA( hkey, iValue, lpszValue, lpcchValue,
778 lpReserved, lpdwType, lpbData, lpcbData );
779 }
780
781 case 0x001A: /* RegQueryValueEx */
782 {
783 HKEY hkey = (HKEY) stack32_pop( context );
784 LPSTR lpszValue = (LPSTR) stack32_pop( context );
785 LPDWORD lpReserved = (LPDWORD)stack32_pop( context );
786 LPDWORD lpdwType = (LPDWORD)stack32_pop( context );
787 LPBYTE lpbData = (LPBYTE) stack32_pop( context );
788 LPDWORD lpcbData = (LPDWORD)stack32_pop( context );
789 return VMM_RegQueryValueExA( hkey, lpszValue, lpReserved,
790 lpdwType, lpbData, lpcbData );
791 }
792
793 case 0x001B: /* RegSetValueEx */
794 {
795 HKEY hkey = (HKEY) stack32_pop( context );
796 LPSTR lpszValue = (LPSTR) stack32_pop( context );
797 DWORD dwReserved = (DWORD) stack32_pop( context );
798 DWORD dwType = (DWORD) stack32_pop( context );
799 LPBYTE lpbData = (LPBYTE)stack32_pop( context );
800 DWORD cbData = (DWORD) stack32_pop( context );
801 return VMM_RegSetValueExA( hkey, lpszValue, dwReserved,
802 dwType, lpbData, cbData );
803 }
804
805 case 0x001C: /* RegFlushKey */
806 {
807 HKEY hkey = (HKEY)stack32_pop( context );
808 FIXME( "RegFlushKey(%p): stub\n", hkey );
809 return ERROR_SUCCESS;
810 }
811
812 case 0x001D: /* RegQueryInfoKey */
813 {
814 /* NOTE: This VxDCall takes only a subset of the parameters that the
815 corresponding Win32 API call does. The implementation in Win95
816 ADVAPI32 sets all output parameters not mentioned here to zero. */
817
818 HKEY hkey = (HKEY) stack32_pop( context );
819 LPDWORD lpcSubKeys = (LPDWORD)stack32_pop( context );
820 LPDWORD lpcchMaxSubKey = (LPDWORD)stack32_pop( context );
821 LPDWORD lpcValues = (LPDWORD)stack32_pop( context );
822 LPDWORD lpcchMaxValueName = (LPDWORD)stack32_pop( context );
823 LPDWORD lpcchMaxValueData = (LPDWORD)stack32_pop( context );
824 return VMM_RegQueryInfoKeyA( hkey, lpcSubKeys, lpcchMaxSubKey,
825 lpcValues, lpcchMaxValueName, lpcchMaxValueData );
826 }
827
828 case 0x0021: /* RegLoadKey */
829 {
830 HKEY hkey = (HKEY) stack32_pop( context );
831 LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
832 LPCSTR lpszFile = (LPCSTR)stack32_pop( context );
833 FIXME("RegLoadKey(%p,%s,%s): stub\n",hkey, debugstr_a(lpszSubKey), debugstr_a(lpszFile));
834 return ERROR_SUCCESS;
835 }
836
837 case 0x0022: /* RegUnLoadKey */
838 {
839 HKEY hkey = (HKEY) stack32_pop( context );
840 LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
841 FIXME("RegUnLoadKey(%p,%s): stub\n",hkey, debugstr_a(lpszSubKey));
842 return ERROR_SUCCESS;
843 }
844
845 case 0x0023: /* RegSaveKey */
846 {
847 HKEY hkey = (HKEY) stack32_pop( context );
848 LPCSTR lpszFile = (LPCSTR)stack32_pop( context );
849 LPSECURITY_ATTRIBUTES sa = (LPSECURITY_ATTRIBUTES)stack32_pop( context );
850 FIXME("RegSaveKey(%p,%s,%p): stub\n",hkey, debugstr_a(lpszFile),sa);
851 return ERROR_SUCCESS;
852 }
853
854 #if 0 /* Functions are not yet implemented in misc/registry.c */
855 case 0x0024: /* RegRemapPreDefKey */
856 case 0x0026: /* RegQueryMultipleValues */
857 #endif
858
859 case 0x0027: /* RegReplaceKey */
860 {
861 HKEY hkey = (HKEY) stack32_pop( context );
862 LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
863 LPCSTR lpszNewFile= (LPCSTR)stack32_pop( context );
864 LPCSTR lpszOldFile= (LPCSTR)stack32_pop( context );
865 FIXME("RegReplaceKey(%p,%s,%s,%s): stub\n", hkey, debugstr_a(lpszSubKey),
866 debugstr_a(lpszNewFile),debugstr_a(lpszOldFile));
867 return ERROR_SUCCESS;
868 }
869
870 case 0x0000: /* PageReserve */
871 {
872 LPVOID address;
873 LPVOID ret;
874 DWORD psize = getpagesize();
875 ULONG page = (ULONG) stack32_pop( context );
876 ULONG npages = (ULONG) stack32_pop( context );
877 ULONG flags = (ULONG) stack32_pop( context );
878
879 TRACE("PageReserve: page: %08lx, npages: %08lx, flags: %08lx partial stub!\n",
880 page, npages, flags );
881
882 if ( page == PR_SYSTEM ) {
883 ERR("Can't reserve ring 1 memory\n");
884 return -1;
885 }
886 /* FIXME: This has to be handled separately for the separate
887 address-spaces we now have */
888 if ( page == PR_PRIVATE || page == PR_SHARED ) page = 0;
889 /* FIXME: Handle flags in some way */
890 address = (LPVOID )(page * psize);
891 ret = VirtualAlloc ( address, ( npages * psize ), MEM_RESERVE, 0 );
892 TRACE("PageReserve: returning: %08lx\n", (DWORD )ret );
893 if ( ret == NULL )
894 return -1;
895 else
896 return (DWORD )ret;
897 }
898
899 case 0x0001: /* PageCommit */
900 {
901 LPVOID address;
902 LPVOID ret;
903 DWORD virt_perm;
904 DWORD psize = getpagesize();
905 ULONG page = (ULONG) stack32_pop( context );
906 ULONG npages = (ULONG) stack32_pop( context );
907 ULONG hpd = (ULONG) stack32_pop( context );
908 ULONG pagerdata = (ULONG) stack32_pop( context );
909 ULONG flags = (ULONG) stack32_pop( context );
910
911 TRACE("PageCommit: page: %08lx, npages: %08lx, hpd: %08lx pagerdata: "
912 "%08lx, flags: %08lx partial stub\n",
913 page, npages, hpd, pagerdata, flags );
914
915 if ( flags & PC_USER )
916 if ( flags & PC_WRITEABLE )
917 virt_perm = PAGE_EXECUTE_READWRITE;
918 else
919 virt_perm = PAGE_EXECUTE_READ;
920 else
921 virt_perm = PAGE_NOACCESS;
922
923 address = (LPVOID )(page * psize);
924 ret = VirtualAlloc ( address, ( npages * psize ), MEM_COMMIT, virt_perm );
925 TRACE("PageCommit: Returning: %08lx\n", (DWORD )ret );
926 return (DWORD )ret;
927
928 }
929 case 0x0002: /* PageDecommit */
930 {
931 LPVOID address;
932 BOOL ret;
933 DWORD psize = getpagesize();
934 ULONG page = (ULONG) stack32_pop( context );
935 ULONG npages = (ULONG) stack32_pop( context );
936 ULONG flags = (ULONG) stack32_pop( context );
937
938 TRACE("PageDecommit: page: %08lx, npages: %08lx, flags: %08lx partial stub\n",
939 page, npages, flags );
940 address = (LPVOID )( page * psize );
941 ret = VirtualFree ( address, ( npages * psize ), MEM_DECOMMIT );
942 TRACE("PageDecommit: Returning: %s\n", ret ? "TRUE" : "FALSE" );
943 return ret;
944 }
945 case 0x000d: /* PageModifyPermissions */
946 {
947 DWORD pg_old_perm;
948 DWORD pg_new_perm;
949 DWORD virt_old_perm;
950 DWORD virt_new_perm;
951 MEMORY_BASIC_INFORMATION mbi;
952 LPVOID address;
953 DWORD psize = getpagesize();
954 ULONG page = stack32_pop ( context );
955 ULONG npages = stack32_pop ( context );
956 ULONG permand = stack32_pop ( context );
957 ULONG permor = stack32_pop ( context );
958
959 TRACE("PageModifyPermissions %08lx %08lx %08lx %08lx partial stub\n",
960 page, npages, permand, permor );
961 address = (LPVOID )( page * psize );
962
963 VirtualQuery ( address, &mbi, sizeof ( MEMORY_BASIC_INFORMATION ));
964 virt_old_perm = mbi.Protect;
965
966 switch ( virt_old_perm & mbi.Protect ) {
967 case PAGE_READONLY:
968 case PAGE_EXECUTE:
969 case PAGE_EXECUTE_READ:
970 pg_old_perm = PC_USER;
971 break;
972 case PAGE_READWRITE:
973 case PAGE_WRITECOPY:
974 case PAGE_EXECUTE_READWRITE:
975 case PAGE_EXECUTE_WRITECOPY:
976 pg_old_perm = PC_USER | PC_WRITEABLE;
977 break;
978 case PAGE_NOACCESS:
979 default:
980 pg_old_perm = 0;
981 break;
982 }
983 pg_new_perm = pg_old_perm;
984 pg_new_perm &= permand & ~PC_STATIC;
985 pg_new_perm |= permor & ~PC_STATIC;
986
987 virt_new_perm = ( virt_old_perm ) & ~0xff;
988 if ( pg_new_perm & PC_USER )
989 {
990 if ( pg_new_perm & PC_WRITEABLE )
991 virt_new_perm |= PAGE_EXECUTE_READWRITE;
992 else
993 virt_new_perm |= PAGE_EXECUTE_READ;
994 }
995
996 if ( ! VirtualProtect ( address, ( npages * psize ), virt_new_perm, &virt_old_perm ) ) {
997 ERR("Can't change page permissions for %08lx\n", (DWORD )address );
998 return 0xffffffff;
999 }
1000 TRACE("Returning: %08lx\n", pg_old_perm );
1001 return pg_old_perm;
1002 }
1003 case 0x000a: /* PageFree */
1004 {
1005 BOOL ret;
1006 LPVOID hmem = (LPVOID) stack32_pop( context );
1007 DWORD flags = (DWORD ) stack32_pop( context );
1008
1009 TRACE("PageFree: hmem: %08lx, flags: %08lx partial stub\n",
1010 (DWORD )hmem, flags );
1011
1012 ret = VirtualFree ( hmem, 0, MEM_RELEASE );
1013 context->Eax = ret;
1014 TRACE("Returning: %d\n", ret );
1015
1016 return 0;
1017 }
1018 case 0x001e: /* GetDemandPageInfo */
1019 {
1020 DWORD dinfo = (DWORD)stack32_pop( context );
1021 DWORD flags = (DWORD)stack32_pop( context );
1022
1023 /* GetDemandPageInfo is supposed to fill out the struct at
1024 * "dinfo" with various low-level memory management information.
1025 * Apps are certainly not supposed to call this, although it's
1026 * demoed and documented by Pietrek on pages 441-443 of "Windows
1027 * 95 System Programming Secrets" if any program needs a real
1028 * implementation of this.
1029 */
1030
1031 FIXME("GetDemandPageInfo(%08lx %08lx): stub!\n", dinfo, flags);
1032
1033 return 0;
1034 }
1035 default:
1036 if (LOWORD(service) < N_VMM_SERVICE)
1037 FIXME( "Unimplemented service %s (%08lx)\n",
1038 VMM_Service_Name[LOWORD(service)], service);
1039 else
1040 FIXME( "Unknown service %08lx\n", service);
1041 break;
1042 }
1043
1044 return 0xffffffff; /* FIXME */
1045 }
1046
1047
1048 /********************************************************************************
1049 * VxDCall_VWin32
1050 *
1051 * Service numbers taken from page 448 of Pietrek's "Windows 95 System
1052 * Programming Secrets". Parameters from experimentation on real Win98.
1053 *
1054 */
1055
1056 static DWORD VxDCall_VWin32( DWORD service, CONTEXT86 *context )
1057 {
1058 switch ( LOWORD(service) )
1059 {
1060 case 0x0000: /* GetVersion */
1061 {
1062 DWORD vers = GetVersion();
1063 return (LOBYTE(vers) << 8) | HIBYTE(vers);
1064 }
1065 break;
1066
1067 case 0x0020: /* Get VMCPD Version */
1068 {
1069 DWORD parm = (DWORD) stack32_pop(context);
1070
1071 FIXME("Get VMCPD Version(%08lx): partial stub!\n", parm);
1072
1073 /* FIXME: This is what Win98 returns, it may
1074 * not be correct in all situations.
1075 * It makes Bleem! happy though.
1076 */
1077
1078 return 0x0405;
1079 }
1080
1081 case 0x0029: /* Int31/DPMI dispatch */
1082 {
1083 DWORD callnum = (DWORD) stack32_pop(context);
1084 DWORD parm = (DWORD) stack32_pop(context);
1085
1086 TRACE("Int31/DPMI dispatch(%08lx)\n", callnum);
1087
1088 SET_AX( context, callnum );
1089 SET_CX( context, parm );
1090 if(Dosvm.CallBuiltinHandler || DPMI_LoadDosSystem())
1091 Dosvm.CallBuiltinHandler( context, 0x31 );
1092
1093 return LOWORD(context->Eax);
1094 }
1095 break;
1096
1097 case 0x002a: /* Int41 dispatch - parm = int41 service number */
1098 {
1099 DWORD callnum = (DWORD) stack32_pop(context);
1100
1101 return callnum; /* FIXME: should really call INT_Int41Handler() */
1102 }
1103 break;
1104
1105 default:
1106 FIXME("Unknown VWin32 service %08lx\n", service);
1107 break;
1108 }
1109
1110 return 0xffffffff;
1111 }
1112
1113
1114 /***********************************************************************
1115 * VxDCall0 (KERNEL32.1)
1116 * VxDCall1 (KERNEL32.2)
1117 * VxDCall2 (KERNEL32.3)
1118 * VxDCall3 (KERNEL32.4)
1119 * VxDCall4 (KERNEL32.5)
1120 * VxDCall5 (KERNEL32.6)
1121 * VxDCall6 (KERNEL32.7)
1122 * VxDCall7 (KERNEL32.8)
1123 * VxDCall8 (KERNEL32.9)
1124 */
1125 void VxDCall( DWORD service, CONTEXT86 *context )
1126 {
1127 DWORD ret;
1128
1129 TRACE( "(%08lx, ...)\n", service);
1130
1131 switch(HIWORD(service))
1132 {
1133 case 0x0001: /* VMM */
1134 ret = VxDCall_VMM( service, context );
1135 break;
1136 case 0x002a: /* VWIN32 */
1137 ret = VxDCall_VWin32( service, context );
1138 break;
1139 default:
1140 FIXME( "Unknown/unimplemented VxD (%08lx)\n", service);
1141 ret = 0xffffffff; /* FIXME */
1142 break;
1143 }
1144 context->Eax = ret;
1145 }
1146
1147
1148 /***********************************************************************
1149 * OpenVxDHandle (KERNEL32.@)
1150 *
1151 * This function is supposed to return the corresponding Ring 0
1152 * ("kernel") handle for a Ring 3 handle in Win9x.
1153 * Evidently, Wine will have problems with this. But we try anyway,
1154 * maybe it helps...
1155 */
1156 HANDLE WINAPI OpenVxDHandle(HANDLE hHandleRing3)
1157 {
1158 FIXME( "(%p), stub! (returning Ring 3 handle instead of Ring 0)\n", hHandleRing3);
1159 return hHandleRing3;
1160 }
useful hacks and other patches not (yet) suitable for mainline