?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Super-crude implementation for NdrClientCall2.
[wine.git] / misc / registry.c
blob8eae5438711c0822f34c5ee62fdd56a286da68cb
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 * This library is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU Lesser General Public
14 * License as published by the Free Software Foundation; either
15 * version 2.1 of the License, or (at your option) any later version.
16 *
17 * This library is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * Lesser General Public License for more details.
21 *
22 * You should have received a copy of the GNU Lesser General Public
23 * License along with this library; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 *
26 * NOTES
27 * When changing this file, please re-run the regtest program to ensure
28 * the conditions are handled properly.
29 *
30 * TODO
31 * Security access
32 * Option handling
33 * Time for RegEnumKey*, RegQueryInfoKey*
34 */
35
36 #include "config.h"
37 #include "wine/port.h"
38
39 #include <stdlib.h>
40 #include <string.h>
41 #include <stdio.h>
42 #ifdef HAVE_UNISTD_H
43 # include <unistd.h>
44 #endif
45 #include <errno.h>
46 #include <sys/types.h>
47 #include <sys/stat.h>
48 #include <fcntl.h>
49 #ifdef HAVE_SYS_MMAN_H
50 # include <sys/mman.h>
51 #endif
52
53 #include "winerror.h"
54 #include "winnt.h"
55 #include "winreg.h"
56
57 #include "wine/winbase16.h"
58 #include "wine/library.h"
59 #include "wine/server.h"
60 #include "wine/unicode.h"
61 #include "file.h"
62
63 #include "wine/debug.h"
64
65 WINE_DEFAULT_DEBUG_CHANNEL(reg);
66
67 #define SAVE_GLOBAL_REGBRANCH_USER_DEFAULT "/wine.userreg"
68 #define SAVE_GLOBAL_REGBRANCH_LOCAL_MACHINE "/wine.systemreg"
69
70 /* relative in ~user/.wine/ : */
71 #define SAVE_LOCAL_REGBRANCH_CURRENT_USER "user.reg"
72 #define SAVE_LOCAL_REGBRANCH_USER_DEFAULT "userdef.reg"
73 #define SAVE_LOCAL_REGBRANCH_LOCAL_MACHINE "system.reg"
74
75 static const WCHAR ClassesRootW[] = {'M','a','c','h','i','n','e','\\',
76 'S','o','f','t','w','a','r','e','\\',
77 'C','l','a','s','s','e','s',0};
78
79 /* _xmalloc [Internal] */
80 static void *_xmalloc( size_t size )
81 {
82 void *res;
83
84 res = malloc (size ? size : 1);
85 if (res == NULL) {
86 WARN("Virtual memory exhausted.\n");
87 exit (1);
88 }
89 return res;
90 }
91
92 /* _strdupnA [Internal] */
93 static LPSTR _strdupnA(LPCSTR str,size_t len)
94 {
95 LPSTR ret;
96
97 if (!str) return NULL;
98 ret = _xmalloc( len + 1 );
99 memcpy( ret, str, len );
100 ret[len] = 0x00;
101 return ret;
102 }
103
104 /* convert ansi string to unicode [Internal] */
105 static LPWSTR _strdupnAtoW(LPCSTR strA,size_t lenA)
106 {
107 LPWSTR ret;
108 size_t lenW;
109
110 if (!strA) return NULL;
111 lenW = MultiByteToWideChar(CP_ACP,0,strA,lenA,NULL,0);
112 ret = _xmalloc(lenW*sizeof(WCHAR)+sizeof(WCHAR));
113 MultiByteToWideChar(CP_ACP,0,strA,lenA,ret,lenW);
114 ret[lenW] = 0;
115 return ret;
116 }
117
118 /* dump a Unicode string with proper escaping [Internal] */
119 /* FIXME: this code duplicates server/unicode.c */
120 static int _dump_strW(const WCHAR *str,size_t len,FILE *f,char escape[2])
121 {
122 static const char escapes[32] = ".......abtnvfr.............e....";
123 char buffer[256];
124 LPSTR pos = buffer;
125 int count = 0;
126
127 for (; len; str++, len--)
128 {
129 if (pos > buffer + sizeof(buffer) - 8)
130 {
131 fwrite( buffer, pos - buffer, 1, f );
132 count += pos - buffer;
133 pos = buffer;
134 }
135 if (*str > 127) /* hex escape */
136 {
137 if (len > 1 && str[1] < 128 && isxdigit((char)str[1]))
138 pos += sprintf( pos, "\\x%04x", *str );
139 else
140 pos += sprintf( pos, "\\x%x", *str );
141 continue;
142 }
143 if (*str < 32) /* octal or C escape */
144 {
145 if (!*str && len == 1) continue; /* do not output terminating NULL */
146 if (escapes[*str] != '.')
147 pos += sprintf( pos, "\\%c", escapes[*str] );
148 else if (len > 1 && str[1] >= '0' && str[1] <= '7')
149 pos += sprintf( pos, "\\%03o", *str );
150 else
151 pos += sprintf( pos, "\\%o", *str );
152 continue;
153 }
154 if (*str == '\\' || *str == escape[0] || *str == escape[1]) *pos++ = '\\';
155 *pos++ = *str;
156 }
157 fwrite( buffer, pos - buffer, 1, f );
158 count += pos - buffer;
159 return count;
160 }
161
162 /* convert ansi string to unicode and dump with proper escaping [Internal] */
163 static int _dump_strAtoW(LPCSTR strA,size_t len,FILE *f,char escape[2])
164 {
165 WCHAR *strW;
166 int ret;
167
168 if (strA == NULL) return 0;
169 strW = _strdupnAtoW(strA,len);
170 ret = _dump_strW(strW,len,f,escape);
171 free(strW);
172 return ret;
173 }
174
175 /* a key value */
176 /* FIXME: this code duplicates server/registry.c */
177 struct key_value {
178 WCHAR *nameW; /* value name */
179 int type; /* value type */
180 size_t len; /* value data length in bytes */
181 void *data; /* pointer to value data */
182 };
183
184 /* dump a value to a text file */
185 /* FIXME: this code duplicates server/registry.c */
186 static void _dump_value(struct key_value *value,FILE *f)
187 {
188 int i, count;
189
190 if (value->nameW[0]) {
191 fputc( '\"', f );
192 count = 1 + _dump_strW(value->nameW,strlenW(value->nameW),f,"\"\"");
193 count += fprintf( f, "\"=" );
194 }
195 else count = fprintf( f, "@=" );
196
197 switch(value->type) {
198 case REG_SZ:
199 case REG_EXPAND_SZ:
200 case REG_MULTI_SZ:
201 if (value->type != REG_SZ) fprintf( f, "str(%d):", value->type );
202 fputc( '\"', f );
203 if (value->data) _dump_strW(value->data,value->len/sizeof(WCHAR),f,"\"\"");
204 fputc( '\"', f );
205 break;
206 case REG_DWORD:
207 if (value->len == sizeof(DWORD)) {
208 DWORD dw;
209 memcpy( &dw, value->data, sizeof(DWORD) );
210 fprintf( f, "dword:%08lx", dw );
211 break;
212 }
213 /* else fall through */
214 default:
215 if (value->type == REG_BINARY) count += fprintf( f, "hex:" );
216 else count += fprintf( f, "hex(%x):", value->type );
217 for (i = 0; i < value->len; i++) {
218 count += fprintf( f, "%02x", *((unsigned char *)value->data + i) );
219 if (i < value->len-1) {
220 fputc( ',', f );
221 if (++count > 76) {
222 fprintf( f, "\\\n " );
223 count = 2;
224 }
225 }
226 }
227 break;
228 }
229 fputc( '\n', f );
230 }
231
232 /******************************************************************/
233 /* WINDOWS 31 REGISTRY LOADER, supplied by Tor Sjøwall, tor@sn.no */
234 /*
235 reghack - windows 3.11 registry data format demo program.
236
237 The reg.dat file has 3 parts, a header, a table of 8-byte entries that is
238 a combined hash table and tree description, and finally a text table.
239
240 The header is obvious from the struct header. The taboff1 and taboff2
241 fields are always 0x20, and their usage is unknown.
242
243 The 8-byte entry table has various entry types.
244
245 tabent[0] is a root index. The second word has the index of the root of
246 the directory.
247 tabent[1..hashsize] is a hash table. The first word in the hash entry is
248 the index of the key/value that has that hash. Data with the same
249 hash value are on a circular list. The other three words in the
250 hash entry are always zero.
251 tabent[hashsize..tabcnt] is the tree structure. There are two kinds of
252 entry: dirent and keyent/valent. They are identified by context.
253 tabent[freeidx] is the first free entry. The first word in a free entry
254 is the index of the next free entry. The last has 0 as a link.
255 The other three words in the free list are probably irrelevant.
256
257 Entries in text table are preceded by a word at offset-2. This word
258 has the value (2*index)+1, where index is the referring keyent/valent
259 entry in the table. I have no suggestion for the 2* and the +1.
260 Following the word, there are N bytes of data, as per the keyent/valent
261 entry length. The offset of the keyent/valent entry is from the start
262 of the text table to the first data byte.
263
264 This information is not available from Microsoft. The data format is
265 deduced from the reg.dat file by me. Mistakes may
266 have been made. I claim no rights and give no guarantees for this program.
267
268 Tor Sjøwall, tor@sn.no
269 */
270
271 /* reg.dat header format */
272 struct _w31_header {
273 char cookie[8]; /* 'SHCC3.10' */
274 unsigned long taboff1; /* offset of hash table (??) = 0x20 */
275 unsigned long taboff2; /* offset of index table (??) = 0x20 */
276 unsigned long tabcnt; /* number of entries in index table */
277 unsigned long textoff; /* offset of text part */
278 unsigned long textsize; /* byte size of text part */
279 unsigned short hashsize; /* hash size */
280 unsigned short freeidx; /* free index */
281 };
282
283 /* generic format of table entries */
284 struct _w31_tabent {
285 unsigned short w0, w1, w2, w3;
286 };
287
288 /* directory tabent: */
289 struct _w31_dirent {
290 unsigned short sibling_idx; /* table index of sibling dirent */
291 unsigned short child_idx; /* table index of child dirent */
292 unsigned short key_idx; /* table index of key keyent */
293 unsigned short value_idx; /* table index of value valent */
294 };
295
296 /* key tabent: */
297 struct _w31_keyent {
298 unsigned short hash_idx; /* hash chain index for string */
299 unsigned short refcnt; /* reference count */
300 unsigned short length; /* length of string */
301 unsigned short string_off; /* offset of string in text table */
302 };
303
304 /* value tabent: */
305 struct _w31_valent {
306 unsigned short hash_idx; /* hash chain index for string */
307 unsigned short refcnt; /* reference count */
308 unsigned short length; /* length of string */
309 unsigned short string_off; /* offset of string in text table */
310 };
311
312 /* recursive helper function to display a directory tree [Internal] */
313 void _w31_dumptree(unsigned short idx,unsigned char *txt,struct _w31_tabent *tab,struct _w31_header *head,HKEY hkey,time_t lastmodified, int level)
314 {
315 static const WCHAR classesW[] = {'.','c','l','a','s','s','e','s',0};
316 struct _w31_dirent *dir;
317 struct _w31_keyent *key;
318 struct _w31_valent *val;
319 HKEY subkey = 0;
320 OBJECT_ATTRIBUTES attr;
321 UNICODE_STRING nameW, valueW;
322 static WCHAR tail[400];
323
324 attr.Length = sizeof(attr);
325 attr.RootDirectory = hkey;
326 attr.ObjectName = &nameW;
327 attr.Attributes = 0;
328 attr.SecurityDescriptor = NULL;
329 attr.SecurityQualityOfService = NULL;
330 RtlInitUnicodeString( &valueW, NULL );
331
332 while (idx!=0) {
333 dir=(struct _w31_dirent*)&tab[idx];
334
335 if (dir->key_idx) {
336 DWORD len;
337 key = (struct _w31_keyent*)&tab[dir->key_idx];
338
339 RtlMultiByteToUnicodeN( tail, sizeof(tail)-sizeof(WCHAR), &len,
340 &txt[key->string_off], key->length);
341 tail[len/sizeof(WCHAR)] = 0;
342
343 /* all toplevel entries AND the entries in the
344 * toplevel subdirectory belong to \SOFTWARE\Classes
345 */
346 if (!level && !strcmpW(tail,classesW))
347 {
348 _w31_dumptree(dir->child_idx,txt,tab,head,hkey,lastmodified,level+1);
349 idx=dir->sibling_idx;
350 continue;
351 }
352
353 if (subkey) NtClose( subkey );
354 RtlInitUnicodeString( &nameW, tail );
355 if (NtCreateKey( &subkey, KEY_ALL_ACCESS, &attr, 0, NULL, 0, NULL )) subkey = 0;
356
357 /* only add if leaf node or valued node */
358 if (dir->value_idx!=0||dir->child_idx==0) {
359 if (dir->value_idx) {
360 DWORD len;
361 val=(struct _w31_valent*)&tab[dir->value_idx];
362 RtlMultiByteToUnicodeN( tail, sizeof(tail) - sizeof(WCHAR), &len,
363 &txt[val->string_off], val->length);
364 tail[len/sizeof(WCHAR)] = 0;
365 NtSetValueKey( subkey, &valueW, 0, REG_SZ, tail, len + sizeof(WCHAR) );
366 }
367 }
368 } else TRACE("strange: no directory key name, idx=%04x\n", idx);
369 _w31_dumptree(dir->child_idx,txt,tab,head,subkey,lastmodified,level+1);
370 idx=dir->sibling_idx;
371 }
372 if (subkey) NtClose( subkey );
373 }
374
375
376 /******************************************************************************
377 * _w31_loadreg [Internal]
378 */
379 void _w31_loadreg(void)
380 {
381 HFILE hf;
382 HKEY root;
383 OBJECT_ATTRIBUTES attr;
384 UNICODE_STRING nameW;
385 struct _w31_header head;
386 struct _w31_tabent *tab;
387 unsigned char *txt;
388 unsigned int len;
389 OFSTRUCT ofs;
390 BY_HANDLE_FILE_INFORMATION hfinfo;
391 time_t lastmodified;
392
393 TRACE("(void)\n");
394
395 hf = OpenFile("reg.dat",&ofs,OF_READ);
396 if (hf==HFILE_ERROR) return;
397
398 /* read & dump header */
399 if (sizeof(head)!=_lread(hf,&head,sizeof(head))) {
400 ERR("reg.dat is too short.\n");
401 _lclose(hf);
402 return;
403 }
404 if (memcmp(head.cookie, "SHCC3.10", sizeof(head.cookie))!=0) {
405 ERR("reg.dat has bad signature.\n");
406 _lclose(hf);
407 return;
408 }
409
410 len = head.tabcnt * sizeof(struct _w31_tabent);
411 /* read and dump index table */
412 tab = _xmalloc(len);
413 if (len!=_lread(hf,tab,len)) {
414 ERR("couldn't read %d bytes.\n",len);
415 free(tab);
416 _lclose(hf);
417 return;
418 }
419
420 /* read text */
421 txt = _xmalloc(head.textsize);
422 if (-1==_llseek(hf,head.textoff,SEEK_SET)) {
423 ERR("couldn't seek to textblock.\n");
424 free(tab);
425 free(txt);
426 _lclose(hf);
427 return;
428 }
429 if (head.textsize!=_lread(hf,txt,head.textsize)) {
430 ERR("textblock too short (%d instead of %ld).\n",len,head.textsize);
431 free(tab);
432 free(txt);
433 _lclose(hf);
434 return;
435 }
436
437 if (!GetFileInformationByHandle(hf,&hfinfo)) {
438 ERR("GetFileInformationByHandle failed?.\n");
439 free(tab);
440 free(txt);
441 _lclose(hf);
442 return;
443 }
444 lastmodified = DOSFS_FileTimeToUnixTime(&hfinfo.ftLastWriteTime,NULL);
445
446 attr.Length = sizeof(attr);
447 attr.RootDirectory = 0;
448 attr.ObjectName = &nameW;
449 attr.Attributes = 0;
450 attr.SecurityDescriptor = NULL;
451 attr.SecurityQualityOfService = NULL;
452 RtlInitUnicodeString( &nameW, ClassesRootW );
453
454 if (!NtCreateKey( &root, KEY_ALL_ACCESS, &attr, 0, NULL, 0, NULL ))
455 {
456 _w31_dumptree(tab[0].w1,txt,tab,&head,root,lastmodified,0);
457 NtClose( root );
458 }
459 free(tab);
460 free(txt);
461 _lclose(hf);
462 return;
463 }
464
465 /***********************************************************************************/
466 /* windows 95 registry loader */
467 /***********************************************************************************/
468
469 /* SECTION 1: main header
470 *
471 * once at offset 0
472 */
473 #define W95_REG_CREG_ID 0x47455243
474
475 typedef struct {
476 DWORD id; /* "CREG" = W95_REG_CREG_ID */
477 DWORD version; /* ???? 0x00010000 */
478 DWORD rgdb_off; /* 0x08 Offset of 1st RGDB-block */
479 DWORD uk2; /* 0x0c */
480 WORD rgdb_num; /* 0x10 # of RGDB-blocks */
481 WORD uk3;
482 DWORD uk[3];
483 /* rgkn */
484 } _w95creg;
485
486 /* SECTION 2: Directory information (tree structure)
487 *
488 * once on offset 0x20
489 *
490 * structure: [rgkn][dke]* (repeat till last_dke is reached)
491 */
492 #define W95_REG_RGKN_ID 0x4e4b4752
493
494 typedef struct {
495 DWORD id; /*"RGKN" = W95_REG_RGKN_ID */
496 DWORD size; /* Size of the RGKN-block */
497 DWORD root_off; /* Rel. Offset of the root-record */
498 DWORD last_dke; /* Offset to last DKE ? */
499 DWORD uk[4];
500 } _w95rgkn;
501
502 /* Disk Key Entry Structure
503 *
504 * the 1st entry in a "usual" registry file is a nul-entry with subkeys: the
505 * hive itself. It looks the same like other keys. Even the ID-number can
506 * be any value.
507 *
508 * The "hash"-value is a value representing the key's name. Windows will not
509 * search for the name, but for a matching hash-value. if it finds one, it
510 * will compare the actual string info, otherwise continue with the next key.
511 * To calculate the hash initialize a D-Word with 0 and add all ASCII-values
512 * of the string which are smaller than 0x80 (128) to this D-Word.
513 *
514 * If you want to modify key names, also modify the hash-values, since they
515 * cannot be found again (although they would be displayed in REGEDIT)
516 * End of list-pointers are filled with 0xFFFFFFFF
517 *
518 * Disk keys are layed out flat ... But, sometimes, nrLS and nrMS are both
519 * 0xFFFF, which means skipping over nextkeyoffset bytes (including this
520 * structure) and reading another RGDB_section.
521 *
522 * The last DKE (see field last_dke in _w95_rgkn) has only 3 DWORDs with
523 * 0x80000000 (EOL indicator ?) as x1, the hash value and 0xFFFFFFFF as x3.
524 * The remaining space between last_dke and the offset calculated from
525 * rgkn->size seems to be free for use for more dke:s.
526 * So it seems if more dke:s are added, they are added to that space and
527 * last_dke is grown, and in case that "free" space is out, the space
528 * gets grown and rgkn->size gets adjusted.
529 *
530 * there is a one to one relationship between dke and dkh
531 */
532 /* key struct, once per key */
533 typedef struct {
534 DWORD x1; /* Free entry indicator(?) */
535 DWORD hash; /* sum of bytes of keyname */
536 DWORD x3; /* Root key indicator? usually 0xFFFFFFFF */
537 DWORD prevlvl; /* offset of previous key */
538 DWORD nextsub; /* offset of child key */
539 DWORD next; /* offset of sibling key */
540 WORD nrLS; /* id inside the rgdb block */
541 WORD nrMS; /* number of the rgdb block */
542 } _w95dke;
543
544 /* SECTION 3: key information, values and data
545 *
546 * structure:
547 * section: [blocks]* (repeat creg->rgdb_num times)
548 * blocks: [rgdb] [subblocks]* (repeat till block size reached )
549 * subblocks: [dkh] [dkv]* (repeat dkh->values times )
550 *
551 * An interesting relationship exists in RGDB_section. The DWORD value
552 * at offset 0x10 equals the one at offset 0x04 minus the one at offset 0x08.
553 * I have no idea at the moment what this means. (Kevin Cozens)
554 */
555
556 /* block header, once per block */
557 #define W95_REG_RGDB_ID 0x42444752
558
559 typedef struct {
560 DWORD id; /* 0x00 'RGDB' = W95_REG_RGDB_ID */
561 DWORD size; /* 0x04 */
562 DWORD uk1; /* 0x08 */
563 DWORD uk2; /* 0x0c */
564 DWORD uk3; /* 0x10 */
565 DWORD uk4; /* 0x14 */
566 DWORD uk5; /* 0x18 */
567 DWORD uk6; /* 0x1c */
568 /* dkh */
569 } _w95rgdb;
570
571 /* Disk Key Header structure (RGDB part), once per key */
572 typedef struct {
573 DWORD nextkeyoff; /* 0x00 offset to next dkh */
574 WORD nrLS; /* 0x04 id inside the rgdb block */
575 WORD nrMS; /* 0x06 number of the rgdb block */
576 DWORD bytesused; /* 0x08 */
577 WORD keynamelen; /* 0x0c len of name */
578 WORD values; /* 0x0e number of values */
579 DWORD xx1; /* 0x10 */
580 char name[1]; /* 0x14 */
581 /* dkv */ /* 0x14 + keynamelen */
582 } _w95dkh;
583
584 /* Disk Key Value structure, once per value */
585 typedef struct {
586 DWORD type; /* 0x00 */
587 DWORD x1; /* 0x04 */
588 WORD valnamelen; /* 0x08 length of name, 0 is default key */
589 WORD valdatalen; /* 0x0A length of data */
590 char name[1]; /* 0x0c */
591 /* raw data */ /* 0x0c + valnamelen */
592 } _w95dkv;
593
594 /******************************************************************************
595 * _w95_lookup_dkh [Internal]
596 *
597 * seeks the dkh belonging to a dke
598 */
599 static _w95dkh *_w95_lookup_dkh(_w95creg *creg,int nrLS,int nrMS)
600 {
601 _w95rgdb * rgdb;
602 _w95dkh * dkh;
603 int i;
604
605 /* get the beginning of the rgdb datastore */
606 rgdb = (_w95rgdb*)((char*)creg+creg->rgdb_off);
607
608 /* check: requested block < last_block) */
609 if (creg->rgdb_num <= nrMS) {
610 ERR("registry file corrupt! requested block no. beyond end.\n");
611 goto error;
612 }
613
614 /* find the right block */
615 for(i=0; i<nrMS ;i++) {
616 if(rgdb->id != W95_REG_RGDB_ID) { /* check the magic */
617 ERR("registry file corrupt! bad magic 0x%08lx\n", rgdb->id);
618 goto error;
619 }
620 rgdb = (_w95rgdb*) ((char*)rgdb+rgdb->size); /* find next block */
621 }
622
623 dkh = (_w95dkh*)(rgdb + 1); /* first sub block within the rgdb */
624
625 do {
626 if(nrLS==dkh->nrLS ) return dkh;
627 dkh = (_w95dkh*)((char*)dkh + dkh->nextkeyoff); /* find next subblock */
628 } while ((char *)dkh < ((char*)rgdb+rgdb->size));
629
630 error:
631 return NULL;
632 }
633
634 /******************************************************************************
635 * _w95_dump_dkv [Internal]
636 */
637 static int _w95_dump_dkv(_w95dkh *dkh,int nrLS,int nrMS,FILE *f)
638 {
639 _w95dkv * dkv;
640 int i;
641
642 /* first value block */
643 dkv = (_w95dkv*)((char*)dkh+dkh->keynamelen+0x14);
644
645 /* loop through the values */
646 for (i=0; i< dkh->values; i++) {
647 struct key_value value;
648 WCHAR *pdata;
649
650 value.nameW = _strdupnAtoW(dkv->name,dkv->valnamelen);
651 value.type = dkv->type;
652 value.len = dkv->valdatalen;
653
654 value.data = &(dkv->name[dkv->valnamelen]);
655 pdata = NULL;
656 if ( (value.type==REG_SZ) || (value.type==REG_EXPAND_SZ) || (value.type==REG_MULTI_SZ) ) {
657 pdata = _strdupnAtoW(value.data,value.len);
658 value.len *= 2;
659 }
660 if (pdata != NULL) value.data = pdata;
661
662 _dump_value(&value,f);
663 free(value.nameW);
664 if (pdata != NULL) free(pdata);
665
666 /* next value */
667 dkv = (_w95dkv*)((char*)dkv+dkv->valnamelen+dkv->valdatalen+0x0c);
668 }
669 return TRUE;
670 }
671
672 /******************************************************************************
673 * _w95_dump_dke [Internal]
674 */
675 static int _w95_dump_dke(LPSTR key_name,_w95creg *creg,_w95rgkn *rgkn,_w95dke *dke,FILE *f,int level)
676 {
677 _w95dkh * dkh;
678 LPSTR new_key_name = NULL;
679
680 /* special root key */
681 if (dke->nrLS == 0xffff || dke->nrMS==0xffff) /* eg. the root key has no name */
682 {
683 /* parse the one subkey */
684 if (dke->nextsub != 0xffffffff) return _w95_dump_dke(key_name, creg, rgkn, (_w95dke*)((char*)rgkn+dke->nextsub),f,level);
685 /* has no sibling keys */
686 return FALSE;
687 }
688
689 /* search subblock */
690 if (!(dkh = _w95_lookup_dkh(creg, dke->nrLS, dke->nrMS))) {
691 ERR("dke pointing to missing dkh !\n");
692 return FALSE;
693 }
694
695 if (level <= 0) {
696 /* create new subkey name */
697 new_key_name = _strdupnA(key_name,strlen(key_name)+dkh->keynamelen+1);
698 if (strcmp(new_key_name,"") != 0) strcat(new_key_name,"\\");
699 strncat(new_key_name,dkh->name,dkh->keynamelen);
700
701 /* walk sibling keys */
702 if (dke->next != 0xffffffff ) {
703 if (!_w95_dump_dke(key_name, creg, rgkn, (_w95dke*)((char*)rgkn+dke->next),f,level)) {
704 free(new_key_name);
705 return FALSE;
706 }
707 }
708
709 /* write the key path (something like [Software\\Microsoft\\..]) only if:
710 1) key has some values
711 2) key has no values and no subkeys
712 */
713 if (dkh->values > 0) {
714 /* there are some values */
715 fprintf(f,"\n[");
716 _dump_strAtoW(new_key_name,strlen(new_key_name),f,"[]");
717 fprintf(f,"]\n");
718 if (!_w95_dump_dkv(dkh, dke->nrLS, dke->nrMS,f)) {
719 free(new_key_name);
720 return FALSE;
721 }
722 }
723 if ((dke->nextsub == 0xffffffff) && (dkh->values == 0)) {
724 /* no subkeys and no values */
725 fprintf(f,"\n[");
726 _dump_strAtoW(new_key_name,strlen(new_key_name),f,"[]");
727 fprintf(f,"]\n");
728 }
729 } else new_key_name = _strdupnA(key_name,strlen(key_name));
730
731 /* next sub key */
732 if (dke->nextsub != 0xffffffff) {
733 if (!_w95_dump_dke(new_key_name, creg, rgkn, (_w95dke*)((char*)rgkn+dke->nextsub),f,level-1)) {
734 free(new_key_name);
735 return FALSE;
736 }
737 }
738
739 free(new_key_name);
740 return TRUE;
741 }
742 /* end windows 95 loader */
743
744 /***********************************************************************************/
745 /* windows NT registry loader */
746 /***********************************************************************************/
747
748 /* NT REGISTRY LOADER */
749
750 #ifdef HAVE_SYS_MMAN_H
751 # include <sys/mman.h>
752 #endif
753
754 #ifndef MAP_FAILED
755 #define MAP_FAILED ((LPVOID)-1)
756 #endif
757
758 #define NT_REG_BLOCK_SIZE 0x1000
759
760 #define NT_REG_HEADER_BLOCK_ID 0x66676572 /* regf */
761 #define NT_REG_POOL_BLOCK_ID 0x6E696268 /* hbin */
762 #define NT_REG_KEY_BLOCK_ID 0x6b6e /* nk */
763 #define NT_REG_VALUE_BLOCK_ID 0x6b76 /* vk */
764
765 /* subblocks of nk */
766 #define NT_REG_HASH_BLOCK_ID 0x666c /* lf */
767 #define NT_REG_NOHASH_BLOCK_ID 0x696c /* li */
768 #define NT_REG_RI_BLOCK_ID 0x6972 /* ri */
769
770 #define NT_REG_KEY_BLOCK_TYPE 0x20
771 #define NT_REG_ROOT_KEY_BLOCK_TYPE 0x2c
772
773 typedef struct {
774 DWORD id; /* 0x66676572 'regf'*/
775 DWORD uk1; /* 0x04 */
776 DWORD uk2; /* 0x08 */
777 FILETIME DateModified; /* 0x0c */
778 DWORD uk3; /* 0x14 */
779 DWORD uk4; /* 0x18 */
780 DWORD uk5; /* 0x1c */
781 DWORD uk6; /* 0x20 */
782 DWORD RootKeyBlock; /* 0x24 */
783 DWORD BlockSize; /* 0x28 */
784 DWORD uk7[116];
785 DWORD Checksum; /* at offset 0x1FC */
786 } nt_regf;
787
788 typedef struct {
789 DWORD blocksize;
790 BYTE data[1];
791 } nt_hbin_sub;
792
793 typedef struct {
794 DWORD id; /* 0x6E696268 'hbin' */
795 DWORD off_prev;
796 DWORD off_next;
797 DWORD uk1;
798 DWORD uk2; /* 0x10 */
799 DWORD uk3; /* 0x14 */
800 DWORD uk4; /* 0x18 */
801 DWORD size; /* 0x1C */
802 nt_hbin_sub hbin_sub; /* 0x20 */
803 } nt_hbin;
804
805 /*
806 * the value_list consists of offsets to the values (vk)
807 */
808 typedef struct {
809 WORD SubBlockId; /* 0x00 0x6B6E */
810 WORD Type; /* 0x02 for the root-key: 0x2C, otherwise 0x20*/
811 FILETIME writetime; /* 0x04 */
812 DWORD uk1; /* 0x0C */
813 DWORD parent_off; /* 0x10 Offset of Owner/Parent key */
814 DWORD nr_subkeys; /* 0x14 number of sub-Keys */
815 DWORD uk8; /* 0x18 */
816 DWORD lf_off; /* 0x1C Offset of the sub-key lf-Records */
817 DWORD uk2; /* 0x20 */
818 DWORD nr_values; /* 0x24 number of values */
819 DWORD valuelist_off; /* 0x28 Offset of the Value-List */
820 DWORD off_sk; /* 0x2c Offset of the sk-Record */
821 DWORD off_class; /* 0x30 Offset of the Class-Name */
822 DWORD uk3; /* 0x34 */
823 DWORD uk4; /* 0x38 */
824 DWORD uk5; /* 0x3c */
825 DWORD uk6; /* 0x40 */
826 DWORD uk7; /* 0x44 */
827 WORD name_len; /* 0x48 name-length */
828 WORD class_len; /* 0x4a class-name length */
829 char name[1]; /* 0x4c key-name */
830 } nt_nk;
831
832 typedef struct {
833 DWORD off_nk; /* 0x00 */
834 DWORD name; /* 0x04 */
835 } hash_rec;
836
837 typedef struct {
838 WORD id; /* 0x00 0x666c */
839 WORD nr_keys; /* 0x06 */
840 hash_rec hash_rec[1];
841 } nt_lf;
842
843 /*
844 list of subkeys without hash
845
846 li --+-->nk
847 |
848 +-->nk
849 */
850 typedef struct {
851 WORD id; /* 0x00 0x696c */
852 WORD nr_keys;
853 DWORD off_nk[1];
854 } nt_li;
855
856 /*
857 this is a intermediate node
858
859 ri --+-->li--+-->nk
860 | +
861 | +-->nk
862 |
863 +-->li--+-->nk
864 +
865 +-->nk
866 */
867 typedef struct {
868 WORD id; /* 0x00 0x6972 */
869 WORD nr_li; /* 0x02 number off offsets */
870 DWORD off_li[1]; /* 0x04 points to li */
871 } nt_ri;
872
873 typedef struct {
874 WORD id; /* 0x00 'vk' */
875 WORD nam_len;
876 DWORD data_len;
877 DWORD data_off;
878 DWORD type;
879 WORD flag;
880 WORD uk1;
881 char name[1];
882 } nt_vk;
883
884 /*
885 * gets a value
886 *
887 * vk->flag:
888 * 0 value is a default value
889 * 1 the value has a name
890 *
891 * vk->data_len
892 * len of the whole data block
893 * - reg_sz (unicode)
894 * bytes including the terminating \0 = 2*(number_of_chars+1)
895 * - reg_dword, reg_binary:
896 * if highest bit of data_len is set data_off contains the value
897 */
898 static int _nt_dump_vk(LPSTR key_name, char *base, nt_vk *vk,FILE *f)
899 {
900 BYTE *pdata = (BYTE *)(base+vk->data_off+4); /* start of data */
901 struct key_value value;
902
903 if (vk->id != NT_REG_VALUE_BLOCK_ID) {
904 ERR("unknown block found (0x%04x), please report!\n", vk->id);
905 return FALSE;
906 }
907
908 value.nameW = _strdupnAtoW(vk->name,vk->nam_len);
909 value.type = vk->type;
910 value.len = (vk->data_len & 0x7fffffff);
911 value.data = (vk->data_len & 0x80000000) ? (LPBYTE)&(vk->data_off): pdata;
912
913 _dump_value(&value,f);
914 free(value.nameW);
915
916 return TRUE;
917 }
918
919 /* it's called from _nt_dump_lf() */
920 static int _nt_dump_nk(LPSTR key_name,char *base,nt_nk *nk,FILE *f,int level);
921
922 /*
923 * get the subkeys
924 *
925 * this structure contains the hash of a keyname and points to all
926 * subkeys
927 *
928 * exception: if the id is 'il' there are no hash values and every
929 * dword is a offset
930 */
931 static int _nt_dump_lf(LPSTR key_name, char *base, int subkeys, nt_lf *lf, FILE *f, int level)
932 {
933 int i;
934
935 if (lf->id == NT_REG_HASH_BLOCK_ID) {
936 if (subkeys != lf->nr_keys) goto error1;
937
938 for (i=0; i<lf->nr_keys; i++)
939 if (!_nt_dump_nk(key_name, base, (nt_nk*)(base+lf->hash_rec[i].off_nk+4), f, level)) goto error;
940 } else if (lf->id == NT_REG_NOHASH_BLOCK_ID) {
941 nt_li * li = (nt_li*)lf;
942 if (subkeys != li->nr_keys) goto error1;
943
944 for (i=0; i<li->nr_keys; i++)
945 if (!_nt_dump_nk(key_name, base, (nt_nk*)(base+li->off_nk[i]+4), f, level)) goto error;
946 } else if (lf->id == NT_REG_RI_BLOCK_ID) { /* ri */
947 nt_ri * ri = (nt_ri*)lf;
948 int li_subkeys = 0;
949
950 /* count all subkeys */
951 for (i=0; i<ri->nr_li; i++) {
952 nt_li * li = (nt_li*)(base+ri->off_li[i]+4);
953 if(li->id != NT_REG_NOHASH_BLOCK_ID) goto error2;
954 li_subkeys += li->nr_keys;
955 }
956
957 /* check number */
958 if (subkeys != li_subkeys) goto error1;
959
960 /* loop through the keys */
961 for (i=0; i<ri->nr_li; i++) {
962 nt_li *li = (nt_li*)(base+ri->off_li[i]+4);
963 if (!_nt_dump_lf(key_name, base, li->nr_keys, (nt_lf*)li, f, level)) goto error;
964 }
965 } else goto error2;
966
967 return TRUE;
968
969 error2:
970 if (lf->id == 0x686c)
971 FIXME("unknown Win XP node id 0x686c: do we need to add support for it ?\n");
972 else
973 ERR("unknown node id 0x%04x, please report!\n", lf->id);
974 return TRUE;
975
976 error1:
977 ERR("registry file corrupt! (inconsistent number of subkeys)\n");
978 return FALSE;
979
980 error:
981 ERR("error reading lf block\n");
982 return FALSE;
983 }
984
985 /* _nt_dump_nk [Internal] */
986 static int _nt_dump_nk(LPSTR key_name,char *base,nt_nk *nk,FILE *f,int level)
987 {
988 unsigned int n;
989 DWORD *vl;
990 LPSTR new_key_name = NULL;
991
992 TRACE("%s\n", key_name);
993
994 if (nk->SubBlockId != NT_REG_KEY_BLOCK_ID) {
995 ERR("unknown node id 0x%04x, please report!\n", nk->SubBlockId);
996 return FALSE;
997 }
998
999 if ((nk->Type!=NT_REG_ROOT_KEY_BLOCK_TYPE) && (((nt_nk*)(base+nk->parent_off+4))->SubBlockId != NT_REG_KEY_BLOCK_ID)) {
1000 ERR("registry file corrupt!\n");
1001 return FALSE;
1002 }
1003
1004 /* create the new key */
1005 if (level <= 0) {
1006 /* create new subkey name */
1007 new_key_name = _strdupnA(key_name,strlen(key_name)+nk->name_len+1);
1008 if (strcmp(new_key_name,"") != 0) strcat(new_key_name,"\\");
1009 strncat(new_key_name,nk->name,nk->name_len);
1010
1011 /* write the key path (something like [Software\\Microsoft\\..]) only if:
1012 1) key has some values
1013 2) key has no values and no subkeys
1014 */
1015 if (nk->nr_values > 0) {
1016 /* there are some values */
1017 fprintf(f,"\n[");
1018 _dump_strAtoW(new_key_name,strlen(new_key_name),f,"[]");
1019 fprintf(f,"]\n");
1020 }
1021 if ((nk->nr_subkeys == 0) && (nk->nr_values == 0)) {
1022 /* no subkeys and no values */
1023 fprintf(f,"\n[");
1024 _dump_strAtoW(new_key_name,strlen(new_key_name),f,"[]");
1025 fprintf(f,"]\n");
1026 }
1027
1028 /* loop trough the value list */
1029 vl = (DWORD *)(base+nk->valuelist_off+4);
1030 for (n=0; n<nk->nr_values; n++) {
1031 nt_vk * vk = (nt_vk*)(base+vl[n]+4);
1032 if (!_nt_dump_vk(new_key_name, base, vk, f)) {
1033 free(new_key_name);
1034 return FALSE;
1035 }
1036 }
1037 } else new_key_name = _strdupnA(key_name,strlen(key_name));
1038
1039 /* loop through the subkeys */
1040 if (nk->nr_subkeys) {
1041 nt_lf *lf = (nt_lf*)(base+nk->lf_off+4);
1042 if (!_nt_dump_lf(new_key_name, base, nk->nr_subkeys, lf, f, level-1)) {
1043 free(new_key_name);
1044 return FALSE;
1045 }
1046 }
1047
1048 free(new_key_name);
1049 return TRUE;
1050 }
1051
1052 /* end nt loader */
1053
1054 /**********************************************************************************
1055 * _set_registry_levels [Internal]
1056 *
1057 * set level to 0 for loading system files
1058 * set level to 1 for loading user files
1059 */
1060 static void _set_registry_levels(int level,int saving,int period)
1061 {
1062 SERVER_START_REQ( set_registry_levels )
1063 {
1064 req->current = level;
1065 req->saving = saving;
1066 req->period = period;
1067 wine_server_call( req );
1068 }
1069 SERVER_END_REQ;
1070 }
1071
1072 /* _save_at_exit [Internal] */
1073 static void _save_at_exit(HKEY hkey,LPCSTR path)
1074 {
1075 LPCSTR confdir = wine_get_config_dir();
1076
1077 SERVER_START_REQ( save_registry_atexit )
1078 {
1079 req->hkey = hkey;
1080 wine_server_add_data( req, confdir, strlen(confdir) );
1081 wine_server_add_data( req, path, strlen(path)+1 );
1082 wine_server_call( req );
1083 }
1084 SERVER_END_REQ;
1085 }
1086
1087 /* configure save files and start the periodic saving timer [Internal] */
1088 static void _init_registry_saving( HKEY hkey_local_machine, HKEY hkey_current_user,
1089 HKEY hkey_users_default )
1090 {
1091 int all;
1092 int period = 0;
1093 WCHAR buffer[20];
1094 static const WCHAR registryW[] = {'r','e','g','i','s','t','r','y',0};
1095 static const WCHAR SaveOnlyUpdatedKeysW[] = {'S','a','v','e','O','n','l','y','U','p','d','a','t','e','d','K','e','y','s',0};
1096 static const WCHAR PeriodicSaveW[] = {'P','e','r','i','o','d','i','c','S','a','v','e',0};
1097 static const WCHAR WritetoHomeRegistryFilesW[] = {'W','r','i','t','e','t','o','H','o','m','e','R','e','g','i','s','t','r','y','F','i','l','e','s',0};
1098 static const WCHAR empty_strW[] = { 0 };
1099
1100 all = !PROFILE_GetWineIniBool(registryW, SaveOnlyUpdatedKeysW, 1);
1101 PROFILE_GetWineIniString( registryW, PeriodicSaveW, empty_strW, buffer, 20 );
1102 if (buffer[0]) period = (int)strtolW(buffer, NULL, 10);
1103
1104 /* set saving level (0 for saving everything, 1 for saving only modified keys) */
1105 _set_registry_levels(1,!all,period*1000);
1106
1107 if (PROFILE_GetWineIniBool(registryW, WritetoHomeRegistryFilesW, 1))
1108 {
1109 _save_at_exit(hkey_current_user,"/" SAVE_LOCAL_REGBRANCH_CURRENT_USER );
1110 _save_at_exit(hkey_local_machine,"/" SAVE_LOCAL_REGBRANCH_LOCAL_MACHINE);
1111 _save_at_exit(hkey_users_default,"/" SAVE_LOCAL_REGBRANCH_USER_DEFAULT);
1112 }
1113
1114 }
1115
1116 /******************************************************************************
1117 * _allocate_default_keys [Internal]
1118 * Registry initialisation, allocates some default keys.
1119 */
1120 static void _allocate_default_keys(void)
1121 {
1122 HKEY hkey;
1123 OBJECT_ATTRIBUTES attr;
1124 UNICODE_STRING nameW, valueW;
1125 WCHAR computer_name[200];
1126 DWORD size = sizeof(computer_name)/sizeof(WCHAR);
1127
1128 static const WCHAR StatDataW[] = {'D','y','n','D','a','t','a','\\',
1129 'P','e','r','f','S','t','a','t','s','\\',
1130 'S','t','a','t','D','a','t','a',0};
1131 static const WCHAR ComputerW[] = {'M','a','c','h','i','n','e','\\',
1132 'S','y','s','t','e','m','\\',
1133 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
1134 'C','o','n','t','r','o','l','\\',
1135 'C','o','m','p','u','t','e','r','N','a','m','e','\\',
1136 'C','o','m','p','u','t','e','r','N','a','m','e',0};
1137 static const WCHAR ComputerNameW[] = {'C','o','m','p','u','t','e','r','N','a','m','e',0};
1138
1139 TRACE("(void)\n");
1140
1141 attr.Length = sizeof(attr);
1142 attr.RootDirectory = 0;
1143 attr.ObjectName = &nameW;
1144 attr.Attributes = 0;
1145 attr.SecurityDescriptor = NULL;
1146 attr.SecurityQualityOfService = NULL;
1147
1148 RtlInitUnicodeString( &nameW, StatDataW );
1149 if (!NtCreateKey( &hkey, KEY_ALL_ACCESS, &attr, 0, NULL, 0, NULL )) NtClose( hkey );
1150
1151 /* \\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion
1152 * CurrentVersion
1153 * CurrentBuildNumber
1154 * CurrentType
1155 * string RegisteredOwner
1156 * string RegisteredOrganization
1157 *
1158 */
1159 /* System\\CurrentControlSet\\Services\\SNMP\\Parameters\\RFC1156Agent
1160 * string SysContact
1161 * string SysLocation
1162 * SysServices
1163 */
1164 if (GetComputerNameW( computer_name, &size ))
1165 {
1166 RtlInitUnicodeString( &nameW, ComputerW );
1167 if (!NtCreateKey( &hkey, KEY_ALL_ACCESS, &attr, 0, NULL, 0, NULL ))
1168 {
1169 RtlInitUnicodeString( &valueW, ComputerNameW );
1170 NtSetValueKey( hkey, &valueW, 0, REG_SZ, computer_name,
1171 (strlenW(computer_name) + 1) * sizeof(WCHAR) );
1172 NtClose(hkey);
1173 }
1174 }
1175 }
1176
1177 #define REG_DONTLOAD -1
1178 #define REG_WIN31 0
1179 #define REG_WIN95 1
1180 #define REG_WINNT 2
1181
1182 /* return the type of native registry [Internal] */
1183 static int _get_reg_type(void)
1184 {
1185 WCHAR windir[MAX_PATHNAME_LEN];
1186 WCHAR tmp[MAX_PATHNAME_LEN];
1187 int ret = REG_WIN31;
1188 static const WCHAR nt_reg_pathW[] = {'\\','s','y','s','t','e','m','3','2','\\','c','o','n','f','i','g','\\','s','y','s','t','e','m',0};
1189 static const WCHAR win9x_reg_pathW[] = {'\\','s','y','s','t','e','m','.','d','a','t',0};
1190 static const WCHAR WineW[] = {'W','i','n','e',0};
1191 static const WCHAR ProfileW[] = {'P','r','o','f','i','l','e',0};
1192 static const WCHAR empty_strW[] = { 0 };
1193
1194 GetWindowsDirectoryW(windir, MAX_PATHNAME_LEN);
1195
1196 /* test %windir%/system32/config/system --> winnt */
1197 strcpyW(tmp, windir);
1198 strcatW(tmp, nt_reg_pathW);
1199 if(GetFileAttributesW(tmp) != (DWORD)-1)
1200 ret = REG_WINNT;
1201 else
1202 {
1203 /* test %windir%/system.dat --> win95 */
1204 strcpyW(tmp, windir);
1205 strcatW(tmp, win9x_reg_pathW);
1206 if(GetFileAttributesW(tmp) != (DWORD)-1)
1207 ret = REG_WIN95;
1208 }
1209
1210 if ((ret == REG_WINNT) && (!PROFILE_GetWineIniString( WineW, ProfileW, empty_strW, tmp, MAX_PATHNAME_LEN )))
1211 {
1212 MESSAGE("When you are running with a native NT directory specify\n");
1213 MESSAGE("'Profile=<profiledirectory>' or disable loading of Windows\n");
1214 MESSAGE("registry (LoadWindowsRegistryFiles=N)\n");
1215 ret = REG_DONTLOAD;
1216 }
1217
1218 return ret;
1219 }
1220
1221 #define WINE_REG_VER_ERROR -1
1222 #define WINE_REG_VER_1 0
1223 #define WINE_REG_VER_2 1
1224 #define WINE_REG_VER_OLD 2
1225 #define WINE_REG_VER_UNKNOWN 3
1226
1227 /* return the version of wine registry file [Internal] */
1228 static int _get_wine_registry_file_format_version(LPCSTR fn)
1229 {
1230 FILE *f;
1231 char tmp[50];
1232 int ver;
1233
1234 if ((f=fopen(fn,"rt")) == NULL) {
1235 WARN("Couldn't open %s for reading: %s\n",fn,strerror(errno));
1236 return WINE_REG_VER_ERROR;
1237 }
1238
1239 if (fgets(tmp,50,f) == NULL) {
1240 WARN("Error reading %s: %s\n",fn,strerror(errno));
1241 fclose(f);
1242 return WINE_REG_VER_ERROR;
1243 }
1244 fclose(f);
1245
1246 if (sscanf(tmp,"WINE REGISTRY Version %d",&ver) != 1) return WINE_REG_VER_UNKNOWN;
1247 switch (ver) {
1248 case 1:
1249 return WINE_REG_VER_1;
1250 break;
1251 case 2:
1252 return WINE_REG_VER_2;
1253 break;
1254 default:
1255 return WINE_REG_VER_UNKNOWN;
1256 }
1257 }
1258
1259 /* load the registry file in wine format [Internal] */
1260 static void load_wine_registry(HKEY hkey,LPCSTR fn)
1261 {
1262 int file_format;
1263
1264 file_format = _get_wine_registry_file_format_version(fn);
1265 switch (file_format) {
1266
1267 case WINE_REG_VER_1:
1268 WARN("Unable to load registry file %s: old format which is no longer supported.\n",fn);
1269 break;
1270
1271 case WINE_REG_VER_2: {
1272 HANDLE file;
1273 if ((file = FILE_CreateFile( fn, GENERIC_READ, 0, NULL, OPEN_EXISTING,
1274 FILE_ATTRIBUTE_NORMAL, 0, TRUE, DRIVE_UNKNOWN )))
1275 {
1276 SERVER_START_REQ( load_registry )
1277 {
1278 req->hkey = hkey;
1279 req->file = file;
1280 wine_server_call( req );
1281 }
1282 SERVER_END_REQ;
1283 CloseHandle( file );
1284 }
1285 break;
1286 }
1287
1288 case WINE_REG_VER_UNKNOWN:
1289 WARN("Unable to load registry file %s: unknown format.\n",fn);
1290 break;
1291
1292 case WINE_REG_VER_ERROR:
1293 break;
1294 }
1295 }
1296
1297 /* generate and return the name of the tmp file and associated stream [Internal] */
1298 static LPSTR _get_tmp_fn(FILE **f)
1299 {
1300 LPSTR ret;
1301 int tmp_fd,count;
1302
1303 ret = _xmalloc(50);
1304 for (count = 0;;) {
1305 sprintf(ret,"/tmp/reg%lx%04x.tmp",(long)getpid(),count++);
1306 if ((tmp_fd = open(ret,O_CREAT | O_EXCL | O_WRONLY,0666)) != -1) break;
1307 if (errno != EEXIST) {
1308 ERR("Unexpected error while open() call: %s\n",strerror(errno));
1309 free(ret);
1310 *f = NULL;
1311 return NULL;
1312 }
1313 }
1314
1315 if ((*f = fdopen(tmp_fd,"w")) == NULL) {
1316 ERR("Unexpected error while fdopen() call: %s\n",strerror(errno));
1317 close(tmp_fd);
1318 free(ret);
1319 return NULL;
1320 }
1321
1322 return ret;
1323 }
1324
1325 /* convert win95 native registry file to wine format [Internal] */
1326 static LPSTR _convert_win95_registry_to_wine_format(LPCWSTR fn, int level)
1327 {
1328 int fd;
1329 FILE *f;
1330 DOS_FULL_NAME full_name;
1331 void *base;
1332 LPSTR ret = NULL;
1333 struct stat st;
1334
1335 _w95creg *creg;
1336 _w95rgkn *rgkn;
1337 _w95dke *dke, *root_dke;
1338
1339 if (!DOSFS_GetFullName( fn, 0, &full_name )) return NULL;
1340
1341 /* map the registry into the memory */
1342 if ((fd = open(full_name.long_name, O_RDONLY | O_NONBLOCK)) == -1) return NULL;
1343 if ((fstat(fd, &st) == -1)) goto error1;
1344 if (!st.st_size) goto error1;
1345 if ((base = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0)) == MAP_FAILED) goto error1;
1346
1347 /* control signature */
1348 if (*(LPDWORD)base != W95_REG_CREG_ID) {
1349 ERR("unable to load native win95 registry file %s: unknown signature.\n",
1350 debugstr_w(fn));
1351 goto error;
1352 }
1353
1354 creg = base;
1355 /* load the header (rgkn) */
1356 rgkn = (_w95rgkn*)(creg + 1);
1357 if (rgkn->id != W95_REG_RGKN_ID) {
1358 ERR("second IFF header not RGKN, but %lx\n", rgkn->id);
1359 goto error;
1360 }
1361 if (rgkn->root_off != 0x20) {
1362 ERR("rgkn->root_off not 0x20, please report !\n");
1363 goto error;
1364 }
1365 if (rgkn->last_dke > rgkn->size)
1366 {
1367 ERR("registry file corrupt! last_dke > size!\n");
1368 goto error;
1369 }
1370 /* verify last dke */
1371 dke = (_w95dke*)((char*)rgkn + rgkn->last_dke);
1372 if (dke->x1 != 0x80000000)
1373 { /* wrong magic */
1374 ERR("last dke invalid !\n");
1375 goto error;
1376 }
1377 if (rgkn->size > creg->rgdb_off)
1378 {
1379 ERR("registry file corrupt! rgkn size > rgdb_off !\n");
1380 goto error;
1381 }
1382 root_dke = (_w95dke*)((char*)rgkn + rgkn->root_off);
1383 if ( (root_dke->prevlvl != 0xffffffff) || (root_dke->next != 0xffffffff) )
1384 {
1385 ERR("registry file corrupt! invalid root dke !\n");
1386 goto error;
1387 }
1388
1389 if ( (ret = _get_tmp_fn(&f)) == NULL) goto error;
1390 fprintf(f,"WINE REGISTRY Version 2");
1391 _w95_dump_dke("",creg,rgkn,root_dke,f,level);
1392 fclose(f);
1393
1394 error:
1395 if(ret == NULL) {
1396 ERR("Unable to load native win95 registry file %s.\n", debugstr_w(fn));
1397 ERR("Please report this.\n");
1398 ERR("Make a backup of the file, run a good reg cleaner program and try again!\n");
1399 }
1400
1401 munmap(base, st.st_size);
1402 error1:
1403 close(fd);
1404 return ret;
1405 }
1406
1407 /* convert winnt native registry file to wine format [Internal] */
1408 static LPSTR _convert_winnt_registry_to_wine_format(LPCWSTR fn, int level)
1409 {
1410 FILE *f;
1411 void *base;
1412 LPSTR ret = NULL;
1413 HANDLE hFile;
1414 HANDLE hMapping;
1415
1416 nt_regf *regf;
1417 nt_hbin *hbin;
1418 nt_hbin_sub *hbin_sub;
1419 nt_nk *nk;
1420
1421 TRACE("%s\n", debugstr_w(fn));
1422
1423 hFile = CreateFileW( fn, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0 );
1424 if ( hFile == INVALID_HANDLE_VALUE ) return NULL;
1425 hMapping = CreateFileMappingW( hFile, NULL, PAGE_READONLY|SEC_COMMIT, 0, 0, NULL );
1426 if (!hMapping) goto error1;
1427 base = MapViewOfFile( hMapping, FILE_MAP_READ, 0, 0, 0 );
1428 CloseHandle( hMapping );
1429 if (!base) goto error1;
1430
1431 /* control signature */
1432 if (*(LPDWORD)base != NT_REG_HEADER_BLOCK_ID) {
1433 ERR("unable to load native winnt registry file %s: unknown signature.\n",
1434 debugstr_w(fn));
1435 goto error;
1436 }
1437
1438 /* start block */
1439 regf = base;
1440
1441 /* hbin block */
1442 hbin = (nt_hbin*)((char*) base + 0x1000);
1443 if (hbin->id != NT_REG_POOL_BLOCK_ID) {
1444 ERR( "hbin block invalid\n");
1445 goto error;
1446 }
1447
1448 /* hbin_sub block */
1449 hbin_sub = (nt_hbin_sub*)&(hbin->hbin_sub);
1450 if ((hbin_sub->data[0] != 'n') || (hbin_sub->data[1] != 'k')) {
1451 ERR( "hbin_sub block invalid\n");
1452 goto error;
1453 }
1454
1455 /* nk block */
1456 nk = (nt_nk*)&(hbin_sub->data[0]);
1457 if (nk->Type != NT_REG_ROOT_KEY_BLOCK_TYPE) {
1458 ERR( "special nk block not found\n");
1459 goto error;
1460 }
1461
1462 if ( (ret = _get_tmp_fn(&f)) == NULL) goto error;
1463 fprintf(f,"WINE REGISTRY Version 2");
1464 _nt_dump_nk("",(char*)base+0x1000,nk,f,level);
1465 fclose(f);
1466
1467 error:
1468 UnmapViewOfFile( base );
1469 error1:
1470 CloseHandle(hFile);
1471 return ret;
1472 }
1473
1474 /* convert native registry to wine format and load it via server call [Internal] */
1475 static void _convert_and_load_native_registry(LPCWSTR fn, HKEY hkey, int reg_type, int level)
1476 {
1477 LPSTR tmp = NULL;
1478
1479 switch (reg_type) {
1480 case REG_WINNT:
1481 /* FIXME: following function doesn't really convert yet */
1482 tmp = _convert_winnt_registry_to_wine_format(fn,level);
1483 break;
1484 case REG_WIN95:
1485 tmp = _convert_win95_registry_to_wine_format(fn,level);
1486 break;
1487 case REG_WIN31:
1488 ERR("Don't know how to convert native 3.1 registry yet.\n");
1489 break;
1490 default:
1491 ERR("Unknown registry format parameter (%d)\n",reg_type);
1492 break;
1493 }
1494
1495 if (tmp != NULL) {
1496 load_wine_registry(hkey,tmp);
1497 TRACE("File %s successfully converted to %s and loaded to registry.\n",
1498 debugstr_w(fn), tmp);
1499 unlink(tmp);
1500 }
1501 else WARN("Unable to convert %s (doesn't exist?)\n", debugstr_w(fn));
1502 free(tmp);
1503 }
1504
1505 /* load all native windows registry files [Internal] */
1506 static void _load_windows_registry( HKEY hkey_local_machine, HKEY hkey_current_user,
1507 HKEY hkey_users_default )
1508 {
1509 int reg_type;
1510 WCHAR windir[MAX_PATHNAME_LEN];
1511 WCHAR path[MAX_PATHNAME_LEN];
1512 OBJECT_ATTRIBUTES attr;
1513 UNICODE_STRING nameW;
1514 HKEY hkey;
1515
1516 static const WCHAR WineW[] = {'W','i','n','e',0};
1517 static const WCHAR ProfileW[] = {'P','r','o','f','i','l','e',0};
1518 static const WCHAR empty_strW[] = { 0 };
1519 static const WCHAR System[] = {'M','a','c','h','i','n','e','\\','S','y','s','t','e','m',0};
1520 static const WCHAR Software[] = {'M','a','c','h','i','n','e','\\','S','o','f','t','w','a','r','e',0};
1521 static const WCHAR Clone[] = {'M','a','c','h','i','n','e','\\',
1522 'S','y','s','t','e','m','\\',
1523 'C','l','o','n','e',0};
1524
1525 attr.Length = sizeof(attr);
1526 attr.RootDirectory = 0;
1527 attr.ObjectName = &nameW;
1528 attr.Attributes = 0;
1529 attr.SecurityDescriptor = NULL;
1530 attr.SecurityQualityOfService = NULL;
1531
1532 GetWindowsDirectoryW(windir, MAX_PATHNAME_LEN);
1533
1534 reg_type = _get_reg_type();
1535 switch (reg_type) {
1536 case REG_WINNT: {
1537 HKEY hkey;
1538 static const WCHAR ntuser_datW[] = {'\\','n','t','u','s','e','r','.','d','a','t',0};
1539 static const WCHAR defaultW[] = {'\\','s','y','s','t','e','m','3','2','\\','c','o','n','f','i','g','\\','d','e','f','a','u','l','t',0};
1540 static const WCHAR systemW[] = {'\\','s','y','s','t','e','m','3','2','\\','c','o','n','f','i','g','\\','s','y','s','t','e','m',0};
1541 static const WCHAR softwareW[] = {'\\','s','y','s','t','e','m','3','2','\\','c','o','n','f','i','g','\\','s','o','f','t','w','a','r','e',0};
1542 static const WCHAR samW[] = {'\\','s','y','s','t','e','m','3','2','\\','c','o','n','f','i','g','\\','s','a','m',0};
1543 static const WCHAR securityW[] = {'\\','s','y','s','t','e','m','3','2','\\','c','o','n','f','i','g','\\','s','e','c','u','r','i','t','y',0};
1544
1545 /* user specific ntuser.dat */
1546 if (PROFILE_GetWineIniString( WineW, ProfileW, empty_strW, path, MAX_PATHNAME_LEN )) {
1547 strcatW(path, ntuser_datW);
1548 _convert_and_load_native_registry(path,hkey_current_user,REG_WINNT,1);
1549 }
1550
1551 /* default user.dat */
1552 if (hkey_users_default) {
1553 strcpyW(path, windir);
1554 strcatW(path, defaultW);
1555 _convert_and_load_native_registry(path,hkey_users_default,REG_WINNT,1);
1556 }
1557
1558 /*
1559 * FIXME
1560 * map HLM\System\ControlSet001 to HLM\System\CurrentControlSet
1561 */
1562 RtlInitUnicodeString( &nameW, System );
1563 if (!NtCreateKey( &hkey, KEY_ALL_ACCESS, &attr, 0, NULL, 0, NULL ))
1564 {
1565 strcpyW(path, windir);
1566 strcatW(path, systemW);
1567 _convert_and_load_native_registry(path,hkey,REG_WINNT,1);
1568 NtClose( hkey );
1569 }
1570 RtlInitUnicodeString( &nameW, Software );
1571 if (!NtCreateKey( &hkey, KEY_ALL_ACCESS, &attr, 0, NULL, 0, NULL ))
1572 {
1573 strcpyW(path, windir);
1574 strcatW(path, softwareW);
1575 _convert_and_load_native_registry(path,hkey,REG_WINNT,1);
1576 NtClose( hkey );
1577 }
1578
1579 strcpyW(path, windir);
1580 strcatW(path, samW);
1581 _convert_and_load_native_registry(path,hkey_local_machine,REG_WINNT,0);
1582
1583 strcpyW(path,windir);
1584 strcatW(path, securityW);
1585 _convert_and_load_native_registry(path,hkey_local_machine,REG_WINNT,0);
1586
1587 /* this key is generated when the nt-core booted successfully */
1588 RtlInitUnicodeString( &nameW, Clone );
1589 if (!NtCreateKey( &hkey, KEY_ALL_ACCESS, &attr, 0, NULL, 0, NULL )) NtClose( hkey );
1590 break;
1591 }
1592
1593 case REG_WIN95:
1594 {
1595 static const WCHAR system_1stW[] = {'c',':','\\','s','y','s','t','e','m','.','1','s','t',0};
1596 static const WCHAR system_datW[] = {'\\','s','y','s','t','e','m','.','d','a','t',0};
1597 static const WCHAR classes_datW[] = {'\\','c','l','a','s','s','e','s','.','d','a','t',0};
1598 static const WCHAR user_datW[] = {'\\','u','s','e','r','.','d','a','t',0};
1599
1600 _convert_and_load_native_registry(system_1stW,hkey_local_machine,REG_WIN95,0);
1601
1602 strcpyW(path, windir);
1603 strcatW(path, system_datW);
1604 _convert_and_load_native_registry(path,hkey_local_machine,REG_WIN95,0);
1605
1606 RtlInitUnicodeString( &nameW, ClassesRootW );
1607 if (!NtCreateKey( &hkey, KEY_ALL_ACCESS, &attr, 0, NULL, 0, NULL ))
1608 {
1609 strcpyW(path, windir);
1610 strcatW(path, classes_datW);
1611 _convert_and_load_native_registry(path,hkey,REG_WIN95,0);
1612 NtClose( hkey );
1613 }
1614
1615 if (PROFILE_GetWineIniString(WineW, ProfileW, empty_strW, path, MAX_PATHNAME_LEN)) {
1616 /* user specific user.dat */
1617 strcatW(path, user_datW);
1618 _convert_and_load_native_registry(path,hkey_current_user,REG_WIN95,1);
1619
1620 /* default user.dat */
1621 if (hkey_users_default) {
1622 strcpyW(path, windir);
1623 strcatW(path, user_datW);
1624 _convert_and_load_native_registry(path,hkey_users_default,REG_WIN95,1);
1625 }
1626 } else {
1627 strcpyW(path, windir);
1628 strcatW(path, user_datW);
1629 _convert_and_load_native_registry(path,hkey_current_user,REG_WIN95,1);
1630 }
1631 break;
1632 }
1633
1634 case REG_WIN31:
1635 /* FIXME: here we should convert to *.reg file supported by server and call REQ_LOAD_REGISTRY, see REG_WIN95 case */
1636 _w31_loadreg();
1637 break;
1638
1639 case REG_DONTLOAD:
1640 TRACE("REG_DONTLOAD\n");
1641 break;
1642
1643 default:
1644 ERR("switch: no match (%d)\n",reg_type);
1645 break;
1646
1647 }
1648 }
1649
1650 /* load global registry files (stored in /etc/wine) [Internal] */
1651 static void _load_global_registry( HKEY hkey_local_machine, HKEY hkey_users )
1652 {
1653 WCHAR Wglobalregistrydir[MAX_PATHNAME_LEN];
1654 char globalregistrydir[MAX_PATHNAME_LEN];
1655 char configfile[MAX_PATHNAME_LEN];
1656 static const WCHAR registryW[] = {'r','e','g','i','s','t','r','y',0};
1657 static const WCHAR GlobalRegistryDirW[] = {'G','l','o','b','a','l','R','e','g','i','s','t','r','y','D','i','r',0};
1658 static const WCHAR empty_strW[] = { 0 };
1659
1660 TRACE("(void)\n");
1661
1662 /* Override ETCDIR? */
1663 PROFILE_GetWineIniString( registryW, GlobalRegistryDirW, empty_strW , Wglobalregistrydir, MAX_PATHNAME_LEN);
1664 WideCharToMultiByte(CP_ACP, 0, Wglobalregistrydir, -1, globalregistrydir, MAX_PATHNAME_LEN, NULL, NULL);
1665
1666 if (globalregistrydir[0] != '/') strcpy(globalregistrydir, ETCDIR);
1667
1668 TRACE("GlobalRegistryDir is '%s'.\n", globalregistrydir);
1669
1670 /* Load the global HKU hive directly from sysconfdir */
1671 strcpy(configfile, globalregistrydir);
1672 strcat(configfile, SAVE_GLOBAL_REGBRANCH_USER_DEFAULT);
1673 load_wine_registry( hkey_users, configfile );
1674
1675 /* Load the global machine defaults directly from sysconfdir */
1676 strcpy(configfile, globalregistrydir);
1677 strcat(configfile, SAVE_GLOBAL_REGBRANCH_LOCAL_MACHINE);
1678 load_wine_registry( hkey_local_machine, configfile );
1679 }
1680
1681 /* load home registry files (stored in ~/.wine) [Internal] */
1682 static void _load_home_registry( HKEY hkey_local_machine, HKEY hkey_current_user,
1683 HKEY hkey_users_default )
1684 {
1685 LPCSTR confdir = wine_get_config_dir();
1686 LPSTR tmp = _xmalloc(strlen(confdir)+20);
1687
1688 strcpy(tmp,confdir);
1689 strcat(tmp,"/" SAVE_LOCAL_REGBRANCH_USER_DEFAULT);
1690 load_wine_registry(hkey_users_default,tmp);
1691
1692 strcpy(tmp,confdir);
1693 strcat(tmp,"/" SAVE_LOCAL_REGBRANCH_CURRENT_USER);
1694 load_wine_registry(hkey_current_user,tmp);
1695
1696 strcpy(tmp,confdir);
1697 strcat(tmp,"/" SAVE_LOCAL_REGBRANCH_LOCAL_MACHINE);
1698 load_wine_registry(hkey_local_machine,tmp);
1699
1700 free(tmp);
1701 }
1702
1703 /* load all registry (native and global and home) */
1704 void SHELL_LoadRegistry( void )
1705 {
1706 HKEY hkey_local_machine, hkey_users, hkey_users_default, hkey_current_user;
1707 OBJECT_ATTRIBUTES attr;
1708 UNICODE_STRING nameW;
1709
1710 static const WCHAR MachineW[] = {'M','a','c','h','i','n','e',0};
1711 static const WCHAR UserW[] = {'U','s','e','r',0};
1712 static const WCHAR DefaultW[] = {'.','D','e','f','a','u','l','t',0};
1713 static const WCHAR RegistryW[] = {'R','e','g','i','s','t','r','y',0};
1714 static const WCHAR load_win_reg_filesW[] = {'L','o','a','d','W','i','n','d','o','w','s','R','e','g','i','s','t','r','y','F','i','l','e','s',0};
1715 static const WCHAR load_global_reg_filesW[] = {'L','o','a','d','G','l','o','b','a','l','R','e','g','i','s','t','r','y','F','i','l','e','s',0};
1716 static const WCHAR load_home_reg_filesW[] = {'L','o','a','d','H','o','m','e','R','e','g','i','s','t','r','y','F','i','l','e','s',0};
1717
1718 TRACE("(void)\n");
1719
1720 if (!CLIENT_IsBootThread()) return; /* already loaded */
1721
1722 attr.Length = sizeof(attr);
1723 attr.RootDirectory = 0;
1724 attr.ObjectName = &nameW;
1725 attr.Attributes = 0;
1726 attr.SecurityDescriptor = NULL;
1727 attr.SecurityQualityOfService = NULL;
1728
1729 RtlInitUnicodeString( &nameW, MachineW );
1730 NtCreateKey( &hkey_local_machine, KEY_ALL_ACCESS, &attr, 0, NULL, 0, NULL );
1731 RtlInitUnicodeString( &nameW, UserW );
1732 NtCreateKey( &hkey_users, KEY_ALL_ACCESS, &attr, 0, NULL, 0, NULL );
1733
1734 attr.RootDirectory = hkey_users;
1735 RtlInitUnicodeString( &nameW, DefaultW );
1736 if (NtCreateKey( &hkey_users_default, KEY_ALL_ACCESS, &attr, 0, NULL, 0, NULL ))
1737 {
1738 ERR("Cannot create HKEY_USERS/.Default\n" );
1739 ExitProcess(1);
1740 }
1741 RtlOpenCurrentUser( KEY_ALL_ACCESS, &hkey_current_user );
1742
1743 _set_registry_levels(0,0,0);
1744 _allocate_default_keys();
1745 if (PROFILE_GetWineIniBool(RegistryW, load_win_reg_filesW, 1))
1746 _load_windows_registry( hkey_local_machine, hkey_current_user, hkey_users_default );
1747 if (PROFILE_GetWineIniBool(RegistryW, load_global_reg_filesW, 1))
1748 _load_global_registry( hkey_local_machine, hkey_users );
1749 _set_registry_levels(1,0,0);
1750 if (PROFILE_GetWineIniBool(RegistryW, load_home_reg_filesW, 1))
1751 _load_home_registry( hkey_local_machine, hkey_current_user, hkey_users_default );
1752 _init_registry_saving( hkey_local_machine, hkey_current_user, hkey_users_default );
1753 NtClose(hkey_users_default);
1754 NtClose(hkey_current_user);
1755 NtClose(hkey_users);
1756 NtClose(hkey_local_machine);
1757 }
Windows API implementation