?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Added more conversion routines (rate conversion is implemented).
[wine.git] / misc / registry.c
blob8ca97551c4733f8687e57a81bfa37b9d26b0c856
1 /*
2 * Registry Functions
3 *
4 * Copyright 1996 Marcus Meissner
5 * Copyright 1998 Matthew Becker
6 * Copyright 1999 Sylvain St-Germain
7 *
8 * December 21, 1997 - Kevin Cozens
9 * Fixed bugs in the _w95_loadreg() function. Added extra information
10 * regarding the format of the Windows '95 registry files.
11 *
12 * NOTES
13 * When changing this file, please re-run the regtest program to ensure
14 * the conditions are handled properly.
15 *
16 * TODO
17 * Security access
18 * Option handling
19 * Time for RegEnumKey*, RegQueryInfoKey*
20 */
21
22 #include "config.h"
23
24 #include <stdlib.h>
25 #include <string.h>
26 #include <stdio.h>
27 #include <unistd.h>
28 #include <limits.h>
29 #include <ctype.h>
30 #include <errno.h>
31 #ifdef HAVE_SYS_ERRNO_H
32 #include <sys/errno.h>
33 #endif
34 #include <sys/types.h>
35 #include <fcntl.h>
36 #include <sys/fcntl.h>
37 #include <sys/stat.h>
38 #include <time.h>
39 #include "windef.h"
40 #include "winbase.h"
41 #include "winnls.h"
42 #include "wine/winbase16.h"
43 #include "winerror.h"
44 #include "file.h"
45 #include "heap.h"
46 #include "debugtools.h"
47 #include "options.h"
48 #include "winreg.h"
49 #include "server.h"
50 #include "services.h"
51
52 DEFAULT_DEBUG_CHANNEL(reg);
53
54 static void REGISTRY_Init(void);
55 /* FIXME: following defines should be configured global ... */
56
57 #define SAVE_USERS_DEFAULT ETCDIR"/wine.userreg"
58 #define SAVE_LOCAL_MACHINE_DEFAULT ETCDIR"/wine.systemreg"
59
60 /* relative in ~user/.wine/ : */
61 #define SAVE_CURRENT_USER "user.reg"
62 #define SAVE_DEFAULT_USER "userdef.reg"
63 #define SAVE_LOCAL_USERS_DEFAULT "wine.userreg"
64 #define SAVE_LOCAL_MACHINE "system.reg"
65
66
67 static void *xmalloc( size_t size )
68 {
69 void *res;
70
71 res = malloc (size ? size : 1);
72 if (res == NULL) {
73 WARN("Virtual memory exhausted.\n");
74 exit (1);
75 }
76 return res;
77 }
78
79
80 /******************************************************************************
81 * REGISTRY_Init [Internal]
82 * Registry initialisation, allocates some default keys.
83 */
84 static void REGISTRY_Init(void) {
85 HKEY hkey;
86 char buf[200];
87
88 TRACE("(void)\n");
89
90 RegCreateKeyA(HKEY_DYN_DATA,"PerfStats\\StatData",&hkey);
91 RegCloseKey(hkey);
92
93 /* This was an Open, but since it is called before the real registries
94 are loaded, it was changed to a Create - MTB 980507*/
95 RegCreateKeyA(HKEY_LOCAL_MACHINE,"HARDWARE\\DESCRIPTION\\System",&hkey);
96 RegSetValueExA(hkey,"Identifier",0,REG_SZ,"SystemType WINE",strlen("SystemType WINE"));
97 RegCloseKey(hkey);
98
99 /* \\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion
100 * CurrentVersion
101 * CurrentBuildNumber
102 * CurrentType
103 * string RegisteredOwner
104 * string RegisteredOrganization
105 *
106 */
107 /* System\\CurrentControlSet\\Services\\SNMP\\Parameters\\RFC1156Agent
108 * string SysContact
109 * string SysLocation
110 * SysServices
111 */
112 if (-1!=gethostname(buf,200)) {
113 RegCreateKeyA(HKEY_LOCAL_MACHINE,"System\\CurrentControlSet\\Control\\ComputerName\\ComputerName",&hkey);
114 RegSetValueExA(hkey,"ComputerName",0,REG_SZ,buf,strlen(buf)+1);
115 RegCloseKey(hkey);
116 }
117 }
118
119
120 /************************ LOAD Registry Function ****************************/
121
122
123
124 /******************************************************************************
125 * _find_or_add_key [Internal]
126 */
127 static inline HKEY _find_or_add_key( HKEY hkey, LPWSTR keyname )
128 {
129 HKEY subkey;
130 if (RegCreateKeyW( hkey, keyname, &subkey ) != ERROR_SUCCESS) subkey = 0;
131 if (keyname) free( keyname );
132 return subkey;
133 }
134
135 /******************************************************************************
136 * _find_or_add_value [Internal]
137 */
138 static void _find_or_add_value( HKEY hkey, LPWSTR name, DWORD type, LPBYTE data, DWORD len )
139 {
140 RegSetValueExW( hkey, name, 0, type, data, len );
141 if (name) free( name );
142 if (data) free( data );
143 }
144
145
146 /******************************************************************************
147 * _wine_read_line [Internal]
148 *
149 * reads a line including dynamically enlarging the readbuffer and throwing
150 * away comments
151 */
152 static int _wine_read_line( FILE *F, char **buf, int *len )
153 {
154 char *s,*curread;
155 int mylen,curoff;
156
157 curread = *buf;
158 mylen = *len;
159 **buf = '\0';
160 while (1) {
161 while (1) {
162 s=fgets(curread,mylen,F);
163 if (s==NULL)
164 return 0; /* EOF */
165 if (NULL==(s=strchr(curread,'\n'))) {
166 /* buffer wasn't large enough */
167 curoff = strlen(*buf);
168 curread = realloc(*buf,*len*2);
169 if(curread == NULL) {
170 WARN("Out of memory");
171 return 0;
172 }
173 *buf = curread;
174 curread+= curoff;
175 mylen = *len; /* we filled up the buffer and
176 * got new '*len' bytes to fill
177 */
178 *len = *len * 2;
179 } else {
180 *s='\0';
181 break;
182 }
183 }
184 /* throw away comments */
185 if (**buf=='#' || **buf==';') {
186 curread = *buf;
187 mylen = *len;
188 continue;
189 }
190 if (s) /* got end of line */
191 break;
192 }
193 return 1;
194 }
195
196
197 /******************************************************************************
198 * _wine_read_USTRING [Internal]
199 *
200 * converts a char* into a UNICODE string (up to a special char)
201 * and returns the position exactly after that string
202 */
203 static char* _wine_read_USTRING( char *buf, LPWSTR *str )
204 {
205 char *s;
206 LPWSTR ws;
207
208 /* read up to "=" or "\0" or "\n" */
209 s = buf;
210 *str = (LPWSTR)xmalloc(2*strlen(buf)+2);
211 ws = *str;
212 while (*s && (*s!='\n') && (*s!='=')) {
213 if (*s!='\\')
214 *ws++=*((unsigned char*)s++);
215 else {
216 s++;
217 if (!*s) {
218 /* Dangling \ ... may only happen if a registry
219 * write was short. FIXME: What to do?
220 */
221 break;
222 }
223 if (*s=='\\') {
224 *ws++='\\';
225 s++;
226 continue;
227 }
228 if (*s!='u') {
229 WARN("Non unicode escape sequence \\%c found in |%s|\n",*s,buf);
230 *ws++='\\';
231 *ws++=*s++;
232 } else {
233 char xbuf[5];
234 int wc;
235
236 s++;
237 memcpy(xbuf,s,4);xbuf[4]='\0';
238 if (!sscanf(xbuf,"%x",&wc))
239 WARN("Strange escape sequence %s found in |%s|\n",xbuf,buf);
240 s+=4;
241 *ws++ =(unsigned short)wc;
242 }
243 }
244 }
245 *ws = 0;
246 return s;
247 }
248
249
250 /******************************************************************************
251 * _wine_loadsubkey [Internal]
252 *
253 * NOTES
254 * It seems like this is returning a boolean. Should it?
255 *
256 * RETURNS
257 * Success: 1
258 * Failure: 0
259 */
260 static int _wine_loadsubkey( FILE *F, HKEY hkey, int level, char **buf, int *buflen )
261 {
262 HKEY subkey;
263 int i;
264 char *s;
265 LPWSTR name;
266
267 TRACE("(%p,%x,%d,%s,%d)\n", F, hkey, level, debugstr_a(*buf), *buflen);
268
269 /* Good. We already got a line here ... so parse it */
270 subkey = 0;
271 while (1) {
272 i=0;s=*buf;
273 while (*s=='\t') {
274 s++;
275 i++;
276 }
277 if (i>level) {
278 if (!subkey) {
279 WARN("Got a subhierarchy without resp. key?\n");
280 return 0;
281 }
282 if (!_wine_loadsubkey(F,subkey,level+1,buf,buflen))
283 if (!_wine_read_line(F,buf,buflen))
284 goto done;
285 continue;
286 }
287
288 /* let the caller handle this line */
289 if (i<level || **buf=='\0')
290 goto done;
291
292 /* it can be: a value or a keyname. Parse the name first */
293 s=_wine_read_USTRING(s,&name);
294
295 /* switch() default: hack to avoid gotos */
296 switch (0) {
297 default:
298 if (*s=='\0') {
299 if (subkey) RegCloseKey( subkey );
300 subkey=_find_or_add_key(hkey,name);
301 } else {
302 LPBYTE data;
303 int len,lastmodified,type;
304
305 if (*s!='=') {
306 WARN("Unexpected character: %c\n",*s);
307 break;
308 }
309 s++;
310 if (2!=sscanf(s,"%d,%d,",&type,&lastmodified)) {
311 WARN("Haven't understood possible value in |%s|, skipping.\n",*buf);
312 break;
313 }
314 /* skip the 2 , */
315 s=strchr(s,',');s++;
316 s=strchr(s,',');
317 if (!s++) {
318 WARN("Haven't understood possible value in |%s|, skipping.\n",*buf);
319 break;
320 }
321 if (type == REG_SZ || type == REG_EXPAND_SZ) {
322 s=_wine_read_USTRING(s,(LPWSTR*)&data);
323 len = lstrlenW((LPWSTR)data)*2+2;
324 } else {
325 len=strlen(s)/2;
326 data = (LPBYTE)xmalloc(len+1);
327 for (i=0;i<len;i++) {
328 data[i]=0;
329 if (*s>='0' && *s<='9')
330 data[i]=(*s-'0')<<4;
331 if (*s>='a' && *s<='f')
332 data[i]=(*s-'a'+'\xa')<<4;
333 if (*s>='A' && *s<='F')
334 data[i]=(*s-'A'+'\xa')<<4;
335 s++;
336 if (*s>='0' && *s<='9')
337 data[i]|=*s-'0';
338 if (*s>='a' && *s<='f')
339 data[i]|=*s-'a'+'\xa';
340 if (*s>='A' && *s<='F')
341 data[i]|=*s-'A'+'\xa';
342 s++;
343 }
344 }
345 _find_or_add_value(hkey,name,type,data,len);
346 }
347 }
348 /* read the next line */
349 if (!_wine_read_line(F,buf,buflen))
350 goto done;
351 }
352 done:
353 if (subkey) RegCloseKey( subkey );
354 return 1;
355 }
356
357
358 /******************************************************************************
359 * _wine_loadsubreg [Internal]
360 */
361 static int _wine_loadsubreg( FILE *F, HKEY hkey, const char *fn )
362 {
363 int ver;
364 char *buf;
365 int buflen;
366
367 buf=xmalloc(10);buflen=10;
368 if (!_wine_read_line(F,&buf,&buflen)) {
369 free(buf);
370 return 0;
371 }
372 if (!sscanf(buf,"WINE REGISTRY Version %d",&ver)) {
373 free(buf);
374 return 0;
375 }
376 if (ver!=1) {
377 if (ver == 2) /* new version */
378 {
379 HANDLE file;
380 if ((file = FILE_CreateFile( fn, GENERIC_READ, 0, NULL, OPEN_EXISTING,
381 FILE_ATTRIBUTE_NORMAL, -1, TRUE )) != INVALID_HANDLE_VALUE)
382 {
383 SERVER_START_REQ
384 {
385 struct load_registry_request *req = server_alloc_req( sizeof(*req), 0 );
386 req->hkey = hkey;
387 req->file = file;
388 server_call( REQ_LOAD_REGISTRY );
389 }
390 SERVER_END_REQ;
391 CloseHandle( file );
392 }
393 free( buf );
394 return 1;
395 }
396 else
397 {
398 TRACE("Old format (%d) registry found, ignoring it. (buf was %s).\n",ver,buf);
399 free(buf);
400 return 0;
401 }
402 }
403 if (!_wine_read_line(F,&buf,&buflen)) {
404 free(buf);
405 return 0;
406 }
407 if (!_wine_loadsubkey(F,hkey,0,&buf,&buflen)) {
408 free(buf);
409 return 0;
410 }
411 free(buf);
412 return 1;
413 }
414
415
416 /******************************************************************************
417 * _wine_loadreg [Internal]
418 */
419 static int _wine_loadreg( HKEY hkey, char *fn )
420 {
421 FILE *F;
422
423 TRACE("(%x,%s)\n",hkey,debugstr_a(fn));
424
425 F = fopen(fn,"rb");
426 if (F==NULL) {
427 WARN("Couldn't open %s for reading: %s\n",fn,strerror(errno) );
428 return -1;
429 }
430 _wine_loadsubreg(F,hkey,fn);
431 fclose(F);
432 return 0;
433 }
434
435 /* NT REGISTRY LOADER */
436
437 #ifdef HAVE_SYS_MMAN_H
438 # include <sys/mman.h>
439 #endif
440
441 #ifndef MAP_FAILED
442 #define MAP_FAILED ((LPVOID)-1)
443 #endif
444
445 #define NT_REG_BLOCK_SIZE 0x1000
446
447 #define NT_REG_HEADER_BLOCK_ID 0x66676572 /* regf */
448 #define NT_REG_POOL_BLOCK_ID 0x6E696268 /* hbin */
449 #define NT_REG_KEY_BLOCK_ID 0x6b6e /* nk */
450 #define NT_REG_VALUE_BLOCK_ID 0x6b76 /* vk */
451
452 /* subblocks of nk */
453 #define NT_REG_HASH_BLOCK_ID 0x666c /* lf */
454 #define NT_REG_NOHASH_BLOCK_ID 0x696c /* li */
455 #define NT_REG_RI_BLOCK_ID 0x6972 /* ri */
456
457 #define NT_REG_KEY_BLOCK_TYPE 0x20
458 #define NT_REG_ROOT_KEY_BLOCK_TYPE 0x2c
459
460 typedef struct
461 {
462 DWORD id; /* 0x66676572 'regf'*/
463 DWORD uk1; /* 0x04 */
464 DWORD uk2; /* 0x08 */
465 FILETIME DateModified; /* 0x0c */
466 DWORD uk3; /* 0x14 */
467 DWORD uk4; /* 0x18 */
468 DWORD uk5; /* 0x1c */
469 DWORD uk6; /* 0x20 */
470 DWORD RootKeyBlock; /* 0x24 */
471 DWORD BlockSize; /* 0x28 */
472 DWORD uk7[116];
473 DWORD Checksum; /* at offset 0x1FC */
474 } nt_regf;
475
476 typedef struct
477 {
478 DWORD blocksize;
479 BYTE data[1];
480 } nt_hbin_sub;
481
482 typedef struct
483 {
484 DWORD id; /* 0x6E696268 'hbin' */
485 DWORD off_prev;
486 DWORD off_next;
487 DWORD uk1;
488 DWORD uk2; /* 0x10 */
489 DWORD uk3; /* 0x14 */
490 DWORD uk4; /* 0x18 */
491 DWORD size; /* 0x1C */
492 nt_hbin_sub hbin_sub; /* 0x20 */
493 } nt_hbin;
494
495 /*
496 * the value_list consists of offsets to the values (vk)
497 */
498 typedef struct
499 {
500 WORD SubBlockId; /* 0x00 0x6B6E */
501 WORD Type; /* 0x02 for the root-key: 0x2C, otherwise 0x20*/
502 FILETIME writetime; /* 0x04 */
503 DWORD uk1; /* 0x0C */
504 DWORD parent_off; /* 0x10 Offset of Owner/Parent key */
505 DWORD nr_subkeys; /* 0x14 number of sub-Keys */
506 DWORD uk8; /* 0x18 */
507 DWORD lf_off; /* 0x1C Offset of the sub-key lf-Records */
508 DWORD uk2; /* 0x20 */
509 DWORD nr_values; /* 0x24 number of values */
510 DWORD valuelist_off; /* 0x28 Offset of the Value-List */
511 DWORD off_sk; /* 0x2c Offset of the sk-Record */
512 DWORD off_class; /* 0x30 Offset of the Class-Name */
513 DWORD uk3; /* 0x34 */
514 DWORD uk4; /* 0x38 */
515 DWORD uk5; /* 0x3c */
516 DWORD uk6; /* 0x40 */
517 DWORD uk7; /* 0x44 */
518 WORD name_len; /* 0x48 name-length */
519 WORD class_len; /* 0x4a class-name length */
520 char name[1]; /* 0x4c key-name */
521 } nt_nk;
522
523 typedef struct
524 {
525 DWORD off_nk; /* 0x00 */
526 DWORD name; /* 0x04 */
527 } hash_rec;
528
529 typedef struct
530 {
531 WORD id; /* 0x00 0x666c */
532 WORD nr_keys; /* 0x06 */
533 hash_rec hash_rec[1];
534 } nt_lf;
535
536 /*
537 list of subkeys without hash
538
539 li --+-->nk
540 |
541 +-->nk
542 */
543 typedef struct
544 {
545 WORD id; /* 0x00 0x696c */
546 WORD nr_keys;
547 DWORD off_nk[1];
548 } nt_li;
549
550 /*
551 this is a intermediate node
552
553 ri --+-->li--+-->nk
554 | +
555 | +-->nk
556 |
557 +-->li--+-->nk
558 +
559 +-->nk
560 */
561 typedef struct
562 {
563 WORD id; /* 0x00 0x6972 */
564 WORD nr_li; /* 0x02 number off offsets */
565 DWORD off_li[1]; /* 0x04 points to li */
566 } nt_ri;
567
568 typedef struct
569 {
570 WORD id; /* 0x00 'vk' */
571 WORD nam_len;
572 DWORD data_len;
573 DWORD data_off;
574 DWORD type;
575 WORD flag;
576 WORD uk1;
577 char name[1];
578 } nt_vk;
579
580 LPSTR _strdupnA( LPCSTR str, int len )
581 {
582 LPSTR ret;
583
584 if (!str) return NULL;
585 ret = xmalloc( len + 1 );
586 memcpy( ret, str, len );
587 ret[len] = 0x00;
588 return ret;
589 }
590
591 static int _nt_parse_nk(HKEY hkey, char * base, nt_nk * nk, int level);
592 static int _nt_parse_vk(HKEY hkey, char * base, nt_vk * vk);
593 static int _nt_parse_lf(HKEY hkey, char * base, int subkeys, nt_lf * lf, int level);
594
595
596 /*
597 * gets a value
598 *
599 * vk->flag:
600 * 0 value is a default value
601 * 1 the value has a name
602 *
603 * vk->data_len
604 * len of the whole data block
605 * - reg_sz (unicode)
606 * bytes including the terminating \0 = 2*(number_of_chars+1)
607 * - reg_dword, reg_binary:
608 * if highest bit of data_len is set data_off contains the value
609 */
610 static int _nt_parse_vk(HKEY hkey, char * base, nt_vk * vk)
611 {
612 WCHAR name [256];
613 DWORD len, ret;
614 BYTE * pdata = (BYTE *)(base+vk->data_off+4); /* start of data */
615
616 if(vk->id != NT_REG_VALUE_BLOCK_ID) goto error;
617
618 if (!(len = MultiByteToWideChar( CP_ACP, 0, vk->name, vk->nam_len, name, 256 )) && vk->nam_len)
619 {
620 ERR("name too large '%.*s' (%d)\n", vk->nam_len, vk->name, vk->nam_len );
621 return FALSE;
622 }
623 name[len] = 0;
624
625 ret = RegSetValueExW( hkey, (vk->flag & 0x00000001) ? name : NULL, 0, vk->type,
626 (vk->data_len & 0x80000000) ? (LPBYTE)&(vk->data_off): pdata,
627 (vk->data_len & 0x7fffffff) );
628 if (ret) ERR("RegSetValueEx failed (0x%08lx)\n", ret);
629 return TRUE;
630 error:
631 ERR("unknown block found (0x%04x), please report!\n", vk->id);
632 return FALSE;
633 }
634
635 /*
636 * get the subkeys
637 *
638 * this structure contains the hash of a keyname and points to all
639 * subkeys
640 *
641 * exception: if the id is 'il' there are no hash values and every
642 * dword is a offset
643 */
644 static int _nt_parse_lf(HKEY hkey, char * base, int subkeys, nt_lf * lf, int level)
645 {
646 int i;
647
648 if (lf->id == NT_REG_HASH_BLOCK_ID)
649 {
650 if (subkeys != lf->nr_keys) goto error1;
651
652 for (i=0; i<lf->nr_keys; i++)
653 {
654 if (!_nt_parse_nk(hkey, base, (nt_nk*)(base+lf->hash_rec[i].off_nk+4), level)) goto error;
655 }
656 }
657 else if (lf->id == NT_REG_NOHASH_BLOCK_ID)
658 {
659 nt_li * li = (nt_li*)lf;
660 if (subkeys != li->nr_keys) goto error1;
661
662 for (i=0; i<li->nr_keys; i++)
663 {
664 if (!_nt_parse_nk(hkey, base, (nt_nk*)(base+li->off_nk[i]+4), level)) goto error;
665 }
666 }
667 else if (lf->id == NT_REG_RI_BLOCK_ID) /* ri */
668 {
669 nt_ri * ri = (nt_ri*)lf;
670 int li_subkeys = 0;
671
672 /* count all subkeys */
673 for (i=0; i<ri->nr_li; i++)
674 {
675 nt_li * li = (nt_li*)(base+ri->off_li[i]+4);
676 if(li->id != NT_REG_NOHASH_BLOCK_ID) goto error2;
677 li_subkeys += li->nr_keys;
678 }
679
680 /* check number */
681 if (subkeys != li_subkeys) goto error1;
682
683 /* loop through the keys */
684 for (i=0; i<ri->nr_li; i++)
685 {
686 nt_li * li = (nt_li*)(base+ri->off_li[i]+4);
687 if (!_nt_parse_lf(hkey, base, li->nr_keys, (nt_lf*)li, level)) goto error;
688 }
689 }
690 else
691 {
692 goto error2;
693 }
694 return TRUE;
695
696 error2: ERR("unknown node id 0x%04x, please report!\n", lf->id);
697 return TRUE;
698
699 error1: ERR("registry file corrupt! (inconsistent number of subkeys)\n");
700 return FALSE;
701
702 error: ERR("error reading lf block\n");
703 return FALSE;
704 }
705
706 static int _nt_parse_nk(HKEY hkey, char * base, nt_nk * nk, int level)
707 {
708 char * name;
709 int i;
710 DWORD * vl;
711 HKEY subkey = hkey;
712
713 if(nk->SubBlockId != NT_REG_KEY_BLOCK_ID)
714 {
715 ERR("unknown node id 0x%04x, please report!\n", nk->SubBlockId);
716 goto error;
717 }
718
719 if((nk->Type!=NT_REG_ROOT_KEY_BLOCK_TYPE) &&
720 (((nt_nk*)(base+nk->parent_off+4))->SubBlockId != NT_REG_KEY_BLOCK_ID))
721 {
722 ERR("registry file corrupt!\n");
723 goto error;
724 }
725
726 /* create the new key */
727 if(level <= 0)
728 {
729 name = _strdupnA( nk->name, nk->name_len);
730 if(RegCreateKeyA( hkey, name, &subkey )) { free(name); goto error; }
731 free(name);
732 }
733
734 /* loop through the subkeys */
735 if (nk->nr_subkeys)
736 {
737 nt_lf * lf = (nt_lf*)(base+nk->lf_off+4);
738 if (!_nt_parse_lf(subkey, base, nk->nr_subkeys, lf, level-1)) goto error1;
739 }
740
741 /* loop trough the value list */
742 vl = (DWORD *)(base+nk->valuelist_off+4);
743 for (i=0; i<nk->nr_values; i++)
744 {
745 nt_vk * vk = (nt_vk*)(base+vl[i]+4);
746 if (!_nt_parse_vk(subkey, base, vk)) goto error1;
747 }
748
749 RegCloseKey(subkey);
750 return TRUE;
751
752 error1: RegCloseKey(subkey);
753 error: return FALSE;
754 }
755
756 /* end nt loader */
757
758 /* windows 95 registry loader */
759
760 /* SECTION 1: main header
761 *
762 * once at offset 0
763 */
764 #define W95_REG_CREG_ID 0x47455243
765
766 typedef struct
767 {
768 DWORD id; /* "CREG" = W95_REG_CREG_ID */
769 DWORD version; /* ???? 0x00010000 */
770 DWORD rgdb_off; /* 0x08 Offset of 1st RGDB-block */
771 DWORD uk2; /* 0x0c */
772 WORD rgdb_num; /* 0x10 # of RGDB-blocks */
773 WORD uk3;
774 DWORD uk[3];
775 /* rgkn */
776 } _w95creg;
777
778 /* SECTION 2: Directory information (tree structure)
779 *
780 * once on offset 0x20
781 *
782 * structure: [rgkn][dke]* (repeat till last_dke is reached)
783 */
784 #define W95_REG_RGKN_ID 0x4e4b4752
785
786 typedef struct
787 {
788 DWORD id; /*"RGKN" = W95_REG_RGKN_ID */
789 DWORD size; /* Size of the RGKN-block */
790 DWORD root_off; /* Rel. Offset of the root-record */
791 DWORD last_dke; /* Offset to last DKE ? */
792 DWORD uk[4];
793 } _w95rgkn;
794
795 /* Disk Key Entry Structure
796 *
797 * the 1st entry in a "usual" registry file is a nul-entry with subkeys: the
798 * hive itself. It looks the same like other keys. Even the ID-number can
799 * be any value.
800 *
801 * The "hash"-value is a value representing the key's name. Windows will not
802 * search for the name, but for a matching hash-value. if it finds one, it
803 * will compare the actual string info, otherwise continue with the next key.
804 * To calculate the hash initialize a D-Word with 0 and add all ASCII-values
805 * of the string which are smaller than 0x80 (128) to this D-Word.
806 *
807 * If you want to modify key names, also modify the hash-values, since they
808 * cannot be found again (although they would be displayed in REGEDIT)
809 * End of list-pointers are filled with 0xFFFFFFFF
810 *
811 * Disk keys are layed out flat ... But, sometimes, nrLS and nrMS are both
812 * 0xFFFF, which means skipping over nextkeyoffset bytes (including this
813 * structure) and reading another RGDB_section.
814 *
815 * The last DKE (see field last_dke in _w95_rgkn) has only 3 DWORDs with
816 * 0x80000000 (EOL indicator ?) as x1, the hash value and 0xFFFFFFFF as x3.
817 * The remaining space between last_dke and the offset calculated from
818 * rgkn->size seems to be free for use for more dke:s.
819 * So it seems if more dke:s are added, they are added to that space and
820 * last_dke is grown, and in case that "free" space is out, the space
821 * gets grown and rgkn->size gets adjusted.
822 *
823 * there is a one to one relationship between dke and dkh
824 */
825 /* key struct, once per key */
826 typedef struct
827 {
828 DWORD x1; /* Free entry indicator(?) */
829 DWORD hash; /* sum of bytes of keyname */
830 DWORD x3; /* Root key indicator? usually 0xFFFFFFFF */
831 DWORD prevlvl; /* offset of previous key */
832 DWORD nextsub; /* offset of child key */
833 DWORD next; /* offset of sibling key */
834 WORD nrLS; /* id inside the rgdb block */
835 WORD nrMS; /* number of the rgdb block */
836 } _w95dke;
837
838 /* SECTION 3: key information, values and data
839 *
840 * structure:
841 * section: [blocks]* (repeat creg->rgdb_num times)
842 * blocks: [rgdb] [subblocks]* (repeat till block size reached )
843 * subblocks: [dkh] [dkv]* (repeat dkh->values times )
844 *
845 * An interesting relationship exists in RGDB_section. The DWORD value
846 * at offset 0x10 equals the one at offset 0x04 minus the one at offset 0x08.
847 * I have no idea at the moment what this means. (Kevin Cozens)
848 */
849
850 /* block header, once per block */
851 #define W95_REG_RGDB_ID 0x42444752
852
853 typedef struct
854 {
855 DWORD id; /* 0x00 'RGDB' = W95_REG_RGDB_ID */
856 DWORD size; /* 0x04 */
857 DWORD uk1; /* 0x08 */
858 DWORD uk2; /* 0x0c */
859 DWORD uk3; /* 0x10 */
860 DWORD uk4; /* 0x14 */
861 DWORD uk5; /* 0x18 */
862 DWORD uk6; /* 0x1c */
863 /* dkh */
864 } _w95rgdb;
865
866 /* Disk Key Header structure (RGDB part), once per key */
867 typedef struct
868 {
869 DWORD nextkeyoff; /* 0x00 offset to next dkh */
870 WORD nrLS; /* 0x04 id inside the rgdb block */
871 WORD nrMS; /* 0x06 number of the rgdb block */
872 DWORD bytesused; /* 0x08 */
873 WORD keynamelen; /* 0x0c len of name */
874 WORD values; /* 0x0e number of values */
875 DWORD xx1; /* 0x10 */
876 char name[1]; /* 0x14 */
877 /* dkv */ /* 0x14 + keynamelen */
878 } _w95dkh;
879
880 /* Disk Key Value structure, once per value */
881 typedef struct
882 {
883 DWORD type; /* 0x00 */
884 DWORD x1; /* 0x04 */
885 WORD valnamelen; /* 0x08 length of name, 0 is default key */
886 WORD valdatalen; /* 0x0A length of data */
887 char name[1]; /* 0x0c */
888 /* raw data */ /* 0x0c + valnamelen */
889 } _w95dkv;
890
891 /******************************************************************************
892 * _w95_lookup_dkh [Internal]
893 *
894 * seeks the dkh belonging to a dke
895 */
896 static _w95dkh * _w95_lookup_dkh (_w95creg *creg, int nrLS, int nrMS)
897 {
898 _w95rgdb * rgdb;
899 _w95dkh * dkh;
900 int i;
901
902 /* get the beginning of the rgdb datastore */
903 rgdb = (_w95rgdb*)((char*)creg+creg->rgdb_off);
904
905 /* check: requested block < last_block) */
906 if (creg->rgdb_num <= nrMS)
907 {
908 ERR("registry file corrupt! requested block no. beyond end.\n");
909 goto error;
910 }
911
912 /* find the right block */
913 for(i=0; i<nrMS ;i++)
914 {
915 if(rgdb->id != W95_REG_RGDB_ID) /* check the magic */
916 {
917 ERR("registry file corrupt! bad magic 0x%08lx\n", rgdb->id);
918 goto error;
919 }
920 rgdb = (_w95rgdb*) ((char*)rgdb+rgdb->size); /* find next block */
921 }
922
923 dkh = (_w95dkh*)(rgdb + 1); /* first sub block within the rgdb */
924
925 do
926 {
927 if(nrLS==dkh->nrLS ) return dkh;
928 dkh = (_w95dkh*)((char*)dkh + dkh->nextkeyoff); /* find next subblock */
929 } while ((char *)dkh < ((char*)rgdb+rgdb->size));
930
931 error: return NULL;
932 }
933
934 /******************************************************************************
935 * _w95_parse_dkv [Internal]
936 */
937 static int _w95_parse_dkv (
938 HKEY hkey,
939 _w95dkh * dkh,
940 int nrLS,
941 int nrMS )
942 {
943 _w95dkv * dkv;
944 int i;
945 DWORD ret;
946 char * name;
947
948 /* first value block */
949 dkv = (_w95dkv*)((char*)dkh+dkh->keynamelen+0x14);
950
951 /* loop trought the values */
952 for (i=0; i< dkh->values; i++)
953 {
954 name = _strdupnA(dkv->name, dkv->valnamelen);
955 ret = RegSetValueExA(hkey, name, 0, dkv->type, &(dkv->name[dkv->valnamelen]),dkv->valdatalen);
956 if (ret) FIXME("RegSetValueEx returned: 0x%08lx\n", ret);
957 free (name);
958
959 /* next value */
960 dkv = (_w95dkv*)((char*)dkv+dkv->valnamelen+dkv->valdatalen+0x0c);
961 }
962 return TRUE;
963 }
964
965 /******************************************************************************
966 * _w95_parse_dke [Internal]
967 */
968 static int _w95_parse_dke(
969 HKEY hkey,
970 _w95creg * creg,
971 _w95rgkn *rgkn,
972 _w95dke * dke,
973 int level )
974 {
975 _w95dkh * dkh;
976 HKEY hsubkey = hkey;
977 char * name;
978 int ret = FALSE;
979
980 /* special root key */
981 if (dke->nrLS == 0xffff || dke->nrMS==0xffff) /* eg. the root key has no name */
982 {
983 /* parse the one subkey */
984 if (dke->nextsub != 0xffffffff)
985 {
986 return _w95_parse_dke(hsubkey, creg, rgkn, (_w95dke*)((char*)rgkn+dke->nextsub), level);
987 }
988 /* has no sibling keys */
989 goto error;
990 }
991
992 /* search subblock */
993 if (!(dkh = _w95_lookup_dkh(creg, dke->nrLS, dke->nrMS)))
994 {
995 fprintf(stderr, "dke pointing to missing dkh !\n");
996 goto error;
997 }
998
999 if ( level <= 0 )
1000 {
1001 /* walk sibling keys */
1002 if (dke->next != 0xffffffff )
1003 {
1004 if (!_w95_parse_dke(hkey, creg, rgkn, (_w95dke*)((char*)rgkn+dke->next), level)) goto error;
1005 }
1006
1007 /* create subkey and insert values */
1008 name = _strdupnA( dkh->name, dkh->keynamelen);
1009 if (RegCreateKeyA(hkey, name, &hsubkey)) { free(name); goto error; }
1010 free(name);
1011 if (!_w95_parse_dkv(hsubkey, dkh, dke->nrLS, dke->nrMS)) goto error1;
1012 }
1013
1014 /* next sub key */
1015 if (dke->nextsub != 0xffffffff)
1016 {
1017 if (!_w95_parse_dke(hsubkey, creg, rgkn, (_w95dke*)((char*)rgkn+dke->nextsub), level-1)) goto error1;
1018 }
1019
1020 ret = TRUE;
1021 error1: if (hsubkey != hkey) RegCloseKey(hsubkey);
1022 error: return ret;
1023 }
1024 /* end windows 95 loader */
1025
1026 /******************************************************************************
1027 * NativeRegLoadKey [Internal]
1028 *
1029 * Loads a native registry file (win95/nt)
1030 * hkey root key
1031 * fn filename
1032 * level number of levels to cut away (eg. ".Default" in user.dat)
1033 *
1034 * this function intentionally uses unix file functions to make it possible
1035 * to move it to a seperate registry helper programm
1036 */
1037 static int NativeRegLoadKey( HKEY hkey, char* fn, int level )
1038 {
1039 int fd = 0;
1040 struct stat st;
1041 DOS_FULL_NAME full_name;
1042 int ret = FALSE;
1043 void * base;
1044 char *filetype = "unknown";
1045
1046 if (!DOSFS_GetFullName( fn, 0, &full_name )) return FALSE;
1047
1048 /* map the registry into the memory */
1049 if ((fd = open(full_name.long_name, O_RDONLY | O_NONBLOCK)) == -1) return FALSE;
1050 if ((fstat(fd, &st) == -1)) goto error;
1051 if (!st.st_size) goto error;
1052 if ((base = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0)) == MAP_FAILED) goto error;
1053
1054 switch (*(LPDWORD)base)
1055 {
1056 /* windows 95 'CREG' */
1057 case W95_REG_CREG_ID:
1058 {
1059 _w95creg *creg;
1060 _w95rgkn *rgkn;
1061 _w95dke *dke, *root_dke;
1062 creg = base;
1063 filetype = "win95";
1064 TRACE("Loading %s registry '%s' '%s'\n", filetype, fn, full_name.long_name);
1065
1066 /* load the header (rgkn) */
1067 rgkn = (_w95rgkn*)(creg + 1);
1068 if (rgkn->id != W95_REG_RGKN_ID)
1069 {
1070 ERR("second IFF header not RGKN, but %lx\n", rgkn->id);
1071 goto error1;
1072 }
1073 if (rgkn->root_off != 0x20)
1074 {
1075 ERR("rgkn->root_off not 0x20, please report !\n");
1076 goto error1;
1077 }
1078 if (rgkn->last_dke > rgkn->size)
1079 {
1080 ERR("registry file corrupt! last_dke > size!\n");
1081 goto error1;
1082 }
1083 /* verify last dke */
1084 dke = (_w95dke*)((char*)rgkn + rgkn->last_dke);
1085 if (dke->x1 != 0x80000000)
1086 { /* wrong magic */
1087 ERR("last dke invalid !\n");
1088 goto error1;
1089 }
1090 if (rgkn->size > creg->rgdb_off)
1091 {
1092 ERR("registry file corrupt! rgkn size > rgdb_off !\n");
1093 goto error1;
1094 }
1095 root_dke = (_w95dke*)((char*)rgkn + rgkn->root_off);
1096 if ( (root_dke->prevlvl != 0xffffffff)
1097 || (root_dke->next != 0xffffffff) )
1098 {
1099 ERR("registry file corrupt! invalid root dke !\n");
1100 goto error1;
1101 }
1102
1103 ret = _w95_parse_dke(hkey, creg, rgkn, root_dke, level);
1104 }
1105 break;
1106 /* nt 'regf'*/
1107 case NT_REG_HEADER_BLOCK_ID:
1108 {
1109 nt_regf * regf;
1110 nt_hbin * hbin;
1111 nt_hbin_sub * hbin_sub;
1112 nt_nk* nk;
1113
1114 filetype = "NT";
1115 TRACE("Loading %s registry '%s' '%s'\n", filetype, fn, full_name.long_name);
1116
1117 /* start block */
1118 regf = base;
1119
1120 /* hbin block */
1121 hbin = (nt_hbin*)((char*) base + 0x1000);
1122 if (hbin->id != NT_REG_POOL_BLOCK_ID)
1123 {
1124 ERR( "hbin block invalid\n");
1125 goto error1;
1126 }
1127
1128 /* hbin_sub block */
1129 hbin_sub = (nt_hbin_sub*)&(hbin->hbin_sub);
1130 if ((hbin_sub->data[0] != 'n') || (hbin_sub->data[1] != 'k'))
1131 {
1132 ERR( "hbin_sub block invalid\n");
1133 goto error1;
1134 }
1135
1136 /* nk block */
1137 nk = (nt_nk*)&(hbin_sub->data[0]);
1138 if (nk->Type != NT_REG_ROOT_KEY_BLOCK_TYPE)
1139 {
1140 ERR( "special nk block not found\n");
1141 goto error1;
1142 }
1143
1144 ret = _nt_parse_nk (hkey, (char *) base + 0x1000, nk, level);
1145 }
1146 break;
1147 default:
1148 {
1149 ERR("unknown registry signature !\n");
1150 goto error1;
1151 }
1152 }
1153 error1: if(!ret)
1154 {
1155 ERR("error loading %s registry file %s\n",
1156 filetype, full_name.long_name);
1157 if (!strcmp(filetype, "win95"))
1158 ERR("Please report to a.mohr@mailto.de.\n");
1159 ERR("Make a backup of the file, run a good reg cleaner program and try again !\n");
1160 }
1161 munmap(base, st.st_size);
1162 error: close(fd);
1163 return ret;
1164 }
1165
1166 /* WINDOWS 31 REGISTRY LOADER, supplied by Tor Sjøwall, tor@sn.no */
1167 /*
1168 reghack - windows 3.11 registry data format demo program.
1169
1170 The reg.dat file has 3 parts, a header, a table of 8-byte entries that is
1171 a combined hash table and tree description, and finally a text table.
1172
1173 The header is obvious from the struct header. The taboff1 and taboff2
1174 fields are always 0x20, and their usage is unknown.
1175
1176 The 8-byte entry table has various entry types.
1177
1178 tabent[0] is a root index. The second word has the index of the root of
1179 the directory.
1180 tabent[1..hashsize] is a hash table. The first word in the hash entry is
1181 the index of the key/value that has that hash. Data with the same
1182 hash value are on a circular list. The other three words in the
1183 hash entry are always zero.
1184 tabent[hashsize..tabcnt] is the tree structure. There are two kinds of
1185 entry: dirent and keyent/valent. They are identified by context.
1186 tabent[freeidx] is the first free entry. The first word in a free entry
1187 is the index of the next free entry. The last has 0 as a link.
1188 The other three words in the free list are probably irrelevant.
1189
1190 Entries in text table are preceeded by a word at offset-2. This word
1191 has the value (2*index)+1, where index is the referring keyent/valent
1192 entry in the table. I have no suggestion for the 2* and the +1.
1193 Following the word, there are N bytes of data, as per the keyent/valent
1194 entry length. The offset of the keyent/valent entry is from the start
1195 of the text table to the first data byte.
1196
1197 This information is not available from Microsoft. The data format is
1198 deduced from the reg.dat file by me. Mistakes may
1199 have been made. I claim no rights and give no guarantees for this program.
1200
1201 Tor Sjøwall, tor@sn.no
1202 */
1203
1204 /* reg.dat header format */
1205 struct _w31_header {
1206 char cookie[8]; /* 'SHCC3.10' */
1207 unsigned long taboff1; /* offset of hash table (??) = 0x20 */
1208 unsigned long taboff2; /* offset of index table (??) = 0x20 */
1209 unsigned long tabcnt; /* number of entries in index table */
1210 unsigned long textoff; /* offset of text part */
1211 unsigned long textsize; /* byte size of text part */
1212 unsigned short hashsize; /* hash size */
1213 unsigned short freeidx; /* free index */
1214 };
1215
1216 /* generic format of table entries */
1217 struct _w31_tabent {
1218 unsigned short w0, w1, w2, w3;
1219 };
1220
1221 /* directory tabent: */
1222 struct _w31_dirent {
1223 unsigned short sibling_idx; /* table index of sibling dirent */
1224 unsigned short child_idx; /* table index of child dirent */
1225 unsigned short key_idx; /* table index of key keyent */
1226 unsigned short value_idx; /* table index of value valent */
1227 };
1228
1229 /* key tabent: */
1230 struct _w31_keyent {
1231 unsigned short hash_idx; /* hash chain index for string */
1232 unsigned short refcnt; /* reference count */
1233 unsigned short length; /* length of string */
1234 unsigned short string_off; /* offset of string in text table */
1235 };
1236
1237 /* value tabent: */
1238 struct _w31_valent {
1239 unsigned short hash_idx; /* hash chain index for string */
1240 unsigned short refcnt; /* reference count */
1241 unsigned short length; /* length of string */
1242 unsigned short string_off; /* offset of string in text table */
1243 };
1244
1245 /* recursive helper function to display a directory tree */
1246 void
1247 __w31_dumptree( unsigned short idx,
1248 unsigned char *txt,
1249 struct _w31_tabent *tab,
1250 struct _w31_header *head,
1251 HKEY hkey,
1252 time_t lastmodified,
1253 int level
1254 ) {
1255 struct _w31_dirent *dir;
1256 struct _w31_keyent *key;
1257 struct _w31_valent *val;
1258 HKEY subkey = 0;
1259 static char tail[400];
1260
1261 while (idx!=0) {
1262 dir=(struct _w31_dirent*)&tab[idx];
1263
1264 if (dir->key_idx) {
1265 key = (struct _w31_keyent*)&tab[dir->key_idx];
1266
1267 memcpy(tail,&txt[key->string_off],key->length);
1268 tail[key->length]='\0';
1269 /* all toplevel entries AND the entries in the
1270 * toplevel subdirectory belong to \SOFTWARE\Classes
1271 */
1272 if (!level && !strcmp(tail,".classes")) {
1273 __w31_dumptree(dir->child_idx,txt,tab,head,hkey,lastmodified,level+1);
1274 idx=dir->sibling_idx;
1275 continue;
1276 }
1277 if (subkey) RegCloseKey( subkey );
1278 if (RegCreateKeyA( hkey, tail, &subkey ) != ERROR_SUCCESS) subkey = 0;
1279 /* only add if leaf node or valued node */
1280 if (dir->value_idx!=0||dir->child_idx==0) {
1281 if (dir->value_idx) {
1282 val=(struct _w31_valent*)&tab[dir->value_idx];
1283 memcpy(tail,&txt[val->string_off],val->length);
1284 tail[val->length]='\0';
1285 RegSetValueA( subkey, NULL, REG_SZ, tail, 0 );
1286 }
1287 }
1288 } else {
1289 TRACE("strange: no directory key name, idx=%04x\n", idx);
1290 }
1291 __w31_dumptree(dir->child_idx,txt,tab,head,subkey,lastmodified,level+1);
1292 idx=dir->sibling_idx;
1293 }
1294 if (subkey) RegCloseKey( subkey );
1295 }
1296
1297
1298 /******************************************************************************
1299 * _w31_loadreg [Internal]
1300 */
1301 void _w31_loadreg(void) {
1302 HFILE hf;
1303 struct _w31_header head;
1304 struct _w31_tabent *tab;
1305 unsigned char *txt;
1306 int len;
1307 OFSTRUCT ofs;
1308 BY_HANDLE_FILE_INFORMATION hfinfo;
1309 time_t lastmodified;
1310
1311 TRACE("(void)\n");
1312
1313 hf = OpenFile("reg.dat",&ofs,OF_READ);
1314 if (hf==HFILE_ERROR)
1315 return;
1316
1317 /* read & dump header */
1318 if (sizeof(head)!=_lread(hf,&head,sizeof(head))) {
1319 ERR("reg.dat is too short.\n");
1320 _lclose(hf);
1321 return;
1322 }
1323 if (memcmp(head.cookie, "SHCC3.10", sizeof(head.cookie))!=0) {
1324 ERR("reg.dat has bad signature.\n");
1325 _lclose(hf);
1326 return;
1327 }
1328
1329 len = head.tabcnt * sizeof(struct _w31_tabent);
1330 /* read and dump index table */
1331 tab = xmalloc(len);
1332 if (len!=_lread(hf,tab,len)) {
1333 ERR("couldn't read %d bytes.\n",len);
1334 free(tab);
1335 _lclose(hf);
1336 return;
1337 }
1338
1339 /* read text */
1340 txt = xmalloc(head.textsize);
1341 if (-1==_llseek(hf,head.textoff,SEEK_SET)) {
1342 ERR("couldn't seek to textblock.\n");
1343 free(tab);
1344 free(txt);
1345 _lclose(hf);
1346 return;
1347 }
1348 if (head.textsize!=_lread(hf,txt,head.textsize)) {
1349 ERR("textblock too short (%d instead of %ld).\n",len,head.textsize);
1350 free(tab);
1351 free(txt);
1352 _lclose(hf);
1353 return;
1354 }
1355
1356 if (!GetFileInformationByHandle(hf,&hfinfo)) {
1357 ERR("GetFileInformationByHandle failed?.\n");
1358 free(tab);
1359 free(txt);
1360 _lclose(hf);
1361 return;
1362 }
1363 lastmodified = DOSFS_FileTimeToUnixTime(&hfinfo.ftLastWriteTime,NULL);
1364 __w31_dumptree(tab[0].w1,txt,tab,&head,HKEY_CLASSES_ROOT,lastmodified,0);
1365 free(tab);
1366 free(txt);
1367 _lclose(hf);
1368 return;
1369 }
1370
1371
1372 static void save_at_exit( HKEY hkey, const char *path )
1373 {
1374 const char *confdir = get_config_dir();
1375 size_t len = strlen(confdir) + strlen(path) + 2;
1376 if (len > REQUEST_MAX_VAR_SIZE)
1377 {
1378 ERR( "config dir '%s' too long\n", confdir );
1379 return;
1380 }
1381 SERVER_START_REQ
1382 {
1383 struct save_registry_atexit_request *req = server_alloc_req( sizeof(*req), len );
1384 sprintf( server_data_ptr(req), "%s/%s", confdir, path );
1385 req->hkey = hkey;
1386 server_call( REQ_SAVE_REGISTRY_ATEXIT );
1387 }
1388 SERVER_END_REQ;
1389 }
1390
1391 /* configure save files and start the periodic saving timer */
1392 static void SHELL_InitRegistrySaving( HKEY hkey_users_default )
1393 {
1394 int all = PROFILE_GetWineIniBool( "registry", "SaveOnlyUpdatedKeys", 1 );
1395 int period = PROFILE_GetWineIniInt( "registry", "PeriodicSave", 0 );
1396
1397 /* set saving level (0 for saving everything, 1 for saving only modified keys) */
1398 SERVER_START_REQ
1399 {
1400 struct set_registry_levels_request *req = server_alloc_req( sizeof(*req), 0 );
1401 req->current = 1;
1402 req->saving = !all;
1403 req->period = period * 1000;
1404 server_call( REQ_SET_REGISTRY_LEVELS );
1405 }
1406 SERVER_END_REQ;
1407
1408 if (PROFILE_GetWineIniBool("registry","WritetoHomeRegistries",1))
1409 {
1410 save_at_exit( HKEY_CURRENT_USER, SAVE_CURRENT_USER );
1411 save_at_exit( HKEY_LOCAL_MACHINE, SAVE_LOCAL_MACHINE );
1412 save_at_exit( hkey_users_default, SAVE_DEFAULT_USER );
1413 }
1414 }
1415
1416
1417 /**********************************************************************************
1418 * SetLoadLevel [Internal]
1419 *
1420 * set level to 0 for loading system files
1421 * set level to 1 for loading user files
1422 */
1423 static void SetLoadLevel(int level)
1424 {
1425 SERVER_START_REQ
1426 {
1427 struct set_registry_levels_request *req = server_alloc_req( sizeof(*req), 0 );
1428
1429 req->current = level;
1430 req->saving = 0;
1431 req->period = 0;
1432 server_call( REQ_SET_REGISTRY_LEVELS );
1433 }
1434 SERVER_END_REQ;
1435 }
1436
1437 /**********************************************************************************
1438 * SHELL_LoadRegistry [Internal]
1439 */
1440 #define REG_DONTLOAD -1
1441 #define REG_WIN31 0
1442 #define REG_WIN95 1
1443 #define REG_WINNT 2
1444
1445 void SHELL_LoadRegistry( void )
1446 {
1447 HKEY hkey;
1448 char windir[MAX_PATHNAME_LEN];
1449 char path[MAX_PATHNAME_LEN];
1450 int systemtype = REG_WIN31;
1451 HKEY hkey_users_default;
1452
1453 TRACE("(void)\n");
1454
1455 if (!CLIENT_IsBootThread()) return; /* already loaded */
1456
1457 REGISTRY_Init();
1458 SetLoadLevel(0);
1459
1460 if (RegCreateKeyA(HKEY_USERS, ".Default", &hkey_users_default))
1461 hkey_users_default = 0;
1462
1463 GetWindowsDirectoryA( windir, MAX_PATHNAME_LEN );
1464
1465 if (PROFILE_GetWineIniBool( "Registry", "LoadWindowsRegistryFiles", 1))
1466 {
1467 /* test %windir%/system32/config/system --> winnt */
1468 strcpy(path, windir);
1469 strncat(path, "\\system32\\config\\system", MAX_PATHNAME_LEN - strlen(path) - 1);
1470 if(GetFileAttributesA(path) != -1)
1471 {
1472 systemtype = REG_WINNT;
1473 }
1474 else
1475 {
1476 /* test %windir%/system.dat --> win95 */
1477 strcpy(path, windir);
1478 strncat(path, "\\system.dat", MAX_PATHNAME_LEN - strlen(path) - 1);
1479 if(GetFileAttributesA(path) != -1)
1480 {
1481 systemtype = REG_WIN95;
1482 }
1483 }
1484
1485 if ((systemtype==REG_WINNT)
1486 && (! PROFILE_GetWineIniString( "Wine", "Profile", "", path, MAX_PATHNAME_LEN)))
1487 {
1488 MESSAGE("When you are running with a native NT directory specify\n");
1489 MESSAGE("'Profile=<profiledirectory>' or disable loading of Windows\n");
1490 MESSAGE("registry (LoadWindowsRegistryFiles=N)\n");
1491 systemtype = REG_DONTLOAD;
1492 }
1493 }
1494 else
1495 {
1496 /* only wine registry */
1497 systemtype = REG_DONTLOAD;
1498 }
1499
1500 switch (systemtype)
1501 {
1502 case REG_WIN31:
1503 _w31_loadreg();
1504 break;
1505
1506 case REG_WIN95:
1507 /* Load windows 95 entries */
1508 NativeRegLoadKey(HKEY_LOCAL_MACHINE, "C:\\system.1st", 0);
1509
1510 strcpy(path, windir);
1511 strncat(path, "\\system.dat", MAX_PATHNAME_LEN - strlen(path) - 1);
1512 NativeRegLoadKey(HKEY_LOCAL_MACHINE, path, 0);
1513
1514 if (PROFILE_GetWineIniString( "Wine", "Profile", "", path, MAX_PATHNAME_LEN))
1515 {
1516 /* user specific user.dat */
1517 strncat(path, "\\user.dat", MAX_PATHNAME_LEN - strlen(path) - 1);
1518 if (!NativeRegLoadKey( HKEY_CURRENT_USER, path, 1 ))
1519 {
1520 MESSAGE("can't load win95 user-registry %s\n", path);
1521 MESSAGE("check wine.conf, section [Wine], value 'Profile'\n");
1522 }
1523 /* default user.dat */
1524 if (hkey_users_default)
1525 {
1526 strcpy(path, windir);
1527 strncat(path, "\\user.dat", MAX_PATHNAME_LEN - strlen(path) - 1);
1528 NativeRegLoadKey(hkey_users_default, path, 1);
1529 }
1530 }
1531 else
1532 {
1533 /* global user.dat */
1534 strcpy(path, windir);
1535 strncat(path, "\\user.dat", MAX_PATHNAME_LEN - strlen(path) - 1);
1536 NativeRegLoadKey(HKEY_CURRENT_USER, path, 1);
1537 }
1538 break;
1539
1540 case REG_WINNT:
1541 /* default user.dat */
1542 if (PROFILE_GetWineIniString( "Wine", "Profile", "", path, MAX_PATHNAME_LEN))
1543 {
1544 strncat(path, "\\ntuser.dat", MAX_PATHNAME_LEN - strlen(path) - 1);
1545 if(!NativeRegLoadKey( HKEY_CURRENT_USER, path, 1 ))
1546 {
1547 MESSAGE("can't load NT user-registry %s\n", path);
1548 MESSAGE("check wine.conf, section [Wine], value 'Profile'\n");
1549 }
1550 }
1551
1552 /* default user.dat */
1553 if (hkey_users_default)
1554 {
1555 strcpy(path, windir);
1556 strncat(path, "\\system32\\config\\default", MAX_PATHNAME_LEN - strlen(path) - 1);
1557 NativeRegLoadKey(hkey_users_default, path, 1);
1558 }
1559
1560 /*
1561 * FIXME
1562 * map HLM\System\ControlSet001 to HLM\System\CurrentControlSet
1563 */
1564
1565 if (!RegCreateKeyA(HKEY_LOCAL_MACHINE, "SYSTEM", &hkey))
1566 {
1567 strcpy(path, windir);
1568 strncat(path, "\\system32\\config\\system", MAX_PATHNAME_LEN - strlen(path) - 1);
1569 NativeRegLoadKey(hkey, path, 1);
1570 RegCloseKey(hkey);
1571 }
1572
1573 if (!RegCreateKeyA(HKEY_LOCAL_MACHINE, "SOFTWARE", &hkey))
1574 {
1575 strcpy(path, windir);
1576 strncat(path, "\\system32\\config\\software", MAX_PATHNAME_LEN - strlen(path) - 1);
1577 NativeRegLoadKey(hkey, path, 1);
1578 RegCloseKey(hkey);
1579 }
1580
1581 strcpy(path, windir);
1582 strncat(path, "\\system32\\config\\sam", MAX_PATHNAME_LEN - strlen(path) - 1);
1583 NativeRegLoadKey(HKEY_LOCAL_MACHINE, path, 0);
1584
1585 strcpy(path, windir);
1586 strncat(path, "\\system32\\config\\security", MAX_PATHNAME_LEN - strlen(path) - 1);
1587 NativeRegLoadKey(HKEY_LOCAL_MACHINE, path, 0);
1588
1589 /* this key is generated when the nt-core booted successfully */
1590 if (!RegCreateKeyA(HKEY_LOCAL_MACHINE,"System\\Clone",&hkey))
1591 RegCloseKey(hkey);
1592 break;
1593 } /* switch */
1594
1595 if (PROFILE_GetWineIniBool ("registry","LoadGlobalRegistryFiles", 1))
1596 {
1597 /*
1598 * Load the global HKU hive directly from sysconfdir
1599 */
1600 _wine_loadreg( HKEY_USERS, SAVE_USERS_DEFAULT );
1601
1602 /*
1603 * Load the global machine defaults directly from sysconfdir
1604 */
1605 _wine_loadreg( HKEY_LOCAL_MACHINE, SAVE_LOCAL_MACHINE_DEFAULT );
1606 }
1607
1608 SetLoadLevel(1);
1609
1610 /*
1611 * Load the user saved registries
1612 */
1613 if (PROFILE_GetWineIniBool("registry", "LoadHomeRegistryFiles", 1))
1614 {
1615 const char *confdir = get_config_dir();
1616 int len = strlen(confdir) + 20;
1617 char *fn = path;
1618
1619 if (len > sizeof(path)) fn = HeapAlloc( GetProcessHeap(), 0, len );
1620 /*
1621 * Load user's personal versions of global HKU/.Default keys
1622 */
1623 if (fn)
1624 {
1625 char *str;
1626 strcpy( fn, confdir );
1627 str = fn + strlen(fn);
1628 *str++ = '/';
1629
1630 /* try to load HKU\.Default key only */
1631 strcpy( str, SAVE_DEFAULT_USER );
1632 if (_wine_loadreg( hkey_users_default, fn ))
1633 {
1634 /* if not found load old file containing both HKU\.Default and HKU\user */
1635 strcpy( str, SAVE_LOCAL_USERS_DEFAULT );
1636 _wine_loadreg( HKEY_USERS, fn );
1637 }
1638
1639 strcpy( str, SAVE_CURRENT_USER );
1640 _wine_loadreg( HKEY_CURRENT_USER, fn );
1641
1642 strcpy( str, SAVE_LOCAL_MACHINE );
1643 _wine_loadreg( HKEY_LOCAL_MACHINE, fn );
1644
1645 if (fn != path) HeapFree( GetProcessHeap(), 0, fn );
1646 }
1647 }
1648 SHELL_InitRegistrySaving( hkey_users_default );
1649 RegCloseKey( hkey_users_default );
1650 }
1651
1652 /********************* API FUNCTIONS ***************************************/
1653
1654
1655
1656
1657 /******************************************************************************
1658 * RegFlushKey [KERNEL.227] [ADVAPI32.143]
1659 * Immediately writes key to registry.
1660 * Only returns after data has been written to disk.
1661 *
1662 * FIXME: does it really wait until data is written ?
1663 *
1664 * PARAMS
1665 * hkey [I] Handle of key to write
1666 *
1667 * RETURNS
1668 * Success: ERROR_SUCCESS
1669 * Failure: Error code
1670 */
1671 DWORD WINAPI RegFlushKey( HKEY hkey )
1672 {
1673 FIXME( "(%x): stub\n", hkey );
1674 return ERROR_SUCCESS;
1675 }
1676
1677 /******************************************************************************
1678 * RegConnectRegistryW [ADVAPI32.128]
1679 *
1680 * PARAMS
1681 * lpMachineName [I] Address of name of remote computer
1682 * hHey [I] Predefined registry handle
1683 * phkResult [I] Address of buffer for remote registry handle
1684 */
1685 LONG WINAPI RegConnectRegistryW( LPCWSTR lpMachineName, HKEY hKey,
1686 LPHKEY phkResult )
1687 {
1688 TRACE("(%s,%x,%p): stub\n",debugstr_w(lpMachineName),hKey,phkResult);
1689
1690 if (!lpMachineName || !*lpMachineName) {
1691 /* Use the local machine name */
1692 return RegOpenKey16( hKey, "", phkResult );
1693 }
1694
1695 FIXME("Cannot connect to %s\n",debugstr_w(lpMachineName));
1696 return ERROR_BAD_NETPATH;
1697 }
1698
1699
1700 /******************************************************************************
1701 * RegConnectRegistryA [ADVAPI32.127]
1702 */
1703 LONG WINAPI RegConnectRegistryA( LPCSTR machine, HKEY hkey, LPHKEY reskey )
1704 {
1705 LPWSTR machineW = HEAP_strdupAtoW( GetProcessHeap(), 0, machine );
1706 DWORD ret = RegConnectRegistryW( machineW, hkey, reskey );
1707 HeapFree( GetProcessHeap(), 0, machineW );
1708 return ret;
1709 }
1710
1711
1712 /******************************************************************************
1713 * RegGetKeySecurity [ADVAPI32.144]
1714 * Retrieves a copy of security descriptor protecting the registry key
1715 *
1716 * PARAMS
1717 * hkey [I] Open handle of key to set
1718 * SecurityInformation [I] Descriptor contents
1719 * pSecurityDescriptor [O] Address of descriptor for key
1720 * lpcbSecurityDescriptor [I/O] Address of size of buffer and description
1721 *
1722 * RETURNS
1723 * Success: ERROR_SUCCESS
1724 * Failure: Error code
1725 */
1726 LONG WINAPI RegGetKeySecurity( HKEY hkey,
1727 SECURITY_INFORMATION SecurityInformation,
1728 PSECURITY_DESCRIPTOR pSecurityDescriptor,
1729 LPDWORD lpcbSecurityDescriptor )
1730 {
1731 TRACE("(%x,%ld,%p,%ld)\n",hkey,SecurityInformation,pSecurityDescriptor,
1732 lpcbSecurityDescriptor?*lpcbSecurityDescriptor:0);
1733
1734 /* FIXME: Check for valid SecurityInformation values */
1735
1736 if (*lpcbSecurityDescriptor < sizeof(SECURITY_DESCRIPTOR))
1737 return ERROR_INSUFFICIENT_BUFFER;
1738
1739 FIXME("(%x,%ld,%p,%ld): stub\n",hkey,SecurityInformation,
1740 pSecurityDescriptor,lpcbSecurityDescriptor?*lpcbSecurityDescriptor:0);
1741
1742 return ERROR_SUCCESS;
1743 }
1744
1745
1746 /******************************************************************************
1747 * RegNotifyChangeKeyValue [ADVAPI32.???]
1748 *
1749 * PARAMS
1750 * hkey [I] Handle of key to watch
1751 * fWatchSubTree [I] Flag for subkey notification
1752 * fdwNotifyFilter [I] Changes to be reported
1753 * hEvent [I] Handle of signaled event
1754 * fAsync [I] Flag for asynchronous reporting
1755 */
1756 LONG WINAPI RegNotifyChangeKeyValue( HKEY hkey, BOOL fWatchSubTree,
1757 DWORD fdwNotifyFilter, HANDLE hEvent,
1758 BOOL fAsync )
1759 {
1760 FIXME("(%x,%i,%ld,%x,%i): stub\n",hkey,fWatchSubTree,fdwNotifyFilter,
1761 hEvent,fAsync);
1762 return ERROR_SUCCESS;
1763 }
1764
1765
1766 /******************************************************************************
1767 * RegUnLoadKeyW [ADVAPI32.173]
1768 *
1769 * PARAMS
1770 * hkey [I] Handle of open key
1771 * lpSubKey [I] Address of name of subkey to unload
1772 */
1773 LONG WINAPI RegUnLoadKeyW( HKEY hkey, LPCWSTR lpSubKey )
1774 {
1775 FIXME("(%x,%s): stub\n",hkey, debugstr_w(lpSubKey));
1776 return ERROR_SUCCESS;
1777 }
1778
1779
1780 /******************************************************************************
1781 * RegUnLoadKeyA [ADVAPI32.172]
1782 */
1783 LONG WINAPI RegUnLoadKeyA( HKEY hkey, LPCSTR lpSubKey )
1784 {
1785 LPWSTR lpSubKeyW = HEAP_strdupAtoW( GetProcessHeap(), 0, lpSubKey );
1786 LONG ret = RegUnLoadKeyW( hkey, lpSubKeyW );
1787 if(lpSubKeyW) HeapFree( GetProcessHeap(), 0, lpSubKeyW);
1788 return ret;
1789 }
1790
1791
1792 /******************************************************************************
1793 * RegSetKeySecurity [ADVAPI32.167]
1794 *
1795 * PARAMS
1796 * hkey [I] Open handle of key to set
1797 * SecurityInfo [I] Descriptor contents
1798 * pSecurityDesc [I] Address of descriptor for key
1799 */
1800 LONG WINAPI RegSetKeySecurity( HKEY hkey, SECURITY_INFORMATION SecurityInfo,
1801 PSECURITY_DESCRIPTOR pSecurityDesc )
1802 {
1803 TRACE("(%x,%ld,%p)\n",hkey,SecurityInfo,pSecurityDesc);
1804
1805 /* It seems to perform this check before the hkey check */
1806 if ((SecurityInfo & OWNER_SECURITY_INFORMATION) ||
1807 (SecurityInfo & GROUP_SECURITY_INFORMATION) ||
1808 (SecurityInfo & DACL_SECURITY_INFORMATION) ||
1809 (SecurityInfo & SACL_SECURITY_INFORMATION)) {
1810 /* Param OK */
1811 } else
1812 return ERROR_INVALID_PARAMETER;
1813
1814 if (!pSecurityDesc)
1815 return ERROR_INVALID_PARAMETER;
1816
1817 FIXME(":(%x,%ld,%p): stub\n",hkey,SecurityInfo,pSecurityDesc);
1818
1819 return ERROR_SUCCESS;
1820 }
1821
1822
1823 /******************************************************************************
1824 * RegRestoreKeyW [ADVAPI32.164]
1825 *
1826 * PARAMS
1827 * hkey [I] Handle of key where restore begins
1828 * lpFile [I] Address of filename containing saved tree
1829 * dwFlags [I] Optional flags
1830 */
1831 LONG WINAPI RegRestoreKeyW( HKEY hkey, LPCWSTR lpFile, DWORD dwFlags )
1832 {
1833 TRACE("(%x,%s,%ld)\n",hkey,debugstr_w(lpFile),dwFlags);
1834
1835 /* It seems to do this check before the hkey check */
1836 if (!lpFile || !*lpFile)
1837 return ERROR_INVALID_PARAMETER;
1838
1839 FIXME("(%x,%s,%ld): stub\n",hkey,debugstr_w(lpFile),dwFlags);
1840
1841 /* Check for file existence */
1842
1843 return ERROR_SUCCESS;
1844 }
1845
1846
1847 /******************************************************************************
1848 * RegRestoreKeyA [ADVAPI32.163]
1849 */
1850 LONG WINAPI RegRestoreKeyA( HKEY hkey, LPCSTR lpFile, DWORD dwFlags )
1851 {
1852 LPWSTR lpFileW = HEAP_strdupAtoW( GetProcessHeap(), 0, lpFile );
1853 LONG ret = RegRestoreKeyW( hkey, lpFileW, dwFlags );
1854 HeapFree( GetProcessHeap(), 0, lpFileW );
1855 return ret;
1856 }
1857
1858
1859 /******************************************************************************
1860 * RegReplaceKeyW [ADVAPI32.162]
1861 *
1862 * PARAMS
1863 * hkey [I] Handle of open key
1864 * lpSubKey [I] Address of name of subkey
1865 * lpNewFile [I] Address of filename for file with new data
1866 * lpOldFile [I] Address of filename for backup file
1867 */
1868 LONG WINAPI RegReplaceKeyW( HKEY hkey, LPCWSTR lpSubKey, LPCWSTR lpNewFile,
1869 LPCWSTR lpOldFile )
1870 {
1871 FIXME("(%x,%s,%s,%s): stub\n", hkey, debugstr_w(lpSubKey),
1872 debugstr_w(lpNewFile),debugstr_w(lpOldFile));
1873 return ERROR_SUCCESS;
1874 }
1875
1876
1877 /******************************************************************************
1878 * RegReplaceKeyA [ADVAPI32.161]
1879 */
1880 LONG WINAPI RegReplaceKeyA( HKEY hkey, LPCSTR lpSubKey, LPCSTR lpNewFile,
1881 LPCSTR lpOldFile )
1882 {
1883 LPWSTR lpSubKeyW = HEAP_strdupAtoW( GetProcessHeap(), 0, lpSubKey );
1884 LPWSTR lpNewFileW = HEAP_strdupAtoW( GetProcessHeap(), 0, lpNewFile );
1885 LPWSTR lpOldFileW = HEAP_strdupAtoW( GetProcessHeap(), 0, lpOldFile );
1886 LONG ret = RegReplaceKeyW( hkey, lpSubKeyW, lpNewFileW, lpOldFileW );
1887 HeapFree( GetProcessHeap(), 0, lpOldFileW );
1888 HeapFree( GetProcessHeap(), 0, lpNewFileW );
1889 HeapFree( GetProcessHeap(), 0, lpSubKeyW );
1890 return ret;
1891 }
1892
1893
1894
1895
1896
1897
1898 /* 16-bit functions */
1899
1900 /* 0 and 1 are valid rootkeys in win16 shell.dll and are used by
1901 * some programs. Do not remove those cases. -MM
1902 */
1903 static inline void fix_win16_hkey( HKEY *hkey )
1904 {
1905 if (*hkey == 0 || *hkey == 1) *hkey = HKEY_CLASSES_ROOT;
1906 }
1907
1908 /******************************************************************************
1909 * RegEnumKey16 [KERNEL.216] [SHELL.7]
1910 */
1911 DWORD WINAPI RegEnumKey16( HKEY hkey, DWORD index, LPSTR name, DWORD name_len )
1912 {
1913 fix_win16_hkey( &hkey );
1914 return RegEnumKeyA( hkey, index, name, name_len );
1915 }
1916
1917 /******************************************************************************
1918 * RegOpenKey16 [KERNEL.217] [SHELL.1]
1919 */
1920 DWORD WINAPI RegOpenKey16( HKEY hkey, LPCSTR name, LPHKEY retkey )
1921 {
1922 fix_win16_hkey( &hkey );
1923 return RegOpenKeyA( hkey, name, retkey );
1924 }
1925
1926 /******************************************************************************
1927 * RegCreateKey16 [KERNEL.218] [SHELL.2]
1928 */
1929 DWORD WINAPI RegCreateKey16( HKEY hkey, LPCSTR name, LPHKEY retkey )
1930 {
1931 fix_win16_hkey( &hkey );
1932 return RegCreateKeyA( hkey, name, retkey );
1933 }
1934
1935 /******************************************************************************
1936 * RegDeleteKey16 [KERNEL.219] [SHELL.4]
1937 */
1938 DWORD WINAPI RegDeleteKey16( HKEY hkey, LPCSTR name )
1939 {
1940 fix_win16_hkey( &hkey );
1941 return RegDeleteKeyA( hkey, name );
1942 }
1943
1944 /******************************************************************************
1945 * RegCloseKey16 [KERNEL.220] [SHELL.3]
1946 */
1947 DWORD WINAPI RegCloseKey16( HKEY hkey )
1948 {
1949 fix_win16_hkey( &hkey );
1950 return RegCloseKey( hkey );
1951 }
1952
1953 /******************************************************************************
1954 * RegSetValue16 [KERNEL.221] [SHELL.5]
1955 */
1956 DWORD WINAPI RegSetValue16( HKEY hkey, LPCSTR name, DWORD type, LPCSTR data, DWORD count )
1957 {
1958 fix_win16_hkey( &hkey );
1959 return RegSetValueA( hkey, name, type, data, count );
1960 }
1961
1962 /******************************************************************************
1963 * RegDeleteValue16 [KERNEL.222]
1964 */
1965 DWORD WINAPI RegDeleteValue16( HKEY hkey, LPSTR name )
1966 {
1967 fix_win16_hkey( &hkey );
1968 return RegDeleteValueA( hkey, name );
1969 }
1970
1971 /******************************************************************************
1972 * RegEnumValue16 [KERNEL.223]
1973 */
1974 DWORD WINAPI RegEnumValue16( HKEY hkey, DWORD index, LPSTR value, LPDWORD val_count,
1975 LPDWORD reserved, LPDWORD type, LPBYTE data, LPDWORD count )
1976 {
1977 fix_win16_hkey( &hkey );
1978 return RegEnumValueA( hkey, index, value, val_count, reserved, type, data, count );
1979 }
1980
1981 /******************************************************************************
1982 * RegQueryValue16 [KERNEL.224] [SHELL.6]
1983 *
1984 * NOTES
1985 * Is this HACK still applicable?
1986 *
1987 * HACK
1988 * The 16bit RegQueryValue doesn't handle selectorblocks anyway, so we just
1989 * mask out the high 16 bit. This (not so much incidently) hopefully fixes
1990 * Aldus FH4)
1991 */
1992 DWORD WINAPI RegQueryValue16( HKEY hkey, LPCSTR name, LPSTR data, LPDWORD count )
1993 {
1994 fix_win16_hkey( &hkey );
1995 if (count) *count &= 0xffff;
1996 return RegQueryValueA( hkey, name, data, count );
1997 }
1998
1999 /******************************************************************************
2000 * RegQueryValueEx16 [KERNEL.225]
2001 */
2002 DWORD WINAPI RegQueryValueEx16( HKEY hkey, LPCSTR name, LPDWORD reserved, LPDWORD type,
2003 LPBYTE data, LPDWORD count )
2004 {
2005 fix_win16_hkey( &hkey );
2006 return RegQueryValueExA( hkey, name, reserved, type, data, count );
2007 }
2008
2009 /******************************************************************************
2010 * RegSetValueEx16 [KERNEL.226]
2011 */
2012 DWORD WINAPI RegSetValueEx16( HKEY hkey, LPCSTR name, DWORD reserved, DWORD type,
2013 CONST BYTE *data, DWORD count )
2014 {
2015 fix_win16_hkey( &hkey );
2016 return RegSetValueExA( hkey, name, reserved, type, data, count );
2017 }
Windows API implementation