import HEAD into svn+ssh://svn.samba.org/home/svn/samba/trunk
[metze/old/v3-2-winbind-ndr.git] / source / utils / editreg.c
1 /*
2    Samba Unix/Linux SMB client utility editreg.c 
3    Copyright (C) 2002 Richard Sharpe, rsharpe@richardsharpe.com
4
5    This program is free software; you can redistribute it and/or modify
6    it under the terms of the GNU General Public License as published by
7    the Free Software Foundation; either version 2 of the License, or
8    (at your option) any later version.
9    
10    This program is distributed in the hope that it will be useful,
11    but WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13    GNU General Public License for more details.
14    
15    You should have received a copy of the GNU General Public License
16    along with this program; if not, write to the Free Software
17    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
18  
19 /*************************************************************************
20                                                        
21  A utility to edit a Windows NT/2K etc registry file.
22                                      
23  Many of the ideas in here come from other people and software. 
24  I first looked in Wine in misc/registry.c and was also influenced by
25  http://www.wednesday.demon.co.uk/dosreg.html
26
27  Which seems to contain comments from someone else. I reproduce them here
28  incase the site above disappears. It actually comes from 
29  http://home.eunet.no/~pnordahl/ntpasswd/WinReg.txt. 
30
31  The goal here is to read the registry into memory, manipulate it, and then
32  write it out if it was changed by any actions of the user.
33
34 The windows NT registry has 2 different blocks, where one can occur many
35 times...
36
37 the "regf"-Block
38 ================
39  
40 "regf" is obviosly the abbreviation for "Registry file". "regf" is the
41 signature of the header-block which is always 4kb in size, although only
42 the first 64 bytes seem to be used and a checksum is calculated over
43 the first 0x200 bytes only!
44
45 Offset            Size      Contents
46 0x00000000      D-Word      ID: ASCII-"regf" = 0x66676572
47 0x00000004      D-Word      ???? //see struct REGF
48 0x00000008      D-Word      ???? Always the same value as at 0x00000004
49 0x0000000C      Q-Word      last modify date in WinNT date-format
50 0x00000014      D-Word      1
51 0x00000018      D-Word      3
52 0x0000001C      D-Word      0
53 0x00000020      D-Word      1
54 0x00000024      D-Word      Offset of 1st key record
55 0x00000028      D-Word      Size of the data-blocks (Filesize-4kb)
56 0x0000002C      D-Word      1
57 0x000001FC      D-Word      Sum of all D-Words from 0x00000000 to
58 0x000001FB  //XOR of all words. Nigel
59
60 I have analyzed more registry files (from multiple machines running
61 NT 4.0 german version) and could not find an explanation for the values
62 marked with ???? the rest of the first 4kb page is not important...
63
64 the "hbin"-Block
65 ================
66 I don't know what "hbin" stands for, but this block is always a multiple
67 of 4kb in size.
68
69 Inside these hbin-blocks the different records are placed. The memory-
70 management looks like a C-compiler heap management to me...
71
72 hbin-Header
73 ===========
74 Offset      Size      Contents
75 0x0000      D-Word      ID: ASCII-"hbin" = 0x6E696268
76 0x0004      D-Word      Offset from the 1st hbin-Block
77 0x0008      D-Word      Offset to the next hbin-Block
78 0x001C      D-Word      Block-size
79
80 The values in 0x0008 and 0x001C should be the same, so I don't know
81 if they are correct or swapped...
82
83 From offset 0x0020 inside a hbin-block data is stored with the following
84 format:
85
86 Offset      Size      Contents
87 0x0000      D-Word      Data-block size    //this size must be a
88 multiple of 8. Nigel
89 0x0004      ????      Data
90  
91 If the size field is negative (bit 31 set), the corresponding block
92 is free and has a size of -blocksize!
93
94 That does not seem to be true. All block lengths seem to be negative! 
95 (Richard Sharpe) 
96
97 The data is stored as one record per block. Block size is a multiple
98 of 4 and the last block reaches the next hbin-block, leaving no room.
99
100 (That also seems incorrect, in that the block size if a multiple of 8.
101 That is, the block, including the 4 byte header, is always a multiple of
102 8 bytes. Richard Sharpe.)
103
104 Records in the hbin-blocks
105 ==========================
106
107 nk-Record
108
109       The nk-record can be treated as a kombination of tree-record and
110       key-record of the win 95 registry.
111
112 lf-Record
113
114       The lf-record is the counterpart to the RGKN-record (the
115       hash-function)
116
117 vk-Record
118
119       The vk-record consists information to a single value.
120
121 sk-Record
122
123       sk (? Security Key ?) is the ACL of the registry.
124
125 Value-Lists
126
127       The value-lists contain information about which values are inside a
128       sub-key and don't have a header.
129
130 Datas
131
132       The datas of the registry are (like the value-list) stored without a
133       header.
134
135 All offset-values are relative to the first hbin-block and point to the
136 block-size field of the record-entry. to get the file offset, you have to add
137 the header size (4kb) and the size field (4 bytes)...
138
139 the nk-Record
140 =============
141 Offset      Size      Contents
142 0x0000      Word      ID: ASCII-"nk" = 0x6B6E
143 0x0002      Word      for the root-key: 0x2C, otherwise 0x20  //key symbolic links 0x10. Nigel
144 0x0004      Q-Word      write-date/time in windows nt notation
145 0x0010      D-Word      Offset of Owner/Parent key
146 0x0014      D-Word      number of sub-Keys
147 0x001C      D-Word      Offset of the sub-key lf-Records
148 0x0024      D-Word      number of values
149 0x0028      D-Word      Offset of the Value-List
150 0x002C      D-Word      Offset of the sk-Record
151
152 0x0030      D-Word      Offset of the Class-Name //see NK structure for the use of these fields. Nigel
153 0x0044      D-Word      Unused (data-trash)  //some kind of run time index. Does not appear to be important. Nigel
154 0x0048      Word      name-length
155 0x004A      Word      class-name length
156 0x004C      ????      key-name
157
158 the Value-List
159 ==============
160 Offset      Size      Contents
161 0x0000      D-Word      Offset 1st Value
162 0x0004      D-Word      Offset 2nd Value
163 0x????      D-Word      Offset nth Value
164
165 To determine the number of values, you have to look at the owner-nk-record!
166
167 Der vk-Record
168 =============
169 Offset      Size      Contents
170 0x0000      Word      ID: ASCII-"vk" = 0x6B76
171 0x0002      Word      name length
172 0x0004      D-Word      length of the data   //if top bit is set when offset contains data. Nigel
173 0x0008      D-Word      Offset of Data
174 0x000C      D-Word      Type of value
175 0x0010      Word      Flag
176 0x0012      Word      Unused (data-trash)
177 0x0014      ????      Name
178
179 If bit 0 of the flag-word is set, a name is present, otherwise the value has no name (=default)
180
181 If the data-size is lower 5, the data-offset value is used to store the data itself!
182
183 The data-types
184 ==============
185 Wert      Beteutung
186 0x0001      RegSZ:             character string (in UNICODE!)
187 0x0002      ExpandSZ:   string with "%var%" expanding (UNICODE!)
188 0x0003      RegBin:           raw-binary value
189 0x0004      RegDWord:   Dword
190 0x0007      RegMultiSZ:      multiple strings, seperated with 0
191                   (UNICODE!)
192
193 The "lf"-record
194 ===============
195 Offset      Size      Contents
196 0x0000      Word      ID: ASCII-"lf" = 0x666C
197 0x0002      Word      number of keys
198 0x0004      ????      Hash-Records
199
200 Hash-Record
201 ===========
202 Offset      Size      Contents
203 0x0000      D-Word      Offset of corresponding "nk"-Record
204 0x0004      D-Word      ASCII: the first 4 characters of the key-name, padded with 0's. Case sensitiv!
205
206 Keep in mind, that the value at 0x0004 is used for checking the data-consistency! If you change the 
207 key-name you have to change the hash-value too!
208
209 //These hashrecords must be sorted low to high within the lf record. Nigel.
210
211 The "sk"-block
212 ==============
213 (due to the complexity of the SAM-info, not clear jet)
214 (This is just a self-relative security descriptor in the data. R Sharpe.) 
215
216
217 Offset      Size      Contents
218 0x0000      Word      ID: ASCII-"sk" = 0x6B73
219 0x0002      Word      Unused
220 0x0004      D-Word      Offset of previous "sk"-Record
221 0x0008      D-Word      Offset of next "sk"-Record
222 0x000C      D-Word      usage-counter
223 0x0010      D-Word      Size of "sk"-record in bytes
224 ????                                             //standard self
225 relative security desciptor. Nigel
226 ????  ????      Security and auditing settings...
227 ????
228
229 The usage counter counts the number of references to this
230 "sk"-record. You can use one "sk"-record for the entire registry!
231
232 Windows nt date/time format
233 ===========================
234 The time-format is a 64-bit integer which is incremented every
235 0,0000001 seconds by 1 (I don't know how accurate it realy is!)
236 It starts with 0 at the 1st of january 1601 0:00! All values are
237 stored in GMT time! The time-zone is important to get the real
238 time!
239
240 Common values for win95 and win-nt
241 ==================================
242 Offset values marking an "end of list", are either 0 or -1 (0xFFFFFFFF).
243 If a value has no name (length=0, flag(bit 0)=0), it is treated as the
244 "Default" entry...
245 If a value has no data (length=0), it is displayed as empty.
246
247 simplyfied win-3.?? registry:
248 =============================
249
250 +-----------+
251 | next rec. |---+                      +----->+------------+
252 | first sub |   |                      |      | Usage cnt. |
253 | name      |   |  +-->+------------+  |      | length     |
254 | value     |   |  |   | next rec.  |  |      | text       |------->+-------+
255 +-----------+   |  |   | name rec.  |--+      +------------+        | xxxxx |
256    +------------+  |   | value rec. |-------->+------------+        +-------+
257    v               |   +------------+         | Usage cnt. |
258 +-----------+      |                          | length     |
259 | next rec. |      |                          | text       |------->+-------+
260 | first sub |------+                          +------------+        | xxxxx |
261 | name      |                                                       +-------+
262 | value     |
263 +-----------+    
264
265 Greatly simplyfied structure of the nt-registry:
266 ================================================
267    
268 +---------------------------------------------------------------+
269 |                                                               |
270 v                                                               |
271 +---------+     +---------->+-----------+  +----->+---------+   |
272 | "nk"    |     |           | lf-rec.   |  |      | nk-rec. |   |
273 | ID      |     |           | # of keys |  |      | parent  |---+
274 | Date    |     |           | 1st key   |--+      | ....    |
275 | parent  |     |           +-----------+         +---------+
276 | suk-keys|-----+
277 | values  |--------------------->+----------+
278 | SK-rec. |---------------+      | 1. value |--> +----------+
279 | class   |--+            |      +----------+    | vk-rec.  |
280 +---------+  |            |                      | ....     |
281              v            |                      | data     |--> +-------+
282       +------------+      |                      +----------+    | xxxxx |
283       | Class name |      |                                      +-------+
284       +------------+      |
285                           v
286           +---------+    +---------+
287    +----->| next sk |--->| Next sk |--+
288    |  +---| prev sk |<---| prev sk |  |
289    |  |   | ....    |    | ...     |  |
290    |  |   +---------+    +---------+  |
291    |  |                    ^          |
292    |  |                    |          |
293    |  +--------------------+          |
294    +----------------------------------+
295
296 ---------------------------------------------------------------------------
297
298 Hope this helps....  (Although it was "fun" for me to uncover this things,
299                   it took me several sleepless nights ;)
300
301             B.D.
302
303 *************************************************************************/
304
305 #include <stdio.h>
306 #include <stdlib.h>
307 #include <errno.h>
308 #include <assert.h>
309 #include <sys/types.h>
310 #include <sys/stat.h>
311 #include <unistd.h>
312 #include <sys/mman.h>
313 #include <string.h>
314 #include <fcntl.h>
315
316 #define False 0
317 #define True 1
318 #define REG_KEY_LIST_SIZE 10
319
320 /*
321  * Structures for dealing with the on-disk format of the registry
322  */
323
324 #define IVAL(buf) ((unsigned int) \
325                    (unsigned int)*((unsigned char *)(buf)+3)<<24| \
326                    (unsigned int)*((unsigned char *)(buf)+2)<<16| \
327                    (unsigned int)*((unsigned char *)(buf)+1)<<8| \
328                    (unsigned int)*((unsigned char *)(buf)+0)) 
329
330 #define SVAL(buf) ((unsigned short) \
331                    (unsigned short)*((unsigned char *)(buf)+1)<<8| \
332                    (unsigned short)*((unsigned char *)(buf)+0)) 
333
334 #define CVAL(buf) ((unsigned char)*((unsigned char *)(buf)))
335
336 #define SIVAL(buf, val) \
337             ((((unsigned char *)(buf))[0])=(unsigned char)((val)&0xFF),\
338              (((unsigned char *)(buf))[1])=(unsigned char)(((val)>>8)&0xFF),\
339              (((unsigned char *)(buf))[2])=(unsigned char)(((val)>>16)&0xFF),\
340              (((unsigned char *)(buf))[3])=(unsigned char)((val)>>24))
341
342 #define SSVAL(buf, val) \
343             ((((unsigned char *)(buf))[0])=(unsigned char)((val)&0xFF),\
344              (((unsigned char *)(buf))[1])=(unsigned char)((val)>>8))
345
346 static int verbose = 0;
347 static int print_security = 0;
348 static int full_print = 0;
349 static const char *def_owner_sid_str = NULL;
350
351 /* 
352  * These definitions are for the in-memory registry structure.
353  * It is a tree structure that mimics what you see with tools like regedit
354  */
355
356 /*
357  * DateTime struct for Windows
358  */
359
360 typedef struct date_time_s {
361   unsigned int low, high;
362 } NTTIME;
363
364 /*
365  * Definition of a Key. It has a name, classname, date/time last modified,
366  * sub-keys, values, and a security descriptor
367  */
368
369 #define REG_ROOT_KEY 1
370 #define REG_SUB_KEY  2
371 #define REG_SYM_LINK 3
372
373 typedef struct key_sec_desc_s KEY_SEC_DESC;
374
375 typedef struct reg_key_s {
376   char *name;         /* Name of the key                    */
377   char *class_name;
378   int type;           /* One of REG_ROOT_KEY or REG_SUB_KEY */
379   NTTIME last_mod; /* Time last modified                 */
380   struct reg_key_s *owner;
381   struct key_list_s *sub_keys;
382   struct val_list_s *values;
383   KEY_SEC_DESC *security;
384   unsigned int offset;  /* Offset of the record in the file */
385 } REG_KEY;
386
387 /*
388  * The KEY_LIST struct lists sub-keys.
389  */
390
391 typedef struct key_list_s {
392   int key_count;
393   int max_keys;
394   REG_KEY *keys[1];
395 } KEY_LIST;
396
397 typedef struct val_key_s {
398   char *name;
399   int has_name;
400   int data_type;
401   int data_len;
402   void *data_blk;    /* Might want a separate block */
403 } VAL_KEY;
404
405 typedef struct val_list_s {
406   int val_count;
407   int max_vals;
408   VAL_KEY *vals[1];
409 } VAL_LIST;
410
411 #ifndef MAXSUBAUTHS
412 #define MAXSUBAUTHS 15
413 #endif
414
415 typedef struct sid_s {
416   unsigned char ver, auths;
417   unsigned char auth[6];
418   unsigned int sub_auths[MAXSUBAUTHS];
419 } sid_t;
420
421 typedef struct ace_struct_s {
422   unsigned char type, flags;
423   unsigned int perms;   /* Perhaps a better def is in order */
424   sid_t *trustee;
425 } ACE; 
426
427 typedef struct acl_struct_s {
428   unsigned short rev, refcnt;
429   unsigned short num_aces;
430   ACE *aces[1];
431 } ACL;
432
433 typedef struct sec_desc_s {
434   unsigned int rev, type;
435   sid_t *owner, *group;
436   ACL *sacl, *dacl;
437 } SEC_DESC;
438
439 #define SEC_DESC_NON 0
440 #define SEC_DESC_RES 1
441 #define SEC_DESC_OCU 2
442 #define SEC_DESC_NBK 3
443 typedef struct sk_struct SK_HDR;
444 struct key_sec_desc_s {
445   struct key_sec_desc_s *prev, *next;
446   int ref_cnt;
447   int state;
448   int offset;
449   SK_HDR *sk_hdr;     /* This means we must keep the registry in memory */
450   SEC_DESC *sec_desc;
451 }; 
452
453 /* 
454  * All of the structures below actually have a four-byte length before them
455  * which always seems to be negative. The following macro retrieves that
456  * size as an integer
457  */
458
459 #define BLK_SIZE(b) ((int)*(int *)(((int *)b)-1))
460
461 typedef unsigned int DWORD;
462 typedef unsigned short WORD;
463
464 #define REG_REGF_ID 0x66676572
465
466 typedef struct regf_block {
467   DWORD REGF_ID;     /* regf */
468   DWORD uk1;
469   DWORD uk2;
470   DWORD tim1, tim2;
471   DWORD uk3;             /* 1 */
472   DWORD uk4;             /* 3 */
473   DWORD uk5;             /* 0 */
474   DWORD uk6;             /* 1 */
475   DWORD first_key;       /* offset */
476   unsigned int dblk_size;
477   DWORD uk7[116];        /* 1 */
478   DWORD chksum;
479 } REGF_HDR;
480
481 typedef struct hbin_sub_struct {
482   DWORD dblocksize;
483   char data[1];
484 } HBIN_SUB_HDR;
485
486 #define REG_HBIN_ID 0x6E696268
487
488 typedef struct hbin_struct {
489   DWORD HBIN_ID; /* hbin */
490   DWORD off_from_first;
491   DWORD off_to_next;
492   DWORD uk1;
493   DWORD uk2;
494   DWORD uk3;
495   DWORD uk4;
496   DWORD blk_size;
497   HBIN_SUB_HDR hbin_sub_hdr;
498 } HBIN_HDR;
499
500 #define REG_NK_ID 0x6B6E
501
502 typedef struct nk_struct {
503   WORD NK_ID;
504   WORD type;
505   DWORD t1, t2;
506   DWORD uk1;
507   DWORD own_off;
508   DWORD subk_num;
509   DWORD uk2;
510   DWORD lf_off;
511   DWORD uk3;
512   DWORD val_cnt;
513   DWORD val_off;
514   DWORD sk_off;
515   DWORD clsnam_off;
516   DWORD unk4[4];
517   DWORD unk5;
518   WORD nam_len;
519   WORD clsnam_len;
520   char key_nam[1];  /* Actual length determined by nam_len */
521 } NK_HDR;
522
523 #define REG_SK_ID 0x6B73
524
525 struct sk_struct {
526   WORD SK_ID;
527   WORD uk1;
528   DWORD prev_off;
529   DWORD next_off;
530   DWORD ref_cnt;
531   DWORD rec_size;
532   char sec_desc[1];
533 };
534
535 typedef struct ace_struct {
536     unsigned char type;
537     unsigned char flags;
538     unsigned short length;
539     unsigned int perms;
540     sid_t trustee;
541 } REG_ACE;
542
543 typedef struct acl_struct {
544   WORD rev;
545   WORD size;
546   DWORD num_aces;
547   REG_ACE *aces;   /* One or more ACEs */
548 } REG_ACL;
549
550 typedef struct sec_desc_rec {
551   WORD rev;
552   WORD type;
553   DWORD owner_off;
554   DWORD group_off;
555   DWORD sacl_off;
556   DWORD dacl_off;
557 } REG_SEC_DESC;
558
559 typedef struct hash_struct {
560   DWORD nk_off;
561   char hash[4];
562 } HASH_REC;
563
564 #define REG_LF_ID 0x666C
565
566 typedef struct lf_struct {
567   WORD LF_ID;
568   WORD key_count;
569   struct hash_struct hr[1];  /* Array of hash records, depending on key_count */
570 } LF_HDR;
571
572 typedef DWORD VL_TYPE[1];  /* Value list is an array of vk rec offsets */
573
574 #define REG_VK_ID 0x6B76
575
576 typedef struct vk_struct {
577   WORD VK_ID;
578   WORD nam_len;
579   DWORD dat_len;    /* If top-bit set, offset contains the data */
580   DWORD dat_off;   
581   DWORD dat_type;
582   WORD flag;        /* =1, has name, else no name (=Default). */
583   WORD unk1;
584   char dat_name[1]; /* Name starts here ... */
585 } VK_HDR;
586
587 #define REG_TYPE_DELETE    -1
588 #define REG_TYPE_NONE      0
589 #define REG_TYPE_REGSZ     1
590 #define REG_TYPE_EXPANDSZ  2
591 #define REG_TYPE_BIN       3  
592 #define REG_TYPE_DWORD     4
593 #define REG_TYPE_MULTISZ   7
594
595 typedef struct _val_str { 
596   unsigned int val;
597   const char * str;
598 } VAL_STR;
599
600 /* A map of sk offsets in the regf to KEY_SEC_DESCs for quick lookup etc */
601 typedef struct sk_map_s {
602   int sk_off;
603   KEY_SEC_DESC *key_sec_desc;
604 } SK_MAP;
605
606 /*
607  * This structure keeps track of the output format of the registry
608  */
609 #define REG_OUTBLK_HDR 1
610 #define REG_OUTBLK_HBIN 2
611
612 typedef struct hbin_blk_s {
613   int type, size;
614   struct hbin_blk_s *next;
615   char *data;                /* The data block                */
616   unsigned int file_offset;  /* Offset in file                */
617   unsigned int free_space;   /* Amount of free space in block */
618   unsigned int fsp_off;      /* Start of free space in block  */
619   int complete, stored;
620 } HBIN_BLK;
621
622 /*
623  * This structure keeps all the registry stuff in one place
624  */
625 typedef struct regf_struct_s {
626   int reg_type;
627   char *regfile_name, *outfile_name;
628   int fd;
629   struct stat sbuf;
630   char *base;
631   int modified;
632   NTTIME last_mod_time;
633   REG_KEY *root;  /* Root of the tree for this file */
634   int sk_count, sk_map_size;
635   SK_MAP *sk_map;
636   const char *owner_sid_str;
637   SEC_DESC *def_sec_desc;
638   /*
639    * These next pointers point to the blocks used to contain the 
640    * keys when we are preparing to write them to a file
641    */
642   HBIN_BLK *blk_head, *blk_tail, *free_space;
643 } REGF;
644
645 /*
646  * An API for accessing/creating/destroying items above
647  */
648
649 /*
650  * Iterate over the keys, depth first, calling a function for each key
651  * and indicating if it is terminal or non-terminal and if it has values.
652  *
653  * In addition, for each value in the list, call a value list function
654  */
655
656 typedef int (*key_print_f)(const char *path, char *key_name, char *class_name, 
657                            int root, int terminal, int values);
658
659 typedef int (*val_print_f)(const char *path, char *val_name, int val_type, 
660                            int data_len, void *data_blk, int terminal,
661                            int first, int last);
662
663 typedef int (*sec_print_f)(SEC_DESC *sec_desc);
664
665 static
666 int nt_key_iterator(REGF *regf, REG_KEY *key_tree, int bf, const char *path, 
667                     key_print_f key_print, sec_print_f sec_print,
668                     val_print_f val_print);
669
670 static
671 int nt_val_list_iterator(REGF *regf, VAL_LIST *val_list, int bf, char *path,
672                          int terminal, val_print_f val_print)
673 {
674   int i;
675
676   if (!val_list) return 1;
677
678   if (!val_print) return 1;
679
680   for (i=0; i<val_list->val_count; i++) {
681     if (!val_print(path, val_list->vals[i]->name, val_list->vals[i]->data_type,
682                    val_list->vals[i]->data_len, val_list->vals[i]->data_blk,
683                    terminal,
684                    (i == 0),
685                    (i == val_list->val_count))) {
686
687       return 0;
688
689     }
690   }
691
692   return 1;
693 }
694
695 static
696 int nt_key_list_iterator(REGF *regf, KEY_LIST *key_list, int bf, 
697                          const char *path,
698                          key_print_f key_print, sec_print_f sec_print, 
699                          val_print_f val_print)
700 {
701   int i;
702
703   if (!key_list) return 1;
704
705   for (i=0; i< key_list->key_count; i++) {
706     if (!nt_key_iterator(regf, key_list->keys[i], bf, path, key_print, 
707                          sec_print, val_print)) {
708       return 0;
709     }
710   }
711   return 1;
712 }
713
714 static
715 int nt_key_iterator(REGF *regf, REG_KEY *key_tree, int bf, const char *path,
716                     key_print_f key_print, sec_print_f sec_print,
717                     val_print_f val_print)
718 {
719   int path_len = strlen(path);
720   char *new_path;
721
722   if (!regf || !key_tree)
723     return -1;
724
725   /* List the key first, then the values, then the sub-keys */
726
727   if (key_print) {
728
729     if (!(*key_print)(path, key_tree->name, 
730                       key_tree->class_name, 
731                       (key_tree->type == REG_ROOT_KEY),
732                       (key_tree->sub_keys == NULL),
733                       (key_tree->values?(key_tree->values->val_count):0)))
734       return 0;
735   }
736
737   /*
738    * If we have a security print routine, call it
739    * If the security print routine returns false, stop.
740    */
741   if (sec_print) {
742     if (key_tree->security && !(*sec_print)(key_tree->security->sec_desc))
743       return 0;
744   }
745
746   new_path = (char *)malloc(path_len + 1 + strlen(key_tree->name) + 1);
747   if (!new_path) return 0; /* Errors? */
748   new_path[0] = '\0';
749   strcat(new_path, path);
750   strcat(new_path, key_tree->name);
751   strcat(new_path, "\\");
752
753   /*
754    * Now, iterate through the values in the val_list 
755    */
756
757   if (key_tree->values &&
758       !nt_val_list_iterator(regf, key_tree->values, bf, new_path, 
759                             (key_tree->values!=NULL),
760                             val_print)) {
761
762     free(new_path);
763     return 0;
764   } 
765
766   /* 
767    * Now, iterate through the keys in the key list
768    */
769
770   if (key_tree->sub_keys && 
771       !nt_key_list_iterator(regf, key_tree->sub_keys, bf, new_path, key_print, 
772                             sec_print, val_print)) {
773     free(new_path);
774     return 0;
775   } 
776
777   free(new_path);
778   return 1;
779 }
780
781 static
782 REG_KEY *nt_find_key_by_name(REG_KEY *tree, char *key);
783
784 /*
785  * Find key by name in a list ...
786  * Take the first component and search for that in the list
787  */
788 static
789 REG_KEY *nt_find_key_in_list_by_name(KEY_LIST *list, char *key)
790 {
791   int i;
792   REG_KEY *res = NULL;
793
794   if (!list || !key || !*key) return NULL;
795
796   for (i = 0; i < list->key_count; i++)
797     if ((res = nt_find_key_by_name(list->keys[i], key)))
798       return res;
799   
800   return NULL;
801 }
802
803 /* 
804  * Find key by name in a tree ... We will assume absolute names here, but we
805  * need the root of the tree ...
806  */
807 static
808 REG_KEY *nt_find_key_by_name(REG_KEY *tree, char *key)
809 {
810   char *lname = NULL, *c1, *c2;
811   REG_KEY *tmp;
812
813   if (!tree || !key || !*key) return NULL;
814
815   lname = strdup(key);
816   if (!lname) return NULL;
817
818   /*
819    * Make sure that the first component is correct ...
820    */
821   c1 = lname;
822   c2 = strchr(c1, '\\');
823   if (c2) { /* Split here ... */
824     *c2 = 0;
825     c2++;
826   }
827   if (strcmp(c1, tree->name) != 0) goto error; 
828
829   if (c2) {
830     tmp = nt_find_key_in_list_by_name(tree->sub_keys, c2);
831     free(lname);
832     return tmp;
833   }
834   else {
835     if (lname) free(lname);
836     return tree;
837   }
838  error:
839   if (lname) free(lname);
840   return NULL;
841 }
842
843 /* Make, delete keys */
844 static
845 int nt_delete_val_key(VAL_KEY *val_key)
846 {
847
848   if (val_key) {
849     if (val_key->name) free(val_key->name);
850     if (val_key->data_blk) free(val_key->data_blk);
851     free(val_key);
852   };
853   return 1;
854 }
855
856 static
857 int nt_delete_val_list(VAL_LIST *vl)
858 {
859   int i;
860
861   if (vl) {
862     for (i=0; i<vl->val_count; i++)
863       nt_delete_val_key(vl->vals[i]);
864     free(vl);
865   }
866   return 1;
867 }
868
869 static
870 int nt_delete_reg_key(REG_KEY *key, int delete_name);
871
872 static
873 int nt_delete_key_list(KEY_LIST *key_list, int delete_name)
874 {
875   int i;
876
877   if (key_list) {
878     for (i=0; i<key_list->key_count; i++) 
879       nt_delete_reg_key(key_list->keys[i], False);
880     free(key_list);
881   }
882   return 1;
883 }
884
885 /*
886  * Find the key, and if it exists, delete it ...
887  */
888 static
889 int nt_delete_key_by_name(REGF *regf, char *name)
890 {
891   REG_KEY *key;
892
893   if (!name || !*name) return 0;
894
895   key = nt_find_key_by_name(regf->root, name);
896
897   if (key) {
898     if (key == regf->root) regf->root = NULL;
899     return nt_delete_reg_key(key, True);
900   }
901
902   return 0;
903
904 }
905
906 static
907 int nt_delete_sid(sid_t *sid)
908 {
909
910   if (sid) free(sid);
911   return 1;
912
913 }
914
915 static
916 int nt_delete_ace(ACE *ace)
917 {
918
919   if (ace) {
920     nt_delete_sid(ace->trustee);
921     free(ace);
922   }
923   return 1;
924
925 }
926
927 static
928 int nt_delete_acl(ACL *acl)
929 {
930
931   if (acl) {
932     int i;
933
934     for (i=0; i<acl->num_aces; i++)
935       nt_delete_ace(acl->aces[i]);
936
937     free(acl);
938   }
939   return 1;
940 }
941
942 static
943 int nt_delete_sec_desc(SEC_DESC *sec_desc)
944 {
945
946   if (sec_desc) {
947
948     nt_delete_sid(sec_desc->owner);
949     nt_delete_sid(sec_desc->group);
950     nt_delete_acl(sec_desc->sacl);
951     nt_delete_acl(sec_desc->dacl);
952     free(sec_desc);
953
954   }
955   return 1;
956 }
957
958 static
959 int nt_delete_key_sec_desc(KEY_SEC_DESC *key_sec_desc)
960 {
961
962   if (key_sec_desc) {
963     key_sec_desc->ref_cnt--;
964     if (key_sec_desc->ref_cnt<=0) {
965       /*
966        * There should always be a next and prev, even if they point to us 
967        */
968       key_sec_desc->next->prev = key_sec_desc->prev;
969       key_sec_desc->prev->next = key_sec_desc->next;
970       nt_delete_sec_desc(key_sec_desc->sec_desc);
971     }
972   }
973   return 1;
974 }
975
976 static
977 int nt_delete_reg_key(REG_KEY *key, int delete_name)
978 {
979
980   if (key) {
981     if (key->name) free(key->name);
982     if (key->class_name) free(key->class_name);
983
984     /*
985      * We will delete the owner if we are not the root and told to ...
986      */
987
988     if (key->owner && key->owner->sub_keys && delete_name) {
989       REG_KEY *own;
990       KEY_LIST *kl;
991       int i;
992       /* Find our owner, look in keylist for us and shuffle up */
993       /* Perhaps should be a function                          */
994
995       own = key->owner;
996       kl = own->sub_keys;
997
998       for (i=0; i < kl->key_count && kl->keys[i] != key ; i++) {
999         /* Just find the entry ... */
1000       }
1001
1002       if (i == kl->key_count) {
1003         fprintf(stderr, "Bad data structure. Key not found in key list of owner\n");
1004       }
1005       else {
1006         int j;
1007
1008         /*
1009          * Shuffle up. Works for the last one also 
1010          */
1011         for (j = i + 1; j < kl->key_count; j++) {
1012           kl->keys[j - 1] = kl->keys[j];
1013         }
1014
1015         kl->key_count--;
1016       }
1017     }
1018
1019     if (key->sub_keys) nt_delete_key_list(key->sub_keys, False);
1020     if (key->values) nt_delete_val_list(key->values);
1021     if (key->security) nt_delete_key_sec_desc(key->security);
1022     free(key);
1023   }
1024   return 1;
1025 }
1026
1027 /*
1028  * Convert a string to a value ...
1029  * FIXME: Error handling and convert this at command parse time ... 
1030  */
1031 static
1032 void *str_to_val(int type, char *val, int *len)
1033 {
1034   unsigned int *dwordp = NULL;
1035
1036   if (!len || !val) return NULL;
1037
1038   switch (type) {
1039   case REG_TYPE_REGSZ:
1040     *len = strlen(val);
1041     return (void *)val;
1042
1043   case REG_TYPE_DWORD:
1044     dwordp = (unsigned int *)malloc(sizeof(unsigned int));
1045     if (!dwordp) return NULL;
1046     /* Allow for ddddd and 0xhhhhh and 0ooooo */
1047     if (strncmp(val, "0x", 2) == 0 || strncmp(val, "0X", 2) == 0) {
1048       sscanf(&val[2], "%X", dwordp);
1049     }
1050     else if (*val == '0') {
1051       sscanf(&val[1], "%o", dwordp);
1052     }
1053     else { 
1054       sscanf(val, "%d", dwordp);
1055     }
1056     *len = sizeof(unsigned int);
1057     return (void *)dwordp;
1058
1059     /* FIXME: Implement more of these */
1060
1061   default:
1062     return NULL;
1063   }
1064
1065   return NULL;
1066 }
1067
1068 /*
1069  * Add a value to the key specified ... We have to parse the value some more
1070  * based on the type to get it in the correct internal form
1071  * An empty name will be converted to "<No Name>" before here
1072  * Hmmm, maybe not. has_name is for that
1073  */
1074 static
1075 VAL_KEY *nt_add_reg_value(REG_KEY *key, char *name, int type, char *value)
1076 {
1077   int i;
1078   VAL_KEY *tmp = NULL;
1079
1080   if (!key || !key->values || !name || !*name) return NULL;
1081
1082   assert(type != REG_TYPE_DELETE); /* We never process deletes here */
1083
1084   for (i = 0; i < key->values->val_count; i++) {
1085     if ((!key->values->vals[i]->has_name && !*name) || 
1086         (key->values->vals[i]->has_name &&
1087          strcmp(name, key->values->vals[i]->name) == 0)){ /* Change the value */
1088       free(key->values->vals[i]->data_blk);
1089       key->values->vals[i]->data_blk = str_to_val(type, value, &
1090                                                   key->values->vals[i]->data_len);
1091       return key->values->vals[i];
1092     }
1093   }
1094
1095   /* 
1096    * If we get here, the name was not found, so insert it 
1097    */
1098
1099   tmp = (VAL_KEY *)malloc(sizeof(VAL_KEY));
1100   if (!tmp) goto error;
1101
1102   memset(tmp, 0, sizeof(VAL_KEY));
1103   tmp->name = strdup(name);
1104   tmp->has_name = True;
1105   if (!tmp->name) goto error;
1106   tmp->data_type = type;
1107   tmp->data_blk = str_to_val(type, value, &tmp->data_len);
1108
1109   /* Now, add to val list */
1110
1111   if (key->values->val_count >= key->values->max_vals) {
1112     /*
1113      * Allocate some more space 
1114      */
1115
1116     if ((key->values = (VAL_LIST *)realloc(key->values, sizeof(VAL_LIST) + 
1117                                            key->values->val_count - 1 +
1118                                            REG_KEY_LIST_SIZE))) {
1119       key->values->max_vals += REG_KEY_LIST_SIZE;
1120     }
1121     else goto error;
1122   }
1123
1124   i = key->values->val_count;
1125   key->values->val_count++;
1126   key->values->vals[i] = tmp;
1127   return tmp;
1128
1129  error:
1130   if (tmp) nt_delete_val_key(tmp);
1131   return NULL;
1132 }
1133
1134 /*
1135  * Delete a value. We return the value and let the caller deal with it. 
1136  */
1137 static
1138 VAL_KEY *nt_delete_reg_value(REG_KEY *key, char *name)
1139 {
1140   int i, j;
1141
1142   if (!key || !key->values || !name || !*name) return NULL;
1143
1144   /* FIXME: Allow empty value name */
1145   for (i = 0; i< key->values->val_count; i++) {
1146     if ((!key->values->vals[i]->has_name && !*name) || 
1147         (key->values->vals[i]->has_name &&
1148          strcmp(name, key->values->vals[i]->name) == 0)) {
1149       VAL_KEY *val;
1150
1151       val = key->values->vals[i];
1152
1153       /* Shuffle down */
1154       for (j = i + 1; j < key->values->val_count; j++)
1155         key->values->vals[j - 1] = key->values->vals[j];
1156
1157       key->values->val_count--;
1158
1159       return val;
1160     }
1161   }
1162   return NULL;
1163 }
1164
1165 /* 
1166  * Add a key to the tree ... We walk down the components matching until
1167  * we don't find any. There must be a match on the first component ...
1168  * We return the key structure for the final component as that is 
1169  * often where we want to add values ...
1170  */
1171
1172 /*
1173  * Convert a string of the form S-1-5-x[-y-z-r] to a SID
1174  */
1175 static
1176 int sid_string_to_sid(sid_t **sid, const char *sid_str)
1177 {
1178   int i = 0, auth;
1179   const char *lstr; 
1180
1181   *sid = (sid_t *)malloc(sizeof(sid_t));
1182   if (!*sid) return 0;
1183
1184   memset(*sid, 0, sizeof(sid_t));
1185
1186   if (strncmp(sid_str, "S-1-5", 5)) {
1187     fprintf(stderr, "Does not conform to S-1-5...: %s\n", sid_str);
1188     return 0;
1189   }
1190
1191   /* We only allow strings of form S-1-5... */
1192
1193   (*sid)->ver = 1;
1194   (*sid)->auth[5] = 5;
1195
1196   lstr = sid_str + 5;
1197
1198   while (1) {
1199     if (!lstr || !lstr[0] || sscanf(lstr, "-%u", &auth) == 0) {
1200       if (i < 1) {
1201         fprintf(stderr, "Not of form -d-d...: %s, %u\n", lstr, i);
1202         return 0;
1203       }
1204       (*sid)->auths=i;
1205       return 1;
1206     }
1207
1208     (*sid)->sub_auths[i] = auth;
1209     i++;
1210     lstr = strchr(lstr + 1, '-'); 
1211   }
1212
1213   /*return 1; */ /* Not Reached ... */
1214 }
1215
1216 /*
1217  * Create an ACE
1218  */
1219 static
1220 ACE *nt_create_ace(int type, int flags, unsigned int perms, const char *sid)
1221 {
1222   ACE *ace;
1223
1224   ace = (ACE *)malloc(sizeof(ACE));
1225   if (!ace) goto error;
1226   ace->type = type;
1227   ace->flags = flags;
1228   ace->perms = perms;
1229   if (!sid_string_to_sid(&ace->trustee, sid))
1230     goto error;
1231   return ace;
1232
1233  error:
1234   if (ace) nt_delete_ace(ace);
1235   return NULL;
1236 }
1237
1238 /*
1239  * Create a default ACL
1240  */
1241 static
1242 ACL *nt_create_default_acl(REGF *regf)
1243 {
1244   ACL *acl;
1245
1246   acl = (ACL *)malloc(sizeof(ACL) + 7*sizeof(ACE *));
1247   if (!acl) goto error;
1248
1249   acl->rev = 2;
1250   acl->refcnt = 1;
1251   acl->num_aces = 8;
1252
1253   acl->aces[0] = nt_create_ace(0x00, 0x0, 0xF003F, regf->owner_sid_str);
1254   if (!acl->aces[0]) goto error;
1255   acl->aces[1] = nt_create_ace(0x00, 0x0, 0xF003F, "S-1-5-18");
1256   if (!acl->aces[1]) goto error;
1257   acl->aces[2] = nt_create_ace(0x00, 0x0, 0xF003F, "S-1-5-32-544");
1258   if (!acl->aces[2]) goto error;
1259   acl->aces[3] = nt_create_ace(0x00, 0x0, 0x20019, "S-1-5-12");
1260   if (!acl->aces[3]) goto error;
1261   acl->aces[4] = nt_create_ace(0x00, 0x0B, 0x10000000, regf->owner_sid_str);
1262   if (!acl->aces[4]) goto error;
1263   acl->aces[5] = nt_create_ace(0x00, 0x0B, 0x10000000, "S-1-5-18");
1264   if (!acl->aces[5]) goto error;
1265   acl->aces[6] = nt_create_ace(0x00, 0x0B, 0x10000000, "S-1-5-32-544");
1266   if (!acl->aces[6]) goto error;
1267   acl->aces[7] = nt_create_ace(0x00, 0x0B, 0x80000000, "S-1-5-12");
1268   if (!acl->aces[7]) goto error;
1269   return acl;
1270
1271  error:
1272   if (acl) nt_delete_acl(acl);
1273   return NULL;
1274 }
1275
1276 /*
1277  * Create a default security descriptor. We pull in things from env
1278  * if need be 
1279  */
1280 static
1281 SEC_DESC *nt_create_def_sec_desc(REGF *regf)
1282 {
1283   SEC_DESC *tmp;
1284
1285   tmp = (SEC_DESC *)malloc(sizeof(SEC_DESC));
1286   if (!tmp) return NULL;
1287
1288   tmp->rev = 1;
1289   tmp->type = 0x8004;
1290   if (!sid_string_to_sid(&tmp->owner, "S-1-5-32-544")) goto error;
1291   if (!sid_string_to_sid(&tmp->group, "S-1-5-18")) goto error;
1292   tmp->sacl = NULL;
1293   tmp->dacl = nt_create_default_acl(regf);
1294
1295   return tmp;
1296
1297  error:
1298   if (tmp) nt_delete_sec_desc(tmp);
1299   return NULL;
1300 }
1301
1302 /*
1303  * We will implement inheritence that is based on what the parent's SEC_DESC
1304  * says, but the Owner and Group SIDs can be overwridden from the command line
1305  * and additional ACEs can be applied from the command line etc.
1306  */
1307 static
1308 KEY_SEC_DESC *nt_inherit_security(REG_KEY *key)
1309 {
1310
1311   if (!key) return NULL;
1312   return key->security;
1313 }
1314
1315 /*
1316  * Create an initial security descriptor and init other structures, if needed
1317  * We assume that the initial security stuff is empty ...
1318  */
1319 static
1320 KEY_SEC_DESC *nt_create_init_sec(REGF *regf)
1321 {
1322   KEY_SEC_DESC *tsec = NULL;
1323   
1324   tsec = (KEY_SEC_DESC *)malloc(sizeof(KEY_SEC_DESC));
1325   if (!tsec) return NULL;
1326
1327   tsec->ref_cnt = 1;
1328   tsec->state = SEC_DESC_NBK;
1329   tsec->offset = 0;
1330
1331   tsec->sec_desc = regf->def_sec_desc;
1332
1333   return tsec;
1334 }
1335
1336 /*
1337  * Add a sub-key 
1338  */
1339 static
1340 REG_KEY *nt_add_reg_key_list(REGF *regf, REG_KEY *key, char * name, int create)
1341 {
1342   int i;
1343   REG_KEY *ret = NULL, *tmp = NULL;
1344   KEY_LIST *list;
1345   char *lname, *c1, *c2;
1346
1347   if (!key || !name || !*name) return NULL;
1348   
1349   list = key->sub_keys;
1350   if (!list) { /* Create an empty list */
1351
1352     list = (KEY_LIST *)malloc(sizeof(KEY_LIST) + (REG_KEY_LIST_SIZE - 1) * sizeof(REG_KEY *));
1353     list->key_count = 0;
1354     list->max_keys = REG_KEY_LIST_SIZE;
1355
1356   }
1357
1358   lname = strdup(name);
1359   if (!lname) return NULL;
1360
1361   c1 = lname;
1362   c2 = strchr(c1, '\\');
1363   if (c2) { /* Split here ... */
1364     *c2 = 0;
1365     c2++;
1366   }
1367
1368   for (i = 0; i < list->key_count; i++) {
1369     if (strcmp(list->keys[i]->name, c1) == 0) {
1370       ret = nt_add_reg_key_list(regf, list->keys[i], c2, create);
1371       free(lname);
1372       return ret;
1373     }
1374   }
1375
1376   /*
1377    * If we reach here we could not find the the first component
1378    * so create it ...
1379    */
1380
1381   if (list->key_count < list->max_keys){
1382     list->key_count++;
1383   }
1384   else { /* Create more space in the list ... */
1385     if (!(list = (KEY_LIST *)realloc(list, sizeof(KEY_LIST) + 
1386                                      (list->max_keys + REG_KEY_LIST_SIZE - 1) 
1387                                      * sizeof(REG_KEY *))))
1388       goto error;
1389
1390     list->max_keys += REG_KEY_LIST_SIZE;
1391     list->key_count++;
1392   }
1393
1394   /*
1395    * add the new key at the new slot 
1396    * FIXME: Sort the list someday
1397    */
1398
1399   /*
1400    * We want to create the key, and then do the rest
1401    */
1402
1403   tmp = (REG_KEY *)malloc(sizeof(REG_KEY)); 
1404
1405   memset(tmp, 0, sizeof(REG_KEY));
1406
1407   tmp->name = strdup(c1);
1408   if (!tmp->name) goto error;
1409   tmp->owner = key;
1410   tmp->type = REG_SUB_KEY;
1411   /*
1412    * Next, pull security from the parent, but override with
1413    * anything passed in on the command line
1414    */
1415   tmp->security = nt_inherit_security(key);
1416
1417   list->keys[list->key_count - 1] = tmp;
1418
1419   if (c2) {
1420     ret = nt_add_reg_key_list(regf, key, c2, True);
1421   }
1422
1423   if (lname) free(lname);
1424
1425   return ret;
1426
1427  error:
1428   if (tmp) free(tmp);
1429   if (lname) free(lname);
1430   return NULL;
1431 }
1432
1433 /*
1434  * This routine only adds a key from the root down.
1435  * It calls helper functions to handle sub-key lists and sub-keys
1436  */
1437 static
1438 REG_KEY *nt_add_reg_key(REGF *regf, char *name, int create)
1439 {
1440   char *lname = NULL, *c1, *c2;
1441   REG_KEY * tmp = NULL;
1442
1443   /*
1444    * Look until we hit the first component that does not exist, and
1445    * then add from there. However, if the first component does not 
1446    * match and the path we are given is the root, then it must match
1447    */
1448   if (!regf || !name || !*name) return NULL;
1449
1450   lname = strdup(name);
1451   if (!lname) return NULL;
1452
1453   c1 = lname;
1454   c2 = strchr(c1, '\\');
1455   if (c2) { /* Split here ... */
1456     *c2 = 0;
1457     c2++;
1458   }
1459
1460   /*
1461    * If the root does not exist, create it and make it equal to the
1462    * first component ...
1463    */
1464
1465   if (!regf->root) {
1466     
1467     tmp = (REG_KEY *)malloc(sizeof(REG_KEY));
1468     if (!tmp) goto error;
1469     memset(tmp, 0, sizeof(REG_KEY));
1470     tmp->name = strdup(c1);
1471     if (!tmp->name) goto error;
1472     tmp->security = nt_create_init_sec(regf);
1473     if (!tmp->security) goto error;
1474     regf->root = tmp;
1475
1476   }
1477   else {
1478     /*
1479      * If we don't match, then we have to return error ...
1480      * If we do match on this component, check the next one in the
1481      * list, and if not found, add it ... short circuit, add all the
1482      * way down
1483      */
1484
1485     if (strcmp(c1, regf->root->name) != 0)
1486       goto error;
1487   }
1488
1489   tmp = nt_add_reg_key_list(regf, regf->root, c2, True);
1490   free(lname);
1491   return tmp;
1492   
1493  error:
1494   if (tmp) free(tmp);
1495   if (lname) free(lname);
1496   return NULL;
1497 }
1498
1499 /*
1500  * Load and unload a registry file.
1501  *
1502  * Load, loads it into memory as a tree, while unload sealizes/flattens it
1503  */
1504
1505 /*
1506  * Get the starting record for NT Registry file 
1507  */
1508
1509 /* 
1510  * Where we keep all the regf stuff for one registry.
1511  * This is the structure that we use to tie the in memory tree etc 
1512  * together. By keeping separate structs, we can operate on different
1513  * registries at the same time.
1514  * Currently, the SK_MAP is an array of mapping structure.
1515  * Since we only need this on input and output, we fill in the structure
1516  * as we go on input. On output, we know how many SK items we have, so
1517  * we can allocate the structure as we need to.
1518  * If you add stuff here that is dynamically allocated, add the 
1519  * appropriate free statements below.
1520  */
1521
1522 #define REGF_REGTYPE_NONE 0
1523 #define REGF_REGTYPE_NT   1
1524 #define REGF_REGTYPE_W9X  2
1525
1526 #define TTTONTTIME(r, t1, t2) (r)->last_mod_time.low = (t1); \
1527                               (r)->last_mod_time.high = (t2);
1528
1529 #define REGF_HDR_BLKSIZ 0x1000 
1530
1531 #define OFF(f) ((f) + REGF_HDR_BLKSIZ + 4) 
1532 #define LOCN(base, f) ((base) + OFF(f))
1533
1534 const VAL_STR reg_type_names[] = {
1535    { REG_TYPE_REGSZ,    "REG_SZ" },
1536    { REG_TYPE_EXPANDSZ, "REG_EXPAND_SZ" },
1537    { REG_TYPE_BIN,      "REG_BIN" },
1538    { REG_TYPE_DWORD,    "REG_DWORD" },
1539    { REG_TYPE_MULTISZ,  "REG_MULTI_SZ" },
1540    { 0, NULL },
1541 };
1542
1543 static
1544 const char *val_to_str(unsigned int val, const VAL_STR *val_array)
1545 {
1546   int i = 0;
1547
1548   if (!val_array) return NULL;
1549
1550   while (val_array[i].val && val_array[i].str) {
1551
1552     if (val_array[i].val == val) return val_array[i].str;
1553     i++;
1554
1555   }
1556
1557   return NULL;
1558
1559 }
1560
1561 /*
1562  * Convert from UniCode to Ascii ... Does not take into account other lang
1563  * Restrict by ascii_max if > 0
1564  */
1565 static
1566 int uni_to_ascii(unsigned char *uni, unsigned char *ascii, int ascii_max, 
1567                  int uni_max)
1568 {
1569   int i = 0; 
1570
1571   while (i < ascii_max && !(!uni[i*2] && !uni[i*2+1])) {
1572     if (uni_max > 0 && (i*2) >= uni_max) break;
1573     ascii[i] = uni[i*2];
1574     i++;
1575
1576   }
1577
1578   ascii[i] = '\0';
1579
1580   return i;
1581 }
1582
1583 /*
1584  * Convert a data value to a string for display
1585  */
1586 static
1587 int data_to_ascii(unsigned char *datap, int len, int type, char *ascii, int ascii_max)
1588
1589   unsigned char *asciip;
1590   int i;
1591
1592   switch (type) {
1593   case REG_TYPE_REGSZ:
1594     if (verbose) fprintf(stderr, "Len: %d\n", len);
1595     /* FIXME. This has to be fixed. It has to be UNICODE */ 
1596     return uni_to_ascii(datap, ascii, len, ascii_max);
1597     break; /*NOTREACHED*/
1598
1599   case REG_TYPE_EXPANDSZ:
1600     return uni_to_ascii(datap, ascii, len, ascii_max);
1601     break;
1602
1603   case REG_TYPE_BIN:
1604     asciip = ascii;
1605     for (i=0; (i<len)&&(i+1)*3<ascii_max; i++) { 
1606       int str_rem = ascii_max - ((int)asciip - (int)ascii);
1607       asciip += snprintf(asciip, str_rem, "%02x", *(unsigned char *)(datap+i));
1608       if (i < len && str_rem > 0)
1609         *asciip = ' '; asciip++;        
1610     }
1611     *asciip = '\0';
1612     return ((int)asciip - (int)ascii);
1613     break;
1614
1615   case REG_TYPE_DWORD:
1616     if (*(int *)datap == 0)
1617       return snprintf(ascii, ascii_max, "0");
1618     else
1619       return snprintf(ascii, ascii_max, "0x%x", *(int *)datap);
1620     break;
1621
1622   case REG_TYPE_MULTISZ:
1623
1624     break;
1625
1626   default:
1627     return 0;
1628     break;
1629   } 
1630
1631   return len;
1632
1633 }
1634
1635 static
1636 REG_KEY *nt_get_key_tree(REGF *regf, NK_HDR *nk_hdr, int size, REG_KEY *parent);
1637
1638 static
1639 int nt_set_regf_input_file(REGF *regf, char *filename)
1640 {
1641   return ((regf->regfile_name = strdup(filename)) != NULL); 
1642 }
1643
1644 static
1645 int nt_set_regf_output_file(REGF *regf, char *filename)
1646 {
1647   return ((regf->outfile_name = strdup(filename)) != NULL); 
1648 }
1649
1650 /* Create a regf structure and init it */
1651
1652 static
1653 REGF *nt_create_regf(void)
1654 {
1655   REGF *tmp = (REGF *)malloc(sizeof(REGF));
1656   if (!tmp) return tmp;
1657   memset(tmp, 0, sizeof(REGF));
1658   tmp->owner_sid_str = def_owner_sid_str;
1659   return tmp;
1660
1661
1662 /* Free all the bits and pieces ... Assumes regf was malloc'd */
1663 /* If you add stuff to REGF, add the relevant free bits here  */
1664 static
1665 int nt_free_regf(REGF *regf)
1666 {
1667   if (!regf) return 0;
1668
1669   if (regf->regfile_name) free(regf->regfile_name);
1670   if (regf->outfile_name) free(regf->outfile_name);
1671
1672   nt_delete_reg_key(regf->root, False); /* Free the tree */
1673   free(regf->sk_map);
1674   regf->sk_count = regf->sk_map_size = 0;
1675
1676   free(regf);
1677
1678   return 1;
1679 }
1680
1681 /* Get the header of the registry. Return a pointer to the structure 
1682  * If the mmap'd area has not been allocated, then mmap the input file
1683  */
1684 static
1685 REGF_HDR *nt_get_regf_hdr(REGF *regf)
1686 {
1687   if (!regf)
1688     return NULL; /* What about errors */
1689
1690   if (!regf->regfile_name)
1691     return NULL; /* What about errors */
1692
1693   if (!regf->base) { /* Try to mmap etc the file */
1694
1695     if ((regf->fd = open(regf->regfile_name, O_RDONLY, 0000)) <0) {
1696       return NULL; /* What about errors? */
1697     }
1698
1699     if (fstat(regf->fd, &regf->sbuf) < 0) {
1700       return NULL;
1701     }
1702
1703     regf->base = mmap(0, regf->sbuf.st_size, PROT_READ, MAP_SHARED, regf->fd, 0);
1704
1705     if ((int)regf->base == 1) {
1706       fprintf(stderr, "Could not mmap file: %s, %s\n", regf->regfile_name,
1707               strerror(errno));
1708       return NULL;
1709     }
1710   }
1711
1712   /* 
1713    * At this point, regf->base != NULL, and we should be able to read the 
1714    * header 
1715    */
1716
1717   assert(regf->base != NULL);
1718
1719   return (REGF_HDR *)regf->base;
1720 }
1721
1722 /*
1723  * Validate a regf header
1724  * For now, do nothing, but we should check the checksum
1725  */
1726 static
1727 int valid_regf_hdr(REGF_HDR *regf_hdr)
1728 {
1729   if (!regf_hdr) return 0;
1730
1731   return 1;
1732 }
1733
1734 /*
1735  * Process an SK header ...
1736  * Every time we see a new one, add it to the map. Otherwise, just look it up.
1737  * We will do a simple linear search for the moment, since many KEYs have the 
1738  * same security descriptor. 
1739  * We allocate the map in increments of 10 entries.
1740  */
1741
1742 /*
1743  * Create a new entry in the map, and increase the size of the map if needed
1744  */
1745 static
1746 SK_MAP *alloc_sk_map_entry(REGF *regf, KEY_SEC_DESC *tmp, int sk_off)
1747 {
1748  if (!regf->sk_map) { /* Allocate a block of 10 */
1749     regf->sk_map = (SK_MAP *)malloc(sizeof(SK_MAP) * 10);
1750     if (!regf->sk_map) {
1751       free(tmp);
1752       return NULL;
1753     }
1754     regf->sk_map_size = 10;
1755     regf->sk_count = 1;
1756     (regf->sk_map)[0].sk_off = sk_off;
1757     (regf->sk_map)[0].key_sec_desc = tmp;
1758   }
1759   else { /* Simply allocate a new slot, unless we have to expand the list */ 
1760     int ndx = regf->sk_count;
1761     if (regf->sk_count >= regf->sk_map_size) {
1762       regf->sk_map = (SK_MAP *)realloc(regf->sk_map, 
1763                                        (regf->sk_map_size + 10)*sizeof(SK_MAP));
1764       if (!regf->sk_map) {
1765         free(tmp);
1766         return NULL;
1767       }
1768       /*
1769        * ndx already points at the first entry of the new block
1770        */
1771       regf->sk_map_size += 10;
1772     }
1773     (regf->sk_map)[ndx].sk_off = sk_off;
1774     (regf->sk_map)[ndx].key_sec_desc = tmp;
1775     regf->sk_count++;
1776   }
1777  return regf->sk_map;
1778 }
1779
1780 /*
1781  * Search for a KEY_SEC_DESC in the sk_map, but don't create one if not
1782  * found
1783  */
1784 static
1785 KEY_SEC_DESC *lookup_sec_key(SK_MAP *sk_map, int count, int sk_off)
1786 {
1787   int i;
1788
1789   if (!sk_map) return NULL;
1790
1791   for (i = 0; i < count; i++) {
1792
1793     if (sk_map[i].sk_off == sk_off)
1794       return sk_map[i].key_sec_desc;
1795
1796   }
1797
1798   return NULL;
1799
1800 }
1801
1802 /*
1803  * Allocate a KEY_SEC_DESC if we can't find one in the map
1804  */
1805 static
1806 KEY_SEC_DESC *lookup_create_sec_key(REGF *regf, SK_MAP *sk_map, int sk_off)
1807 {
1808   KEY_SEC_DESC *tmp = lookup_sec_key(regf->sk_map, regf->sk_count, sk_off);
1809
1810   if (tmp) {
1811     return tmp;
1812   }
1813   else { /* Allocate a new one */
1814     tmp = (KEY_SEC_DESC *)malloc(sizeof(KEY_SEC_DESC));
1815     if (!tmp) {
1816       return NULL;
1817     }
1818     memset(tmp, 0, sizeof(KEY_SEC_DESC)); /* Neatly sets offset to 0 */
1819     tmp->state = SEC_DESC_RES;
1820     if (!alloc_sk_map_entry(regf, tmp, sk_off)) {
1821       return NULL;
1822     }
1823     return tmp;
1824   }
1825 }
1826
1827 /*
1828  * Allocate storage and duplicate a SID 
1829  * We could allocate the SID to be only the size needed, but I am too lazy. 
1830  */
1831 static
1832 sid_t *dup_sid(sid_t *sid)
1833 {
1834   sid_t *tmp = (sid_t *)malloc(sizeof(sid_t));
1835   int i;
1836   
1837   if (!tmp) return NULL;
1838   tmp->ver = sid->ver;
1839   tmp->auths = sid->auths;
1840   for (i=0; i<6; i++) {
1841     tmp->auth[i] = sid->auth[i];
1842   }
1843   for (i=0; i<tmp->auths&&i<MAXSUBAUTHS; i++) {
1844     tmp->sub_auths[i] = sid->sub_auths[i];
1845   }
1846   return tmp;
1847 }
1848
1849 /*
1850  * Allocate space for an ACE and duplicate the registry encoded one passed in
1851  */
1852 static
1853 ACE *dup_ace(REG_ACE *ace)
1854 {
1855   ACE *tmp = NULL; 
1856
1857   tmp = (ACE *)malloc(sizeof(ACE));
1858
1859   if (!tmp) return NULL;
1860
1861   tmp->type = CVAL(&ace->type);
1862   tmp->flags = CVAL(&ace->flags);
1863   tmp->perms = IVAL(&ace->perms);
1864   tmp->trustee = dup_sid(&ace->trustee);
1865   return tmp;
1866 }
1867
1868 /*
1869  * Allocate space for an ACL and duplicate the registry encoded one passed in 
1870  */
1871 static
1872 ACL *dup_acl(REG_ACL *acl)
1873 {
1874   ACL *tmp = NULL;
1875   REG_ACE* ace;
1876   int i, num_aces;
1877
1878   num_aces = IVAL(&acl->num_aces);
1879
1880   tmp = (ACL *)malloc(sizeof(ACL) + (num_aces - 1)*sizeof(ACE *));
1881   if (!tmp) return NULL;
1882
1883   tmp->num_aces = num_aces;
1884   tmp->refcnt = 1;
1885   tmp->rev = SVAL(&acl->rev);
1886   if (verbose) fprintf(stdout, "ACL: refcnt: %u, rev: %u\n", tmp->refcnt, 
1887                        tmp->rev);
1888   ace = (REG_ACE *)&acl->aces;
1889   for (i=0; i<num_aces; i++) {
1890     tmp->aces[i] = dup_ace(ace);
1891     ace = (REG_ACE *)((char *)ace + SVAL(&ace->length));
1892     /* XXX: FIXME, should handle malloc errors */
1893   }
1894
1895   return tmp;
1896 }
1897
1898 static
1899 SEC_DESC *process_sec_desc(REGF *regf, REG_SEC_DESC *sec_desc)
1900 {
1901   SEC_DESC *tmp = NULL;
1902   
1903   tmp = (SEC_DESC *)malloc(sizeof(SEC_DESC));
1904
1905   if (!tmp) {
1906     return NULL;
1907   }
1908   
1909   tmp->rev = SVAL(&sec_desc->rev);
1910   tmp->type = SVAL(&sec_desc->type);
1911   if (verbose) fprintf(stdout, "SEC_DESC Rev: %0X, Type: %0X\n", 
1912                        tmp->rev, tmp->type);
1913   if (verbose) fprintf(stdout, "SEC_DESC Owner Off: %0X\n",
1914                        IVAL(&sec_desc->owner_off));
1915   if (verbose) fprintf(stdout, "SEC_DESC Group Off: %0X\n",
1916                        IVAL(&sec_desc->group_off));
1917   if (verbose) fprintf(stdout, "SEC_DESC DACL Off: %0X\n",
1918                        IVAL(&sec_desc->dacl_off));
1919   tmp->owner = dup_sid((sid_t *)((char *)sec_desc + IVAL(&sec_desc->owner_off)));
1920   if (!tmp->owner) {
1921     free(tmp);
1922     return NULL;
1923   }
1924   tmp->group = dup_sid((sid_t *)((char *)sec_desc + IVAL(&sec_desc->group_off)));
1925   if (!tmp->group) {
1926     free(tmp);
1927     return NULL;
1928   }
1929
1930   /* Now pick up the SACL and DACL */
1931
1932   if (sec_desc->sacl_off)
1933     tmp->sacl = dup_acl((REG_ACL *)((char *)sec_desc + IVAL(&sec_desc->sacl_off)));
1934   else
1935     tmp->sacl = NULL;
1936
1937   if (sec_desc->dacl_off)
1938     tmp->dacl = dup_acl((REG_ACL *)((char *)sec_desc + IVAL(&sec_desc->dacl_off)));
1939   else
1940     tmp->dacl = NULL;
1941
1942   return tmp;
1943 }
1944
1945 static
1946 KEY_SEC_DESC *process_sk(REGF *regf, SK_HDR *sk_hdr, int sk_off, int size)
1947 {
1948   KEY_SEC_DESC *tmp = NULL;
1949   int sk_next_off, sk_prev_off, sk_size;
1950   REG_SEC_DESC *sec_desc;
1951
1952   if (!sk_hdr) return NULL;
1953
1954   if (SVAL(&sk_hdr->SK_ID) != REG_SK_ID) {
1955     fprintf(stderr, "Unrecognized SK Header ID: %08X, %s\n", (int)sk_hdr,
1956             regf->regfile_name);
1957     return NULL;
1958   }
1959
1960   if (-size < (sk_size = IVAL(&sk_hdr->rec_size))) {
1961     fprintf(stderr, "Incorrect SK record size: %d vs %d. %s\n",
1962             -size, sk_size, regf->regfile_name);
1963     return NULL;
1964   }
1965
1966   /* 
1967    * Now, we need to look up the SK Record in the map, and return it
1968    * Since the map contains the SK_OFF mapped to KEY_SEC_DESC, we can
1969    * use that
1970    */
1971
1972   if (regf->sk_map &&
1973       ((tmp = lookup_sec_key(regf->sk_map, regf->sk_count, sk_off)) != NULL)
1974       && (tmp->state == SEC_DESC_OCU)) {
1975     tmp->ref_cnt++;
1976     return tmp;
1977   }
1978
1979   /* Here, we have an item in the map that has been reserved, or tmp==NULL. */
1980
1981   assert(tmp == NULL || (tmp && tmp->state != SEC_DESC_NON));
1982
1983   /*
1984    * Now, allocate a KEY_SEC_DESC, and parse the structure here, and add the
1985    * new KEY_SEC_DESC to the mapping structure, since the offset supplied is 
1986    * the actual offset of structure. The same offset will be used by
1987    * all future references to this structure
1988    * We could put all this unpleasantness in a function.
1989    */
1990
1991   if (!tmp) {
1992     tmp = (KEY_SEC_DESC *)malloc(sizeof(KEY_SEC_DESC));
1993     if (!tmp) return NULL;
1994     memset(tmp, 0, sizeof(KEY_SEC_DESC));
1995     
1996     /*
1997      * Allocate an entry in the SK_MAP ...
1998      * We don't need to free tmp, because that is done for us if the
1999      * sm_map entry can't be expanded when we need more space in the map.
2000      */
2001     
2002     if (!alloc_sk_map_entry(regf, tmp, sk_off)) {
2003       return NULL;
2004     }
2005   }
2006
2007   tmp->ref_cnt++;
2008   tmp->state = SEC_DESC_OCU;
2009
2010   /*
2011    * Now, process the actual sec desc and plug the values in
2012    */
2013
2014   sec_desc = (REG_SEC_DESC *)&sk_hdr->sec_desc[0];
2015   tmp->sec_desc = process_sec_desc(regf, sec_desc);
2016
2017   /*
2018    * Now forward and back links. Here we allocate an entry in the sk_map
2019    * if it does not exist, and mark it reserved
2020    */
2021
2022   sk_prev_off = IVAL(&sk_hdr->prev_off);
2023   tmp->prev = lookup_create_sec_key(regf, regf->sk_map, sk_prev_off);
2024   assert(tmp->prev != NULL);
2025   sk_next_off = IVAL(&sk_hdr->next_off);
2026   tmp->next = lookup_create_sec_key(regf, regf->sk_map, sk_next_off);
2027   assert(tmp->next != NULL);
2028
2029   return tmp;
2030 }
2031
2032 /*
2033  * Process a VK header and return a value
2034  */
2035 static
2036 VAL_KEY *process_vk(REGF *regf, VK_HDR *vk_hdr, int size)
2037 {
2038   char val_name[1024];
2039   int nam_len, dat_len, flag, dat_type, dat_off, vk_id;
2040   const char *val_type;
2041   VAL_KEY *tmp = NULL; 
2042
2043   if (!vk_hdr) return NULL;
2044
2045   if ((vk_id = SVAL(&vk_hdr->VK_ID)) != REG_VK_ID) {
2046     fprintf(stderr, "Unrecognized VK header ID: %0X, block: %0X, %s\n",
2047             vk_id, (int)vk_hdr, regf->regfile_name);
2048     return NULL;
2049   }
2050
2051   nam_len = SVAL(&vk_hdr->nam_len);
2052   val_name[nam_len] = '\0';
2053   flag = SVAL(&vk_hdr->flag);
2054   dat_type = IVAL(&vk_hdr->dat_type);
2055   dat_len = IVAL(&vk_hdr->dat_len);  /* If top bit, offset contains data */
2056   dat_off = IVAL(&vk_hdr->dat_off);
2057
2058   tmp = (VAL_KEY *)malloc(sizeof(VAL_KEY));
2059   if (!tmp) {
2060     goto error;
2061   }
2062   memset(tmp, 0, sizeof(VAL_KEY));
2063   tmp->has_name = flag;
2064   tmp->data_type = dat_type;
2065
2066   if (flag & 0x01) {
2067     strncpy(val_name, vk_hdr->dat_name, nam_len);
2068     tmp->name = strdup(val_name);
2069     if (!tmp->name) {
2070       goto error;
2071     }
2072   }
2073   else
2074     strncpy(val_name, "<No Name>", 10);
2075
2076   /*
2077    * Allocate space and copy the data as a BLOB
2078    */
2079
2080   if (dat_len) {
2081     
2082     char *dtmp = (char *)malloc(dat_len&0x7FFFFFFF);
2083     
2084     if (!dtmp) {
2085       goto error;
2086     }
2087
2088     tmp->data_blk = dtmp;
2089
2090     if ((dat_len&0x80000000) == 0) { /* The data is pointed to by the offset */
2091       char *dat_ptr = LOCN(regf->base, dat_off);
2092       bcopy(dat_ptr, dtmp, dat_len);
2093     }
2094     else { /* The data is in the offset or type */
2095       /*
2096        * FIXME.
2097        * Some registry files seem to have wierd fields. If top bit is set,
2098        * but len is 0, the type seems to be the value ...
2099        * Not sure how to handle this last type for the moment ...
2100        */
2101       dat_len = dat_len & 0x7FFFFFFF;
2102       bcopy(&dat_off, dtmp, dat_len);
2103     }
2104
2105     tmp->data_len = dat_len;
2106   }
2107
2108   val_type = val_to_str(dat_type, reg_type_names);
2109
2110   /*
2111    * We need to save the data area as well
2112    */
2113
2114   if (verbose) fprintf(stdout, "  %s : %s : \n", val_name, val_type);
2115
2116   return tmp;
2117
2118  error:
2119   if (tmp) nt_delete_val_key(tmp);
2120   return NULL;
2121
2122 }
2123
2124 /*
2125  * Process a VL Header and return a list of values
2126  */
2127 static
2128 VAL_LIST *process_vl(REGF *regf, VL_TYPE vl, int count, int size)
2129 {
2130   int i, vk_off;
2131   VK_HDR *vk_hdr;
2132   VAL_LIST *tmp = NULL;
2133
2134   if (!vl) return NULL;
2135
2136   if (-size < (count+1)*sizeof(int)){
2137     fprintf(stderr, "Error in VL header format. Size less than space required. %d\n", -size);
2138     return NULL;
2139   }
2140
2141   tmp = (VAL_LIST *)malloc(sizeof(VAL_LIST) + (count - 1) * sizeof(VAL_KEY *));
2142   if (!tmp) {
2143     goto error;
2144   }
2145
2146   for (i=0; i<count; i++) {
2147     vk_off = IVAL(&vl[i]);
2148     vk_hdr = (VK_HDR *)LOCN(regf->base, vk_off);
2149     tmp->vals[i] = process_vk(regf, vk_hdr, BLK_SIZE(vk_hdr));
2150     if (!tmp->vals[i]){
2151       goto error;
2152     }
2153   }
2154
2155   tmp->val_count = count;
2156   tmp->max_vals = count;
2157
2158   return tmp;
2159
2160  error:
2161   /* XXX: FIXME, free the partially allocated structure */
2162   return NULL;
2163
2164
2165 /*
2166  * Process an LF Header and return a list of sub-keys
2167  */
2168 static
2169 KEY_LIST *process_lf(REGF *regf, LF_HDR *lf_hdr, int size, REG_KEY *parent)
2170 {
2171   int count, i, nk_off;
2172   unsigned int lf_id;
2173   KEY_LIST *tmp;
2174
2175   if (!lf_hdr) return NULL;
2176
2177   if ((lf_id = SVAL(&lf_hdr->LF_ID)) != REG_LF_ID) {
2178     fprintf(stderr, "Unrecognized LF Header format: %0X, Block: %0X, %s.\n",
2179             lf_id, (int)lf_hdr, regf->regfile_name);
2180     return NULL;
2181   }
2182
2183   assert(size < 0);
2184
2185   count = SVAL(&lf_hdr->key_count);
2186   if (verbose) fprintf(stdout, "Key Count: %u\n", count);
2187   if (count <= 0) return NULL;
2188
2189   /* Now, we should allocate a KEY_LIST struct and fill it in ... */
2190
2191   tmp = (KEY_LIST *)malloc(sizeof(KEY_LIST) + (count - 1) * sizeof(REG_KEY *));
2192   if (!tmp) {
2193     goto error;
2194   }
2195
2196   tmp->key_count = count;
2197   tmp->max_keys = count;
2198
2199   for (i=0; i<count; i++) {
2200     NK_HDR *nk_hdr;
2201
2202     nk_off = IVAL(&lf_hdr->hr[i].nk_off);
2203     if (verbose) fprintf(stdout, "NK Offset: %0X\n", nk_off);
2204     nk_hdr = (NK_HDR *)LOCN(regf->base, nk_off);
2205     tmp->keys[i] = nt_get_key_tree(regf, nk_hdr, BLK_SIZE(nk_hdr), parent);
2206     if (!tmp->keys[i]) {
2207       goto error;
2208     }
2209   }
2210
2211   return tmp;
2212
2213  error:
2214   if (tmp) nt_delete_key_list(tmp, False);
2215   return NULL;
2216 }
2217
2218 /*
2219  * This routine is passed an NK_HDR pointer and retrieves the entire tree
2220  * from there down. It returns a REG_KEY *.
2221  */
2222 static
2223 REG_KEY *nt_get_key_tree(REGF *regf, NK_HDR *nk_hdr, int size, REG_KEY *parent)
2224 {
2225   REG_KEY *tmp = NULL, *own;
2226   int name_len, clsname_len, lf_off, val_off, val_count, sk_off, own_off;
2227   unsigned int nk_id;
2228   LF_HDR *lf_hdr;
2229   VL_TYPE *vl;
2230   SK_HDR *sk_hdr;
2231   char key_name[1024], cls_name[1024];
2232
2233   if (!nk_hdr) return NULL;
2234
2235   if ((nk_id = SVAL(&nk_hdr->NK_ID)) != REG_NK_ID) {
2236     fprintf(stderr, "Unrecognized NK Header format: %08X, Block: %0X. %s\n", 
2237             nk_id, (int)nk_hdr, regf->regfile_name);
2238     return NULL;
2239   }
2240
2241   assert(size < 0);
2242
2243   name_len = SVAL(&nk_hdr->nam_len);
2244   clsname_len = SVAL(&nk_hdr->clsnam_len);
2245
2246   /*
2247    * The value of -size should be ge 
2248    * (sizeof(NK_HDR) - 1 + name_len)
2249    * The -1 accounts for the fact that we included the first byte of 
2250    * the name in the structure. clsname_len is the length of the thing 
2251    * pointed to by clsnam_off
2252    */
2253
2254   if (-size < (sizeof(NK_HDR) - 1 + name_len)) {
2255     fprintf(stderr, "Incorrect NK_HDR size: %d, %0X\n", -size, (int)nk_hdr);
2256     fprintf(stderr, "Sizeof NK_HDR: %d, name_len %d, clsname_len %d\n",
2257             sizeof(NK_HDR), name_len, clsname_len);
2258     /*return NULL;*/
2259   }
2260
2261   if (verbose) fprintf(stdout, "NK HDR: Name len: %d, class name len: %d\n", 
2262                        name_len, clsname_len);
2263
2264   /* Fish out the key name and process the LF list */
2265
2266   assert(name_len < sizeof(key_name));
2267
2268   /* Allocate the key struct now */
2269   tmp = (REG_KEY *)malloc(sizeof(REG_KEY));
2270   if (!tmp) return tmp;
2271   memset(tmp, 0, sizeof(REG_KEY));
2272
2273   tmp->type = (SVAL(&nk_hdr->type)==0x2C?REG_ROOT_KEY:REG_SUB_KEY);
2274   
2275   strncpy(key_name, nk_hdr->key_nam, name_len);
2276   key_name[name_len] = '\0';
2277
2278   if (verbose) fprintf(stdout, "Key name: %s\n", key_name);
2279
2280   tmp->name = strdup(key_name);
2281   if (!tmp->name) {
2282     goto error;
2283   }
2284
2285   /*
2286    * Fish out the class name, it is in UNICODE, while the key name is 
2287    * ASCII :-)
2288    */
2289
2290   if (clsname_len) { /* Just print in Ascii for now */
2291     char *clsnamep;
2292     int clsnam_off;
2293
2294     clsnam_off = IVAL(&nk_hdr->clsnam_off);
2295     clsnamep = LOCN(regf->base, clsnam_off);
2296     if (verbose) fprintf(stdout, "Class Name Offset: %0X\n", clsnam_off);
2297  
2298     memset(cls_name, 0, clsname_len);
2299     uni_to_ascii(clsnamep, cls_name, sizeof(cls_name), clsname_len);
2300     
2301     /*
2302      * I am keeping class name as an ascii string for the moment.
2303      * That means it needs to be converted on output.
2304      * It will also piss off people who need Unicode/UTF-8 strings. Sorry. 
2305      * XXX: FIXME
2306      */
2307
2308     tmp->class_name = strdup(cls_name);
2309     if (!tmp->class_name) {
2310       goto error;
2311     }
2312
2313     if (verbose) fprintf(stdout, "  Class Name: %s\n", cls_name);
2314
2315   }
2316
2317   /*
2318    * Process the owner offset ...
2319    */
2320
2321   own_off = IVAL(&nk_hdr->own_off);
2322   own = (REG_KEY *)LOCN(regf->base, own_off);
2323   if (verbose) fprintf(stdout, "Owner Offset: %0X\n", own_off);
2324
2325   if (verbose) fprintf(stdout, "  Owner locn: %0X, Our locn: %0X\n", 
2326                        (unsigned int)own, (unsigned int)nk_hdr);
2327
2328   /* 
2329    * We should verify that the owner field is correct ...
2330    * for now, we don't worry ...
2331    */
2332
2333   tmp->owner = parent;
2334
2335   /*
2336    * If there are any values, process them here
2337    */
2338
2339   val_count = IVAL(&nk_hdr->val_cnt);
2340   if (verbose) fprintf(stdout, "Val Count: %d\n", val_count);
2341   if (val_count) {
2342
2343     val_off = IVAL(&nk_hdr->val_off);
2344     vl = (VL_TYPE *)LOCN(regf->base, val_off);
2345     if (verbose) fprintf(stdout, "Val List Offset: %0X\n", val_off);
2346
2347     tmp->values = process_vl(regf, *vl, val_count, BLK_SIZE(vl));
2348     if (!tmp->values) {
2349       goto error;
2350     }
2351
2352   }
2353
2354   /* 
2355    * Also handle the SK header ...
2356    */
2357
2358   sk_off = IVAL(&nk_hdr->sk_off);
2359   sk_hdr = (SK_HDR *)LOCN(regf->base, sk_off);
2360   if (verbose) fprintf(stdout, "SK Offset: %0X\n", sk_off);
2361
2362   if (sk_off != -1) {
2363
2364     tmp->security = process_sk(regf, sk_hdr, sk_off, BLK_SIZE(sk_hdr));
2365
2366   } 
2367
2368   lf_off = IVAL(&nk_hdr->lf_off);
2369   if (verbose) fprintf(stdout, "SubKey list offset: %0X\n", lf_off);
2370
2371   /*
2372    * No more subkeys if lf_off == -1
2373    */
2374
2375   if (lf_off != -1) {
2376
2377     lf_hdr = (LF_HDR *)LOCN(regf->base, lf_off);
2378     
2379     tmp->sub_keys = process_lf(regf, lf_hdr, BLK_SIZE(lf_hdr), tmp);
2380     if (!tmp->sub_keys){
2381       goto error;
2382     }
2383
2384   }
2385
2386   return tmp;
2387
2388  error:
2389   if (tmp) nt_delete_reg_key(tmp, False);
2390   return NULL;
2391 }
2392
2393 static
2394 int nt_load_registry(REGF *regf)
2395 {
2396   REGF_HDR *regf_hdr;
2397   unsigned int regf_id, hbin_id;
2398   HBIN_HDR *hbin_hdr;
2399   NK_HDR *first_key;
2400
2401   /* Get the header */
2402
2403   if ((regf_hdr = nt_get_regf_hdr(regf)) == NULL) {
2404     return -1;
2405   }
2406
2407   /* Now process that header and start to read the rest in */
2408
2409   if ((regf_id = IVAL(&regf_hdr->REGF_ID)) != REG_REGF_ID) {
2410     fprintf(stderr, "Unrecognized NT registry header id: %0X, %s\n",
2411             regf_id, regf->regfile_name);
2412     return -1;
2413   }
2414
2415   /*
2416    * Validate the header ...
2417    */
2418   if (!valid_regf_hdr(regf_hdr)) {
2419     fprintf(stderr, "Registry file header does not validate: %s\n",
2420             regf->regfile_name);
2421     return -1;
2422   }
2423
2424   /* Update the last mod date, and then go get the first NK record and on */
2425
2426   TTTONTTIME(regf, IVAL(&regf_hdr->tim1), IVAL(&regf_hdr->tim2));
2427
2428   /* 
2429    * The hbin hdr seems to be just uninteresting garbage. Check that
2430    * it is there, but that is all.
2431    */
2432
2433   hbin_hdr = (HBIN_HDR *)(regf->base + REGF_HDR_BLKSIZ);
2434
2435   if ((hbin_id = IVAL(&hbin_hdr->HBIN_ID)) != REG_HBIN_ID) {
2436     fprintf(stderr, "Unrecognized registry hbin hdr ID: %0X, %s\n", 
2437             hbin_id, regf->regfile_name);
2438     return -1;
2439   } 
2440
2441   /*
2442    * Get a pointer to the first key from the hreg_hdr
2443    */
2444
2445   if (verbose) fprintf(stdout, "First Key: %0X\n",
2446                        IVAL(&regf_hdr->first_key));
2447
2448   first_key = (NK_HDR *)LOCN(regf->base, IVAL(&regf_hdr->first_key));
2449   if (verbose) fprintf(stdout, "First Key Offset: %0X\n", 
2450                        IVAL(&regf_hdr->first_key));
2451
2452   if (verbose) fprintf(stdout, "Data Block Size: %d\n",
2453                        IVAL(&regf_hdr->dblk_size));
2454
2455   if (verbose) fprintf(stdout, "Offset to next hbin block: %0X\n",
2456                        IVAL(&hbin_hdr->off_to_next));
2457
2458   if (verbose) fprintf(stdout, "HBIN block size: %0X\n",
2459                        IVAL(&hbin_hdr->blk_size));
2460
2461   /*
2462    * Now, get the registry tree by processing that NK recursively
2463    */
2464
2465   regf->root = nt_get_key_tree(regf, first_key, BLK_SIZE(first_key), NULL);
2466
2467   assert(regf->root != NULL);
2468
2469   /*
2470    * Unmap the registry file, as we might want to read in another
2471    * tree etc.
2472    */
2473
2474   if (regf->base) munmap(regf->base, regf->sbuf.st_size);
2475   regf->base = NULL;
2476   close(regf->fd);    /* Ignore the error :-) */
2477
2478   return 1;
2479 }
2480
2481 /*
2482  * Allocate a new hbin block, set up the header for the block etc 
2483  */
2484 static
2485 HBIN_BLK *nt_create_hbin_blk(REGF *regf, int size)
2486 {
2487   HBIN_BLK *tmp;
2488   HBIN_HDR *hdr;
2489
2490   if (!regf || !size) return NULL;
2491
2492   /* Round size up to multiple of REGF_HDR_BLKSIZ */
2493
2494   size = (size + (REGF_HDR_BLKSIZ - 1)) & ~(REGF_HDR_BLKSIZ - 1);
2495
2496   tmp = (HBIN_BLK *)malloc(sizeof(HBIN_BLK));
2497   memset(tmp, 0, sizeof(HBIN_BLK));
2498
2499   tmp->data = malloc(size);
2500   if (!tmp->data) goto error;
2501
2502   memset(tmp->data, 0, size);  /* Make it pristine */
2503
2504   tmp->size = size;
2505   tmp->file_offset = regf->blk_tail->file_offset + regf->blk_tail->size;
2506
2507   tmp->free_space = size - (sizeof(HBIN_HDR) - sizeof(HBIN_SUB_HDR));
2508   tmp->fsp_off = size - tmp->free_space;
2509
2510   /* 
2511    * Now, build the header in the data block 
2512    */
2513   hdr = (HBIN_HDR *)tmp->data;
2514   hdr->HBIN_ID = REG_HBIN_ID;
2515   hdr->off_from_first = tmp->file_offset - REGF_HDR_BLKSIZ;
2516   hdr->off_to_next = tmp->size;
2517   hdr->blk_size = tmp->size;
2518
2519   /*
2520    * Now link it in
2521    */
2522
2523   regf->blk_tail->next = tmp;
2524   regf->blk_tail = tmp;
2525   if (!regf->free_space) regf->free_space = tmp;
2526
2527   return tmp;
2528  error:
2529   if (tmp) free(tmp);
2530   return NULL;
2531 }
2532
2533 /*
2534  * Allocate a unit of space ... and return a pointer as function param
2535  * and the block's offset as a side effect
2536  */
2537 static
2538 void *nt_alloc_regf_space(REGF *regf, int size, unsigned int *off)
2539 {
2540   int tmp = 0;
2541   void *ret = NULL;
2542   HBIN_BLK *blk;
2543   
2544   if (!regf || !size || !off) return NULL;
2545
2546   assert(regf->blk_head != NULL);
2547
2548   /*
2549    * round up size to include header and then to 8-byte boundary
2550    */
2551   size = (size + 4 + 7) & ~7;
2552
2553   /*
2554    * Check if there is space, if none, grab a block
2555    */
2556   if (!regf->free_space) {
2557     if (!nt_create_hbin_blk(regf, REGF_HDR_BLKSIZ))
2558       return NULL;
2559   }
2560
2561   /*
2562    * Now, chain down the list of blocks looking for free space
2563    */
2564
2565   for (blk = regf->free_space; blk != NULL; blk = blk->next) {
2566     if (blk->free_space <= size) {
2567       tmp = blk->file_offset + blk->fsp_off - REGF_HDR_BLKSIZ;
2568       ret = blk->data + blk->fsp_off;
2569       blk->free_space -= size;
2570       blk->fsp_off += size;
2571
2572       /* Insert the header */
2573       ((HBIN_SUB_HDR *)ret)->dblocksize = -size;
2574
2575       /*
2576        * Fix up the free space ptr
2577        * If it is NULL, we fix it up next time
2578        */
2579
2580       if (!blk->free_space) 
2581         regf->free_space = blk->next;
2582
2583       *off = tmp;
2584       return (((char *)ret)+4);/* The pointer needs to be to the data struct */
2585     }
2586   }
2587
2588   /*
2589    * If we got here, we need to add another block, which might be 
2590    * larger than one block -- deal with that later
2591    */
2592   if (nt_create_hbin_blk(regf, REGF_HDR_BLKSIZ)) {
2593     blk = regf->free_space;
2594     tmp = blk->file_offset + blk->fsp_off - REGF_HDR_BLKSIZ;
2595     ret = blk->data + blk->fsp_off;
2596     blk->free_space -= size;
2597     blk->fsp_off += size;
2598
2599     /* Insert the header */
2600     ((HBIN_SUB_HDR *)ret)->dblocksize = -size;
2601
2602     /*
2603      * Fix up the free space ptr
2604      * If it is NULL, we fix it up next time
2605      */
2606     
2607     if (!blk->free_space) 
2608       regf->free_space = blk->next;
2609
2610     *off = tmp;
2611     return (((char *)ret) + 4);/* The pointer needs to be to the data struct */
2612   }
2613
2614   return NULL;
2615 }
2616
2617 /*
2618  * Compute the size of a SID stored ...
2619  */
2620 static
2621 unsigned int sid_size(sid_t *sid)
2622 {
2623   unsigned int size;
2624
2625   if (!sid) return 0;
2626
2627   size = 8 + (sid->auths * sizeof(unsigned int));
2628
2629   return size;
2630 }
2631
2632 /*
2633  * Compute the size of an ACE on disk from its components
2634  */
2635 static
2636 unsigned int ace_size(ACE *ace)
2637 {
2638   unsigned int size;
2639
2640   if (!ace) return 0;
2641
2642   size = 8 + sid_size(ace->trustee);
2643
2644   return size;
2645 }     
2646
2647 /* 
2648  * Compute the size of an ACL from its components ...
2649  */
2650 static
2651 unsigned int acl_size(ACL *acl)
2652 {
2653   unsigned int size;
2654   int i;
2655
2656   if (!acl) return 0;
2657
2658   size = 8; 
2659   for (i = 0; i < acl->num_aces; i++)
2660     size += ace_size(acl->aces[i]);
2661
2662   return size;
2663 }
2664
2665 /*
2666  * Compute the size of the sec desc as a self-relative SD
2667  */
2668 static
2669 unsigned int sec_desc_size(SEC_DESC *sd)
2670 {
2671   unsigned int size;
2672   
2673   if (!sd) return 0;
2674
2675   size = 20;
2676
2677   if (sd->owner) size += sid_size(sd->owner);
2678   if (sd->group) size += sid_size(sd->group);
2679   if (sd->sacl) size += acl_size(sd->sacl);
2680   if (sd->dacl) size += acl_size(sd->dacl);
2681
2682   return size;
2683 }
2684
2685 /*
2686  * Store a SID at the location provided
2687  */
2688 static
2689 int nt_store_SID(REGF *regf, sid_t *sid, unsigned char *locn)
2690 {
2691   int i;
2692   unsigned char *p = locn;
2693
2694   if (!regf || !sid || !locn) return 0;
2695
2696   *p = sid->ver; p++;
2697   *p = sid->auths; p++;
2698   
2699   for (i=0; i < 6; i++) {
2700     *p = sid->auth[i]; p++;
2701   }
2702
2703   for (i=0; i < sid->auths; i++) {
2704     SIVAL(p, sid->sub_auths[i]); p+=4;
2705   }
2706
2707   return p - locn;
2708   
2709 }
2710
2711 static
2712 int nt_store_ace(REGF *regf, ACE *ace, unsigned char *locn)
2713 {
2714   int size = 0;
2715   REG_ACE *reg_ace = (REG_ACE *)locn;
2716   unsigned char *p;
2717
2718   if (!regf || !ace || !locn) return 0;
2719
2720   reg_ace->type = ace->type;
2721   reg_ace->flags = ace->flags;
2722
2723   /* Deal with the length when we have stored the SID */
2724
2725   p = (unsigned char *)&reg_ace->perms;
2726
2727   SIVAL(p, ace->perms); p += 4;
2728
2729   size = nt_store_SID(regf, ace->trustee, p);
2730
2731   size += 8; /* Size of the fixed header */
2732
2733   p = (unsigned char *)&reg_ace->length;
2734
2735   SSVAL(p, size);
2736
2737   return size;
2738 }
2739
2740 /*
2741  * Store an ACL at the location provided
2742  */
2743 static
2744 int nt_store_acl(REGF *regf, ACL *acl, unsigned char *locn)
2745 {
2746   int size = 0, i;
2747   unsigned char *p = locn, *s;
2748
2749   if (!regf || !acl || !locn) return 0;
2750
2751   /*
2752    * Now store the header and then the ACEs ...
2753    */
2754
2755   SSVAL(p, acl->rev);
2756
2757   p += 2; s = p; /* Save this for the size field */
2758
2759   p += 2;
2760
2761   SIVAL(p, acl->num_aces);
2762
2763   p += 4;
2764
2765   for (i = 0; i < acl->num_aces; i++) {
2766     size = nt_store_ace(regf, acl->aces[i], p);
2767     p += size;
2768   }
2769
2770   size = s - locn;
2771   SSVAL(s, size);
2772   return size;
2773 }
2774
2775 /*
2776  * Flatten and store the Sec Desc 
2777  * Windows lays out the DACL first, but since there is no SACL, it might be
2778  * that first, then the owner, then the group SID. So, we do it that way
2779  * too.
2780  */
2781 static
2782 unsigned int nt_store_sec_desc(REGF *regf, SEC_DESC *sd, char *locn)
2783 {
2784   REG_SEC_DESC *rsd = (REG_SEC_DESC *)locn;
2785   unsigned int size = 0, off = 0;
2786
2787   if (!regf || !sd || !locn) return 0;
2788
2789   /* 
2790    * Now, fill in the first two fields, then lay out the various fields
2791    * as needed
2792    */
2793
2794   rsd->rev = 0x01;
2795   /* Self relative, DACL pres, owner and group not defaulted */
2796   rsd->type = 0x8004;  
2797
2798   off = 4 * sizeof(DWORD) + 4;
2799
2800   if (sd->sacl){
2801     size = nt_store_acl(regf, sd->sacl, (char *)(locn + off));
2802     rsd->sacl_off = off;
2803   }
2804   else
2805     rsd->sacl_off = 0;
2806
2807   off += size;
2808
2809   if (sd->dacl) {
2810     rsd->dacl_off = off;
2811     size = nt_store_acl(regf, sd->dacl, (char *)(locn + off));
2812   }
2813   else {
2814     rsd->dacl_off = 0;
2815   }
2816
2817   off += size;
2818
2819   /* Now the owner and group SIDs */
2820
2821   if (sd->owner) {
2822     rsd->owner_off = off;
2823     size = nt_store_SID(regf, sd->owner, (char *)(locn + off));
2824   }
2825   else {
2826     rsd->owner_off = 0;
2827   }
2828
2829   off += size;
2830
2831   if (sd->group) {
2832     rsd->group_off = off;
2833     size = nt_store_SID(regf, sd->group, (char *)(locn + off));
2834   }
2835   else {
2836     rsd->group_off = 0;
2837   }
2838
2839   off += size;
2840
2841   return size;
2842 }
2843
2844 /*
2845  * Store the security information
2846  *
2847  * If it has already been stored, just get its offset from record
2848  * otherwise, store it and record its offset
2849  */
2850 static
2851 unsigned int nt_store_security(REGF *regf, KEY_SEC_DESC *sec)
2852 {
2853   int size = 0;
2854   unsigned int sk_off;
2855   SK_HDR *sk_hdr;
2856   
2857   if (sec->offset) return sec->offset;
2858
2859   /*
2860    * OK, we don't have this one in the file yet. We must compute the 
2861    * size taken by the security descriptor as a self-relative SD, which
2862    * means making one pass over each structure and figuring it out
2863    */
2864
2865   size = sec_desc_size(sec->sec_desc);
2866
2867   /* Allocate that much space */
2868
2869   sk_hdr = nt_alloc_regf_space(regf, size, &sk_off);
2870   sec->sk_hdr = sk_hdr;
2871
2872   if (!sk_hdr) return 0;
2873
2874   /* Now, lay out the sec_desc in the space provided */
2875
2876   sk_hdr->SK_ID = REG_SK_ID;
2877   
2878   /* 
2879    * We can't deal with the next and prev offset in the SK_HDRs until the
2880    * whole tree has been stored, then we can go and deal with them
2881    */
2882
2883   sk_hdr->ref_cnt = sec->ref_cnt;
2884   sk_hdr->rec_size = size;       /* Is this correct */
2885
2886   /* Now, lay out the sec_desc */
2887
2888   if (!nt_store_sec_desc(regf, sec->sec_desc, (char *)&sk_hdr->sec_desc))
2889     return 0;
2890
2891   return sk_off;
2892
2893 }
2894
2895 /*
2896  * Store a VAL LIST
2897  */
2898 static
2899 int nt_store_val_list(REGF *regf, VAL_LIST * values)
2900 {
2901
2902   return 0;
2903 }
2904
2905 /*
2906  * Store a KEY in the file ...
2907  *
2908  * We store this depth first, and defer storing the lf struct until
2909  * all the sub-keys have been stored.
2910  * 
2911  * We store the NK hdr, any SK header, class name, and VK structure, then
2912  * recurse down the LF structures ... 
2913  * 
2914  * We return the offset of the NK struct
2915  * FIXME, FIXME, FIXME: Convert to using SIVAL and SSVAL ...
2916  */
2917 static
2918 int nt_store_reg_key(REGF *regf, REG_KEY *key)
2919 {
2920   NK_HDR *nk_hdr; 
2921   unsigned int nk_off, sk_off, size;
2922
2923   if (!regf || !key) return 0;
2924
2925   size = sizeof(NK_HDR) + strlen(key->name) - 1;
2926   nk_hdr = nt_alloc_regf_space(regf, size, &nk_off);
2927   if (!nk_hdr) goto error;
2928
2929   key->offset = nk_off;  /* We will need this later */
2930
2931   /*
2932    * Now fill in each field etc ...
2933    */
2934
2935   nk_hdr->NK_ID = REG_NK_ID; 
2936   if (key->type == REG_ROOT_KEY)
2937     nk_hdr->type = 0x2C;
2938   else
2939     nk_hdr->type = 0x20;
2940
2941   /* FIXME: Fill in the time of last update */
2942
2943   if (key->type != REG_ROOT_KEY)
2944     nk_hdr->own_off = key->owner->offset;
2945
2946   if (key->sub_keys)
2947     nk_hdr->subk_num = key->sub_keys->key_count;
2948
2949   /*
2950    * Now, process the Sec Desc and then store its offset
2951    */
2952
2953   sk_off = nt_store_security(regf, key->security);
2954   nk_hdr->sk_off = sk_off;
2955
2956   /*
2957    * Then, store the val list and store its offset
2958    */
2959   if (key->values) {
2960     nk_hdr->val_cnt = key->values->val_count;
2961     nk_hdr->val_off = nt_store_val_list(regf, key->values);
2962   }
2963   else {
2964     nk_hdr->val_off = -1;
2965     nk_hdr->val_cnt = 0;
2966   }
2967
2968   /*
2969    * Finally, store the subkeys, and their offsets
2970    */
2971
2972  error:
2973   return 0;
2974 }
2975
2976 /*
2977  * Store the registry header ...
2978  * We actually create the registry header block and link it to the chain
2979  * of output blocks.
2980  */
2981 static
2982 REGF_HDR *nt_get_reg_header(REGF *regf)
2983 {
2984   HBIN_BLK *tmp = NULL;
2985   
2986   tmp = (HBIN_BLK *)malloc(sizeof(HBIN_BLK));
2987   if (!tmp) return 0;
2988
2989   memset(tmp, 0, sizeof(HBIN_BLK));
2990   tmp->type = REG_OUTBLK_HDR;
2991   tmp->size = REGF_HDR_BLKSIZ;
2992   tmp->data = malloc(REGF_HDR_BLKSIZ);
2993   if (!tmp->data) goto error;
2994
2995   memset(tmp->data, 0, REGF_HDR_BLKSIZ);  /* Make it pristine, unlike Windows */
2996   regf->blk_head = regf->blk_tail = tmp;
2997
2998   return (REGF_HDR *)tmp->data;
2999
3000  error:
3001   if (tmp) free(tmp);
3002   return NULL;
3003 }
3004
3005 /*
3006  * Store the registry in the output file
3007  * We write out the header and then each of the keys etc into the file
3008  * We have to flatten the data structure ...
3009  *
3010  * The structures are stored in a depth-first fashion, with all records
3011  * aligned on 8-byte boundaries, with sub-keys and values layed down before
3012  * the lists that contain them. SK records are layed down first, however.
3013  * The lf fields are layed down after all sub-keys have been layed down, it
3014  * seems, including the whole tree associated with each sub-key.
3015  */
3016 static
3017 int nt_store_registry(REGF *regf)
3018 {
3019   REGF_HDR *reg;
3020   int fkey, fd;
3021
3022   /*
3023    * Get a header ... and partially fill it in ...
3024    */
3025   reg = nt_get_reg_header(regf);
3026
3027   /*
3028    * Store the first key, which will store the whole thing
3029    */
3030   fkey = nt_store_reg_key(regf, regf->root);
3031
3032   /*
3033    * At this point we have the registry as a series of blocks, so
3034    * run down that series of blocks and save them ...
3035    */
3036
3037   if (!regf->outfile_name) {
3038     fprintf(stderr, "Cannot write file without a name!\n");
3039     return 0;
3040   }
3041
3042   if ((fd = open(regf->outfile_name, O_WRONLY, 0666)) < 0) {
3043     fprintf(stderr, "Unable to create file %s: %s\n", regf->outfile_name,
3044             strerror(errno));
3045     return 0;
3046   }
3047
3048   return 1;
3049 }
3050
3051 /*
3052  * Routines to parse a REGEDIT4 file
3053  * 
3054  * The file consists of:
3055  * 
3056  * REGEDIT4
3057  * \[[-]key-path\]\n
3058  * <value-spec>*
3059  *
3060  * Format:
3061  * [cmd:]name=type:value
3062  *
3063  * cmd = a|d|c|add|delete|change|as|ds|cs
3064  *
3065  * There can be more than one key-path and value-spec.
3066  *
3067  * Since we want to support more than one type of file format, we
3068  * construct a command-file structure that keeps info about the command file
3069  */
3070
3071 #define FMT_UNREC -1
3072 #define FMT_REGEDIT4 0
3073 #define FMT_EDITREG1_1 1
3074
3075 #define FMT_STRING_REGEDIT4 "REGEDIT4"
3076 #define FMT_STRING_EDITREG1_0 "EDITREG1.0"
3077
3078 #define CMD_NONE     0
3079 #define CMD_ADD_KEY  1
3080 #define CMD_DEL_KEY  2
3081
3082 #define CMD_KEY 1
3083 #define CMD_VAL 2
3084
3085 typedef struct val_spec_list {
3086   struct val_spec_list *next;
3087   char *name;
3088   int type;
3089   char *val;    /* Kept as a char string, really? */
3090 } VAL_SPEC_LIST;
3091
3092 typedef struct command_s {
3093   int cmd;
3094   char *key;
3095   int val_count;
3096   VAL_SPEC_LIST *val_spec_list, *val_spec_last;
3097 } CMD;
3098
3099 typedef struct cmd_line {
3100   int len, line_len;
3101   char *line;
3102 } CMD_LINE;
3103
3104 static
3105 void free_val_spec_list(VAL_SPEC_LIST *vl)
3106 {
3107   if (!vl) return;
3108   if (vl->name) free(vl->name);
3109   if (vl->val) free(vl->val);
3110   free(vl);
3111
3112 }
3113
3114 /* 
3115  * Some routines to handle lines of info in the command files
3116  */
3117 static
3118 void skip_to_eol(int fd)
3119 {
3120   int rc;
3121   char ch = 0;
3122
3123   while ((rc = read(fd, &ch, 1)) == 1) {
3124     if (ch == 0x0A) return;
3125   }
3126   if (rc < 0) {
3127     fprintf(stderr, "Could not read file descriptor: %d, %s\n",
3128             fd, strerror(errno));
3129     exit(1);
3130   }
3131 }
3132
3133 static
3134 void free_cmd(CMD *cmd)
3135 {
3136   if (!cmd) return;
3137
3138   while (cmd->val_spec_list) {
3139     VAL_SPEC_LIST *tmp;
3140
3141     tmp = cmd->val_spec_list;
3142     cmd->val_spec_list = tmp->next;
3143     free(tmp);
3144   }
3145
3146   free(cmd);
3147
3148 }
3149
3150 static
3151 void free_cmd_line(CMD_LINE *cmd_line)
3152 {
3153   if (cmd_line) {
3154     if (cmd_line->line) free(cmd_line->line);
3155     free(cmd_line);
3156   }
3157 }
3158
3159 static
3160 void print_line(struct cmd_line *cl)
3161 {
3162   char *pl;
3163
3164   if (!cl) return;
3165
3166   if ((pl = malloc(cl->line_len + 1)) == NULL) {
3167     fprintf(stderr, "Unable to allocate space to print line: %s\n",
3168             strerror(errno));
3169     exit(1);
3170   }
3171
3172   strncpy(pl, cl->line, cl->line_len);
3173   pl[cl->line_len] = 0;
3174
3175   fprintf(stdout, "%s\n", pl);
3176   free(pl);
3177 }
3178
3179 #define INIT_ALLOC 10 
3180
3181 /*
3182  * Read a line from the input file.
3183  * NULL returned when EOF and no chars read
3184  * Otherwise we return a cmd_line *
3185  * Exit if other errors
3186  */
3187 static
3188 struct cmd_line *get_cmd_line(int fd)
3189 {
3190   struct cmd_line *cl = (CMD_LINE *)malloc(sizeof(CMD_LINE));
3191   int i = 0, rc;
3192   unsigned char ch;
3193
3194   if (!cl) {
3195     fprintf(stderr, "Unable to allocate structure for command line: %s\n",
3196             strerror(errno));
3197     exit(1);
3198   }
3199
3200   cl->len = INIT_ALLOC;
3201
3202   /*
3203    * Allocate some space for the line. We extend later if needed.
3204    */
3205
3206   if ((cl->line = (char *)malloc(INIT_ALLOC)) == NULL) {
3207     fprintf(stderr, "Unable to allocate initial space for line: %s\n",
3208             strerror(errno));
3209     exit(1);
3210   }
3211
3212   /*
3213    * Now read in the chars to EOL. Don't store the EOL in the 
3214    * line. What about CR?
3215    */
3216
3217   while ((rc = read(fd, &ch, 1)) == 1 && ch != '\n') {
3218     if (ch == '\r') continue; /* skip CR */
3219     if (i == cl->len) {
3220       /*
3221        * Allocate some more memory
3222        */
3223       if ((cl->line = realloc(cl->line, cl->len + INIT_ALLOC)) == NULL) {
3224         fprintf(stderr, "Unable to realloc space for line: %s\n",
3225                 strerror(errno));
3226         exit(1);
3227       }
3228       cl->len += INIT_ALLOC;
3229     }
3230     cl->line[i] = ch;
3231     i++;
3232   }
3233
3234   /* read 0 and we were at loc'n 0, return NULL */
3235   if (rc == 0 && i == 0) {
3236     free_cmd_line(cl);
3237     return NULL;
3238   }
3239
3240   cl->line_len = i;
3241
3242   return cl;
3243
3244 }
3245
3246 /*
3247  * parse_value: parse out a value. We pull it apart as:
3248  *
3249  * <value> ::= <value-name>=<type>:<value-string>
3250  *
3251  * <value-name> ::= char-string-without-spaces | '"' char-string '"'
3252  *
3253  * If it parsed OK, return the <value-name> as a string, and the
3254  * value type and value-string in parameters.
3255  *
3256  * The value name can be empty. There can only be one empty name in 
3257  * a list of values. A value of - removes the value entirely.  
3258  */
3259 static
3260 char *dup_str(char *s, int len) 
3261
3262   char *nstr; 
3263   nstr = (char *)malloc(len + 1);
3264   if (nstr) {
3265     memcpy(nstr, s, len);
3266     nstr[len] = 0;
3267   }
3268   return nstr;
3269 }
3270
3271 static
3272 char *parse_name(char *nstr)
3273 {
3274   int len = 0, start = 0;
3275   if (!nstr) return NULL;
3276
3277   len = strlen(nstr);
3278
3279   while (len && nstr[len - 1] == ' ') len--;
3280
3281   nstr[len] = 0; /* Trim any spaces ... if there were none, doesn't matter */
3282
3283   /*
3284    * Beginning and end should be '"' or neither should be so
3285    */
3286   if ((nstr[0] == '"' && nstr[len - 1] != '"') ||
3287       (nstr[0] != '"' && nstr[len - 1] == '"'))
3288     return NULL;
3289
3290   if (nstr[0] == '"') {
3291     start = 1;
3292     len -= 2;
3293   }
3294
3295   return dup_str(&nstr[start], len);
3296 }
3297
3298 static
3299 int parse_value_type(char *tstr)
3300 {
3301   int len = strlen(tstr);
3302   
3303   while (len && tstr[len - 1] == ' ') len--;
3304   tstr[len] = 0;
3305
3306   if (strcmp(tstr, "REG_DWORD") == 0)
3307     return REG_TYPE_DWORD;
3308   else if (strcmp(tstr, "dword") == 0)
3309     return REG_TYPE_DWORD;
3310   else if (strcmp(tstr, "REG_EXPAND_SZ") == 0)
3311     return REG_TYPE_EXPANDSZ;
3312   else if (strcmp(tstr, "REG_BIN") == 0)
3313     return REG_TYPE_BIN;
3314   else if (strcmp(tstr, "REG_SZ") == 0)
3315     return REG_TYPE_REGSZ;
3316   else if (strcmp(tstr, "REG_MULTI_SZ") == 0)
3317     return REG_TYPE_MULTISZ;
3318   else if (strcmp(tstr, "-") == 0)
3319     return REG_TYPE_DELETE;
3320
3321   return 0;
3322 }
3323
3324 static
3325 char *parse_val_str(char *vstr)
3326 {
3327   
3328   return dup_str(vstr, strlen(vstr));
3329
3330 }
3331
3332 static
3333 char *parse_value(struct cmd_line *cl, int *vtype, char **val)
3334 {
3335   char *p1 = NULL, *p2 = NULL, *nstr = NULL, *tstr = NULL, *vstr = NULL;
3336   
3337   if (!cl || !vtype || !val) return NULL;
3338   if (!cl->line_len) return NULL;
3339
3340   p1 = dup_str(cl->line, cl->line_len);
3341   /* FIXME: Better return codes etc ... */
3342   if (!p1) return NULL;
3343   p2 = strchr(p1, '=');
3344   if (!p2) return NULL;
3345
3346   *p2 = 0; p2++; /* Split into two strings at p2 */
3347
3348   /* Now, parse the name ... */
3349
3350   nstr = parse_name(p1);
3351   if (!nstr) goto error;
3352
3353   /* Now, split the remainder and parse on type and val ... */
3354
3355   tstr = p2;
3356   while (*tstr == ' ') tstr++; /* Skip leading white space */
3357   p2 = strchr(p2, ':');
3358
3359   if (p2) {
3360     *p2 = 0; p2++; /* split on the : */
3361   }
3362
3363   *vtype = parse_value_type(tstr);
3364
3365   if (!vtype) goto error;
3366
3367   if (!p2 || !*p2) return nstr;
3368
3369   /* Now, parse the value string. It should return a newly malloc'd string */
3370   
3371   while (*p2 == ' ') p2++; /* Skip leading space */
3372   vstr = parse_val_str(p2);
3373
3374   if (!vstr) goto error;
3375
3376   *val = vstr;
3377
3378   return nstr;
3379
3380  error:
3381   if (p1) free(p1);
3382   if (nstr) free(nstr);
3383   if (vstr) free(vstr);
3384   return NULL;
3385 }
3386
3387 /*
3388  * Parse out a key. Look for a correctly formatted key [...] 
3389  * and whether it is a delete or add? A delete is signalled 
3390  * by a - in front of the key.
3391  * Assumes that there are no leading and trailing spaces
3392  */
3393
3394 static
3395 char *parse_key(struct cmd_line *cl, int *cmd)
3396 {
3397   int start = 1;
3398   char *tmp;
3399
3400   if (cl->line[0] != '[' ||
3401       cl->line[cl->line_len - 1] != ']') return NULL;
3402   if (cl->line_len == 2) return NULL;
3403   *cmd = CMD_ADD_KEY;
3404   if (cl->line[1] == '-') {
3405     if (cl->line_len == 3) return NULL;
3406     start = 2;
3407     *cmd = CMD_DEL_KEY;
3408   }
3409   tmp = malloc(cl->line_len - 1 - start + 1);
3410   if (!tmp) return tmp; /* Bail out on no mem ... FIXME */
3411   strncpy(tmp, &cl->line[start], cl->line_len - 1 - start);
3412   tmp[cl->line_len - 1 - start] = 0;
3413   return tmp;
3414 }
3415
3416 /*
3417  * Parse a line to determine if we have a key or a value
3418  * We only check for key or val ...
3419  */
3420
3421 static
3422 int parse_line(struct cmd_line *cl)
3423 {
3424
3425   if (!cl || cl->len == 0) return 0;
3426
3427   if (cl->line[0] == '[')  /* No further checking for now */
3428     return CMD_KEY;
3429   else 
3430     return CMD_VAL;
3431 }
3432
3433 /*
3434  * We seek to offset 0, read in the required number of bytes, 
3435  * and compare to the correct value.
3436  * We then seek back to the original location
3437  */
3438 static
3439 int regedit4_file_type(int fd)
3440 {
3441   int cur_ofs = 0;
3442   char desc[9];
3443
3444   cur_ofs = lseek(fd, 0, SEEK_CUR); /* Get current offset */
3445   if (cur_ofs < 0) {
3446     fprintf(stderr, "Unable to get current offset: %s\n", strerror(errno));
3447     exit(1);  /* FIXME */
3448   }
3449
3450   if (cur_ofs) {
3451     lseek(fd, 0, SEEK_SET);
3452   }
3453
3454   if (read(fd, desc, 8) < 8) {
3455     fprintf(stderr, "Unable to read command file format\n"); 
3456     exit(2);  /* FIXME */
3457   }
3458
3459   desc[8] = 0;
3460
3461   if (strcmp(desc, FMT_STRING_REGEDIT4) == 0) {
3462     if (cur_ofs) {
3463       lseek(fd, cur_ofs, SEEK_SET);
3464     }
3465     else {
3466       skip_to_eol(fd);
3467     }
3468     return FMT_REGEDIT4;
3469   }
3470
3471   return FMT_UNREC;
3472 }
3473
3474 /*
3475  * Run though the data in the line and strip anything after a comment
3476  * char.
3477  */
3478 static
3479 void strip_comment(struct cmd_line *cl)
3480 {
3481   int i;
3482
3483   if (!cl) return;
3484
3485   for (i = 0; i < cl->line_len; i++) {
3486     if (cl->line[i] == ';') {
3487       cl->line_len = i;
3488       return;
3489     }
3490   }
3491 }
3492
3493 /* 
3494  * trim leading space
3495  */
3496
3497 static
3498 void trim_leading_spaces(struct cmd_line *cl)
3499 {
3500   int i;
3501
3502   if (!cl) return;
3503
3504   for (i = 0; i < cl->line_len; i++) {
3505     if (cl->line[i] != ' '){
3506       if (i) memcpy(cl->line, &cl->line[i], cl->line_len - i);
3507       return;
3508     }
3509   }
3510 }
3511
3512 /* 
3513  * trim trailing spaces
3514  */
3515 static
3516 void trim_trailing_spaces(struct cmd_line *cl)
3517 {
3518   int i;
3519
3520   if (!cl) return;
3521
3522   for (i = cl->line_len; i == 0; i--) {
3523     if (cl->line[i-1] != ' ' &&
3524         cl->line[i-1] != '\t') {
3525       cl->line_len = i;
3526     }
3527   }
3528 }
3529
3530 /* 
3531  * Get a command ... This consists of possibly multiple lines:
3532  * [key]
3533  * values*
3534  * possibly Empty line
3535  *
3536  * value ::= <value-name>=<value-type>':'<value-string>
3537  * <value-name> is some path, possibly enclosed in quotes ...
3538  * We alctually look for the next key to terminate a previous key
3539  * if <value-type> == '-', then it is a delete type.
3540  */
3541 static
3542 CMD *regedit4_get_cmd(int fd)
3543 {
3544   struct command_s *cmd = NULL;
3545   struct cmd_line *cl = NULL;
3546   struct val_spec_list *vl = NULL;
3547
3548   if ((cmd = (struct command_s *)malloc(sizeof(struct command_s))) == NULL) {
3549     fprintf(stderr, "Unable to malloc space for command: %s\n",
3550             strerror(errno));
3551     exit(1);
3552   }
3553
3554   cmd->cmd = CMD_NONE;
3555   cmd->key = NULL;
3556   cmd->val_count = 0;
3557   cmd->val_spec_list = cmd->val_spec_last = NULL;
3558   while ((cl = get_cmd_line(fd))) {
3559
3560     /*
3561      * If it is an empty command line, and we already have a key
3562      * then exit from here ... FIXME: Clean up the parser
3563      */
3564
3565     if (cl->line_len == 0 && cmd->key) {
3566       free_cmd_line(cl);
3567       break;
3568     } 
3569
3570     strip_comment(cl);     /* remove anything beyond a comment char */
3571     trim_trailing_spaces(cl);
3572     trim_leading_spaces(cl);
3573
3574     if (cl->line_len == 0) {    /* An empty line */
3575       free_cmd_line(cl);
3576     }
3577     else {                 /* Else, non-empty ... */
3578       /* 
3579        * Parse out the bits ... 
3580        */
3581       switch (parse_line(cl)) {
3582       case CMD_KEY:
3583         if ((cmd->key = parse_key(cl, &cmd->cmd)) == NULL) {
3584           fprintf(stderr, "Error parsing key from line: ");
3585           print_line(cl);
3586           fprintf(stderr, "\n");
3587         }
3588         break;
3589
3590       case CMD_VAL:
3591         /*
3592          * We need to add the value stuff to the list
3593          * There could be a \ on the end which we need to 
3594          * handle at some time
3595          */
3596         vl = (struct val_spec_list *)malloc(sizeof(struct val_spec_list));
3597         if (!vl) goto error;
3598         vl->next = NULL;
3599         vl->val = NULL;
3600         vl->name = parse_value(cl, &vl->type, &vl->val);
3601         if (!vl->name) goto error;
3602         if (cmd->val_spec_list == NULL) {
3603           cmd->val_spec_list = cmd->val_spec_last = vl;
3604         }
3605         else {
3606           cmd->val_spec_last->next = vl;
3607           cmd->val_spec_last = vl;
3608         }
3609         cmd->val_count++;
3610         break;
3611
3612       default:
3613         fprintf(stderr, "Unrecognized line in command file: \n");
3614         print_line(cl);
3615         break;
3616       }
3617     }
3618
3619   }
3620   if (!cmd->cmd) goto error; /* End of file ... */