ef2565bda85f7e74facea590f8e54dfdbf521eb5
[ira/wip.git] / source4 / lib / registry / reg_backend_nt4 / reg_backend_nt4.c
1 /*
2    Samba Unix/Linux SMB client utility libeditreg.c 
3    Copyright (C) 2002 Richard Sharpe, rsharpe@richardsharpe.com
4    Copyright (C) 2003-2004 Jelmer Vernooij, jelmer@samba.org
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 2 of the License, or
9    (at your option) any later version.
10    
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15    
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, write to the Free Software
18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
19  
20 /*************************************************************************
21                                                        
22  A utility to edit a Windows NT/2K etc registry file.
23                                      
24  Many of the ideas in here come from other people and software. 
25  I first looked in Wine in misc/registry.c and was also influenced by
26  http://www.wednesday.demon.co.uk/dosreg.html
27
28  Which seems to contain comments from someone else. I reproduce them here
29  incase the site above disappears. It actually comes from 
30  http://home.eunet.no/~pnordahl/ntpasswd/WinReg.txt. 
31
32  The goal here is to read the registry into memory, manipulate it, and then
33  write it out if it was changed by any actions of the user.
34
35 The windows NT registry has 2 different blocks, where one can occur many
36 times...
37
38 the "regf"-Block
39 ================
40  
41 "regf" is obviously the abbreviation for "Registry file". "regf" is the
42 signature of the header-block which is always 4kb in size, although only
43 the first 64 bytes seem to be used and a checksum is calculated over
44 the first 0x200 bytes only!
45
46 Offset            Size      Contents
47 0x00000000      D-Word      ID: ASCII-"regf" = 0x66676572
48 0x00000004      D-Word      ???? //see struct REG_HANDLE
49 0x00000008      D-Word      ???? Always the same value as at 0x00000004
50 0x0000000C      Q-Word      last modify date in WinNT date-format
51 0x00000014      D-Word      1
52 0x00000018      D-Word      3
53 0x0000001C      D-Word      0
54 0x00000020      D-Word      1
55 0x00000024      D-Word      Offset of 1st key record
56 0x00000028      D-Word      Size of the data-blocks (Filesize-4kb)
57 0x0000002C      D-Word      1
58 0x000001FC      D-Word      Sum of all D-Words from 0x00000000 to
59 0x000001FB  //XOR of all words. Nigel
60
61 I have analyzed more registry files (from multiple machines running
62 NT 4.0 german version) and could not find an explanation for the values
63 marked with ???? the rest of the first 4kb page is not important...
64
65 the "hbin"-Block
66 ================
67 I don't know what "hbin" stands for, but this block is always a multiple
68 of 4kb in size.
69
70 Inside these hbin-blocks the different records are placed. The memory-
71 management looks like a C-compiler heap management to me...
72
73 hbin-Header
74 ===========
75 Offset      Size      Contents
76 0x0000      D-Word      ID: ASCII-"hbin" = 0x6E696268
77 0x0004      D-Word      Offset from the 1st hbin-Block
78 0x0008      D-Word      Offset to the next hbin-Block
79 0x001C      D-Word      Block-size
80
81 The values in 0x0008 and 0x001C should be the same, so I don't know
82 if they are correct or swapped...
83
84 From offset 0x0020 inside a hbin-block data is stored with the following
85 format:
86
87 Offset      Size      Contents
88 0x0000      D-Word      Data-block size    //this size must be a
89 multiple of 8. Nigel
90 0x0004      ????      Data
91  
92 If the size field is negative (bit 31 set), the corresponding block
93 is free and has a size of -blocksize!
94
95 That does not seem to be true. All block lengths seem to be negative! 
96 (Richard Sharpe) 
97
98 The data is stored as one record per block. Block size is a multiple
99 of 4 and the last block reaches the next hbin-block, leaving no room.
100
101 (That also seems incorrect, in that the block size if a multiple of 8.
102 That is, the block, including the 4 byte header, is always a multiple of
103 8 bytes. Richard Sharpe.)
104
105 Records in the hbin-blocks
106 ==========================
107
108 nk-Record
109
110       The nk-record can be treated as a combination of tree-record and
111       key-record of the win 95 registry.
112
113 lf-Record
114
115       The lf-record is the counterpart to the RGKN-record (the
116       hash-function)
117
118 vk-Record
119
120       The vk-record consists information to a single value (value key).
121
122 sk-Record
123
124       sk (? Security Key ?) is the ACL of the registry.
125
126 Value-Lists
127
128       The value-lists contain information about which values are inside a
129       sub-key and don't have a header.
130
131 Datas
132
133       The datas of the registry are (like the value-list) stored without a
134       header.
135
136 All offset-values are relative to the first hbin-block and point to the
137 block-size field of the record-entry. to get the file offset, you have to add
138 the header size (4kb) and the size field (4 bytes)...
139
140 the nk-Record
141 =============
142 Offset      Size      Contents
143 0x0000      Word      ID: ASCII-"nk" = 0x6B6E
144 0x0002      Word      for the root-key: 0x2C, otherwise 0x20  //key symbolic links 0x10. Nigel
145 0x0004      Q-Word      write-date/time in windows nt notation
146 0x0010      D-Word      Offset of Owner/Parent key
147 0x0014      D-Word      number of sub-Keys
148 0x001C      D-Word      Offset of the sub-key lf-Records
149 0x0024      D-Word      number of values
150 0x0028      D-Word      Offset of the Value-List
151 0x002C      D-Word      Offset of the sk-Record
152
153 0x0030      D-Word      Offset of the Class-Name //see NK structure for the use of these fields. Nigel
154 0x0044      D-Word      Unused (data-trash)  //some kind of run time index. Does not appear to be important. Nigel
155 0x0048      Word      name-length
156 0x004A      Word      class-name length
157 0x004C      ????      key-name
158
159 the Value-List
160 ==============
161 Offset      Size      Contents
162 0x0000      D-Word      Offset 1st Value
163 0x0004      D-Word      Offset 2nd Value
164 0x????      D-Word      Offset nth Value
165
166 To determine the number of values, you have to look at the owner-nk-record!
167
168 Der vk-Record
169 =============
170 Offset      Size      Contents
171 0x0000      Word      ID: ASCII-"vk" = 0x6B76
172 0x0002      Word      name length
173 0x0004      D-Word      length of the data   //if top bit is set when offset contains data. Nigel
174 0x0008      D-Word      Offset of Data
175 0x000C      D-Word      Type of value
176 0x0010      Word      Flag
177 0x0012      Word      Unused (data-trash)
178 0x0014      ????      Name
179
180 If bit 0 of the flag-word is set, a name is present, otherwise the value has no name (=default)
181
182 If the data-size is lower 5, the data-offset value is used to store the data itself!
183
184 The data-types
185 ==============
186 Wert      Beteutung
187 0x0001      RegSZ:             character string (in UNICODE!)
188 0x0002      ExpandSZ:   string with "%var%" expanding (UNICODE!)
189 0x0003      RegBin:           raw-binary value
190 0x0004      RegDWord:   Dword
191 0x0007      RegMultiSZ:      multiple strings, seperated with 0
192                   (UNICODE!)
193
194 The "lf"-record
195 ===============
196 Offset      Size      Contents
197 0x0000      Word      ID: ASCII-"lf" = 0x666C
198 0x0002      Word      number of keys
199 0x0004      ????      Hash-Records
200
201 Hash-Record
202 ===========
203 Offset      Size      Contents
204 0x0000      D-Word      Offset of corresponding "nk"-Record
205 0x0004      D-Word      ASCII: the first 4 characters of the key-name, padded with 0's. Case sensitiv!
206
207 Keep in mind, that the value at 0x0004 is used for checking the data-consistency! If you change the 
208 key-name you have to change the hash-value too!
209
210 //These hashrecords must be sorted low to high within the lf record. Nigel.
211
212 The "sk"-block
213 ==============
214 (due to the complexity of the SAM-info, not clear jet)
215 (This is just a self-relative security descriptor in the data. R Sharpe.) 
216
217
218 Offset      Size      Contents
219 0x0000      Word      ID: ASCII-"sk" = 0x6B73
220 0x0002      Word      Unused
221 0x0004      D-Word      Offset of previous "sk"-Record
222 0x0008      D-Word      Offset of next "sk"-Record
223 0x000C      D-Word      usage-counter
224 0x0010      D-Word      Size of "sk"-record in bytes
225 ????                                             //standard self
226 relative security desciptor. Nigel
227 ????  ????      Security and auditing settings...
228 ????
229
230 The usage counter counts the number of references to this
231 "sk"-record. You can use one "sk"-record for the entire registry!
232
233 Windows nt date/time format
234 ===========================
235 The time-format is a 64-bit integer which is incremented every
236 0,0000001 seconds by 1 (I don't know how accurate it realy is!)
237 It starts with 0 at the 1st of january 1601 0:00! All values are
238 stored in GMT time! The time-zone is important to get the real
239 time!
240
241 Common values for win95 and win-nt
242 ==================================
243 Offset values marking an "end of list", are either 0 or -1 (0xFFFFFFFF).
244 If a value has no name (length=0, flag(bit 0)=0), it is treated as the
245 "Default" entry...
246 If a value has no data (length=0), it is displayed as empty.
247
248 simplyfied win-3.?? registry:
249 =============================
250
251 +-----------+
252 | next rec. |---+                      +----->+------------+
253 | first sub |   |                      |      | Usage cnt. |
254 | name      |   |  +-->+------------+  |      | length     |
255 | value     |   |  |   | next rec.  |  |      | text       |------->+-------+
256 +-----------+   |  |   | name rec.  |--+      +------------+        | xxxxx |
257    +------------+  |   | value rec. |-------->+------------+        +-------+
258    v               |   +------------+         | Usage cnt. |
259 +-----------+      |                          | length     |
260 | next rec. |      |                          | text       |------->+-------+
261 | first sub |------+                          +------------+        | xxxxx |
262 | name      |                                                       +-------+
263 | value     |
264 +-----------+    
265
266 Greatly simplyfied structure of the nt-registry:
267 ================================================
268    
269 +---------------------------------------------------------------+
270 |                                                               |
271 v                                                               |
272 +---------+     +---------->+-----------+  +----->+---------+   |
273 | "nk"    |     |           | lf-rec.   |  |      | nk-rec. |   |
274 | ID      |     |           | # of keys |  |      | parent  |---+
275 | Date    |     |           | 1st key   |--+      | ....    |
276 | parent  |     |           +-----------+         +---------+
277 | suk-keys|-----+
278 | values  |--------------------->+----------+
279 | SK-rec. |---------------+      | 1. value |--> +----------+
280 | class   |--+            |      +----------+    | vk-rec.  |
281 +---------+  |            |                      | ....     |
282              v            |                      | data     |--> +-------+
283       +------------+      |                      +----------+    | xxxxx |
284       | Class name |      |                                      +-------+
285       +------------+      |
286                           v
287           +---------+    +---------+
288    +----->| next sk |--->| Next sk |--+
289    |  +---| prev sk |<---| prev sk |  |
290    |  |   | ....    |    | ...     |  |
291    |  |   +---------+    +---------+  |
292    |  |                    ^          |
293    |  |                    |          |
294    |  +--------------------+          |
295    +----------------------------------+
296
297 ---------------------------------------------------------------------------
298
299 Hope this helps....  (Although it was "fun" for me to uncover this things,
300                   it took me several sleepless nights ;)
301
302             B.D.
303
304 *************************************************************************/
305
306 #include "includes.h"
307 #include "lib/registry/common/registry.h"
308
309 #define REG_KEY_LIST_SIZE 10
310 /*FIXME*/
311
312 /*
313  * Structures for dealing with the on-disk format of the registry
314  */
315
316 const char *def_owner_sid_str = NULL;
317
318 /* 
319  * These definitions are for the in-memory registry structure.
320  * It is a tree structure that mimics what you see with tools like regedit
321  */
322
323
324 /*
325  * Definition of a Key. It has a name, classname, date/time last modified,
326  * sub-keys, values, and a security descriptor
327  */
328
329 #define REG_ROOT_KEY 1
330 #define REG_SUB_KEY  2
331 #define REG_SYM_LINK 3
332
333 /* 
334  * All of the structures below actually have a four-byte length before them
335  * which always seems to be negative. The following macro retrieves that
336  * size as an integer
337  */
338
339 #define BLK_SIZE(b) ((int)*(int *)(((int *)b)-1))
340
341 typedef unsigned int DWORD;
342 typedef unsigned short WORD;
343
344 typedef struct sk_struct SK_HDR;
345 /*
346  * This structure keeps track of the output format of the registry
347  */
348 #define REG_OUTBLK_HDR 1
349 #define REG_OUTBLK_HBIN 2
350
351 typedef struct regf_block {
352         DWORD REGF_ID;     /* regf */
353         DWORD uk1;
354         DWORD uk2;
355         DWORD tim1, tim2;
356         DWORD uk3;             /* 1 */
357         DWORD uk4;             /* 3 */
358         DWORD uk5;             /* 0 */
359         DWORD uk6;             /* 1 */
360         DWORD first_key;       /* offset */
361         unsigned int dblk_size;
362     DWORD uk7[116];        /* 1 */
363     DWORD chksum;
364 } REGF_HDR;
365
366 typedef struct hbin_sub_struct {
367         DWORD dblocksize;
368         char data[1];
369 } HBIN_SUB_HDR;
370
371 typedef struct hbin_struct {
372         DWORD HBIN_ID; /* hbin */
373         DWORD off_from_first;
374         DWORD off_to_next;
375         DWORD uk1;
376         DWORD uk2;
377         DWORD uk3;
378         DWORD uk4;
379         DWORD blk_size;
380         HBIN_SUB_HDR hbin_sub_hdr;
381 } HBIN_HDR;
382
383 typedef struct nk_struct {
384         WORD NK_ID;
385         WORD type;
386         DWORD t1, t2;
387         DWORD uk1;
388         DWORD own_off;
389         DWORD subk_num;
390         DWORD uk2;
391         DWORD lf_off;
392         DWORD uk3;
393         DWORD val_cnt;
394         DWORD val_off;
395         DWORD sk_off;
396         DWORD clsnam_off;
397         DWORD unk4[4];
398         DWORD unk5;
399         WORD nam_len;
400         WORD clsnam_len;
401         char key_nam[1];  /* Actual length determined by nam_len */
402 } NK_HDR;
403
404 struct sk_struct {
405         WORD SK_ID;
406         WORD uk1;
407         DWORD prev_off;
408         DWORD next_off;
409         DWORD ref_cnt;
410         DWORD rec_size;
411         char sec_desc[1];
412 };
413
414 typedef struct key_sec_desc_s {
415         struct key_sec_desc_s *prev, *next;
416         int ref_cnt;
417         int state;
418         int offset;
419         SK_HDR *sk_hdr;     /* This means we must keep the registry in memory */
420         SEC_DESC *sec_desc;
421 } KEY_SEC_DESC; 
422
423 /* A map of sk offsets in the regf to KEY_SEC_DESCs for quick lookup etc */
424 typedef struct sk_map_s {
425   int sk_off;
426   KEY_SEC_DESC *key_sec_desc;
427 } SK_MAP;
428
429 typedef struct vk_struct {
430   WORD VK_ID;
431   WORD nam_len;
432   DWORD dat_len;    /* If top-bit set, offset contains the data */
433   DWORD dat_off;
434   DWORD dat_type;
435   WORD flag;        /* =1, has name, else no name (=Default). */
436   WORD unk1;
437   char dat_name[1]; /* Name starts here ... */
438 } VK_HDR;
439
440 typedef DWORD VL_TYPE[1];  /* Value list is an array of vk rec offsets */
441                                                                                 
442 typedef struct hash_struct {
443   DWORD nk_off;
444   char hash[4];
445 } HASH_REC;
446
447
448 typedef struct lf_struct {
449   WORD LF_ID;
450   WORD key_count;
451   struct hash_struct hr[1];  /* Array of hash records, depending on key_count */} LF_HDR;
452
453
454
455 /*
456  * This structure keeps track of the output format of the registry
457  */
458 #define REG_OUTBLK_HDR 1
459 #define REG_OUTBLK_HBIN 2
460
461 typedef struct hbin_blk_s {
462   int type, size;
463   struct hbin_blk_s *next;
464   char *data;                /* The data block                */
465   unsigned int file_offset;  /* Offset in file                */
466   unsigned int free_space;   /* Amount of free space in block */
467   unsigned int fsp_off;      /* Start of free space in block  */
468   int complete, stored;
469 } HBIN_BLK;
470
471 typedef struct regf_struct_s {
472         int reg_type;
473         int fd;
474         struct stat sbuf;
475         char *base;
476         int modified;
477         NTTIME last_mod_time;
478         NK_HDR *first_key;
479         int sk_count, sk_map_size;
480         SK_MAP *sk_map;
481         const char *owner_sid_str;
482         SEC_DESC *def_sec_desc;
483         /*
484          * These next pointers point to the blocks used to contain the 
485          * keys when we are preparing to write them to a file
486          */
487         HBIN_BLK *blk_head, *blk_tail, *free_space;
488         TALLOC_CTX *mem_ctx;
489 } REGF;
490
491 DWORD str_to_dword(const char *a) {
492         int i;
493         unsigned long ret = 0;
494         for(i = strlen(a)-1; i >= 0; i--) {
495                 ret = ret * 0x100 + a[i];
496         }
497         return ret;
498 }
499
500 #if 0
501
502 /*
503  * Create an ACE
504  */
505 static BOOL nt_create_ace(SEC_ACE *ace, int type, int flags, uint32 perms, const char *sid)
506 {
507   DOM_SID s;
508   SEC_ACCESS access;
509   access.mask = perms;
510   if(!string_to_sid(&s, sid))return False;
511   init_sec_ace(ace, &s, type, access, flags);
512   return True;
513 }
514
515 /*
516  * Create a default ACL
517  */
518 static SEC_ACL *nt_create_default_acl(REG_HANDLE *regf)
519 {
520   SEC_ACE aces[8];
521
522   if(!nt_create_ace(&aces[0], 0x00, 0x0, 0xF003F, regf->owner_sid_str)) return NULL;
523   if(!nt_create_ace(&aces[1], 0x00, 0x0, 0xF003F, "S-1-5-18")) return NULL;
524   if(!nt_create_ace(&aces[2], 0x00, 0x0, 0xF003F, "S-1-5-32-544")) return NULL;
525   if(!nt_create_ace(&aces[3], 0x00, 0x0, 0x20019, "S-1-5-12")) return NULL;
526   if(!nt_create_ace(&aces[4], 0x00, 0x0B, GENERIC_RIGHT_ALL_ACCESS, regf->owner_sid_str)) return NULL;
527   if(!nt_create_ace(&aces[5], 0x00, 0x0B, 0x10000000, "S-1-5-18")) return NULL;
528   if(!nt_create_ace(&aces[6], 0x00, 0x0B, 0x10000000, "S-1-5-32-544")) return NULL;
529   if(!nt_create_ace(&aces[7], 0x00, 0x0B, 0x80000000, "S-1-5-12")) return NULL;
530
531   return make_sec_acl(regf->mem_ctx, 2, 8, aces);
532 }
533
534 /*
535  * Create a default security descriptor. We pull in things from env
536  * if need be 
537  */
538 static SEC_DESC *nt_create_def_sec_desc(REG_HANDLE *regf)
539 {
540   SEC_DESC *tmp;
541
542   tmp = (SEC_DESC *)malloc(sizeof(SEC_DESC));
543
544   tmp->revision = 1;
545   tmp->type = SEC_DESC_SELF_RELATIVE | SEC_DESC_DACL_PRESENT;
546   if (!string_to_sid(tmp->owner_sid, "S-1-5-32-544")) goto error;
547   if (!string_to_sid(tmp->grp_sid, "S-1-5-18")) goto error;
548   tmp->sacl = NULL;
549   tmp->dacl = nt_create_default_acl(regf);
550
551   return tmp;
552
553  error:
554   if (tmp) nt_delete_sec_desc(tmp);
555   return NULL;
556 }
557
558 /*
559  * We will implement inheritence that is based on what the parent's SEC_DESC
560  * says, but the Owner and Group SIDs can be overwridden from the command line
561  * and additional ACEs can be applied from the command line etc.
562  */
563 static KEY_SEC_DESC *nt_inherit_security(REG_KEY *key)
564 {
565
566   if (!key) return NULL;
567   return key->security;
568 }
569
570 /*
571  * Create an initial security descriptor and init other structures, if needed
572  * We assume that the initial security stuff is empty ...
573  */
574 static KEY_SEC_DESC *nt_create_init_sec(REG_HANDLE *h)
575 {
576         REGF *regf = h->backend_data;
577         KEY_SEC_DESC *tsec = NULL;
578
579         tsec = (KEY_SEC_DESC *)malloc(sizeof(KEY_SEC_DESC));
580
581         tsec->ref_cnt = 1;
582         tsec->state = SEC_DESC_NBK;
583         tsec->offset = 0;
584
585         tsec->sec_desc = regf->def_sec_desc;
586
587         return tsec;
588 }
589 #endif
590
591 /*
592  * Get the starting record for NT Registry file 
593  */
594
595 /* 
596  * Where we keep all the regf stuff for one registry.
597  * This is the structure that we use to tie the in memory tree etc 
598  * together. By keeping separate structs, we can operate on different
599  * registries at the same time.
600  * Currently, the SK_MAP is an array of mapping structure.
601  * Since we only need this on input and output, we fill in the structure
602  * as we go on input. On output, we know how many SK items we have, so
603  * we can allocate the structure as we need to.
604  * If you add stuff here that is dynamically allocated, add the 
605  * appropriate free statements below.
606  */
607
608 #define REG_HANDLE_REGTYPE_NONE 0
609 #define REG_HANDLE_REGTYPE_NT   1
610 #define REG_HANDLE_REGTYPE_W9X  2
611
612 #define TTTONTTIME(r, t1, t2) (r)->last_mod_time.low = (t1); \
613                               (r)->last_mod_time.high = (t2);
614
615 #define REGF_HDR_BLKSIZ 0x1000 
616
617 #define OFF(f) ((f) + REGF_HDR_BLKSIZ + 4) 
618 #define LOCN(base, f) ((base) + OFF(f))
619
620 /* Get the header of the registry. Return a pointer to the structure 
621  * If the mmap'd area has not been allocated, then mmap the input file
622  */
623 static REGF_HDR *nt_get_regf_hdr(REG_HANDLE *h)
624 {
625         REGF *regf = h->backend_data;
626         SMB_REG_ASSERT(regf);
627
628         if (!regf->base) { /* Try to mmap etc the file */
629
630                 if ((regf->fd = open(h->location, O_RDONLY, 0000)) <0) {
631                         return NULL; /* What about errors? */
632                 }
633
634                 if (fstat(regf->fd, &regf->sbuf) < 0) {
635                         return NULL;
636                 }
637
638                 regf->base = mmap(0, regf->sbuf.st_size, PROT_READ, MAP_SHARED, regf->fd, 0);
639
640                 if ((int)regf->base == 1) {
641                         DEBUG(0,("Could not mmap file: %s, %s\n", h->location,
642                                          strerror(errno)));
643                         return NULL;
644                 }
645         }
646
647         /* 
648          * At this point, regf->base != NULL, and we should be able to read the 
649          * header 
650          */
651
652         SMB_REG_ASSERT(regf->base != NULL);
653
654         return (REGF_HDR *)regf->base;
655 }
656
657 /*
658  * Validate a regf header
659  * For now, do nothing, but we should check the checksum
660  */
661 static int valid_regf_hdr(REGF_HDR *regf_hdr)
662 {
663         if (!regf_hdr) return 0;
664
665         return 1;
666 }
667
668 #if 0
669
670 /*
671  * Process an SK header ...
672  * Every time we see a new one, add it to the map. Otherwise, just look it up.
673  * We will do a simple linear search for the moment, since many KEYs have the 
674  * same security descriptor. 
675  * We allocate the map in increments of 10 entries.
676  */
677
678 /*
679  * Create a new entry in the map, and increase the size of the map if needed
680  */
681 static SK_MAP *alloc_sk_map_entry(REG_HANDLE *h, KEY_SEC_DESC *tmp, int sk_off)
682 {
683         REGF *regf = h->backend_data;
684         if (!regf->sk_map) { /* Allocate a block of 10 */
685                 regf->sk_map = (SK_MAP *)malloc(sizeof(SK_MAP) * 10);
686                 regf->sk_map_size = 10;
687                 regf->sk_count = 1;
688                 (regf->sk_map)[0].sk_off = sk_off;
689                 (regf->sk_map)[0].key_sec_desc = tmp;
690         }
691         else { /* Simply allocate a new slot, unless we have to expand the list */ 
692                 int ndx = regf->sk_count;
693                 if (regf->sk_count >= regf->sk_map_size) {
694                         regf->sk_map = (SK_MAP *)realloc(regf->sk_map, 
695                                                                                          (regf->sk_map_size + 10)*sizeof(SK_MAP));
696                         if (!regf->sk_map) {
697                                 free(tmp);
698                                 return NULL;
699                         }
700                         /*
701                          * ndx already points at the first entry of the new block
702                          */
703                         regf->sk_map_size += 10;
704                 }
705                 (regf->sk_map)[ndx].sk_off = sk_off;
706                 (regf->sk_map)[ndx].key_sec_desc = tmp;
707                 regf->sk_count++;
708         }
709         return regf->sk_map;
710 }
711
712 /*
713  * Search for a KEY_SEC_DESC in the sk_map, but don't create one if not
714  * found
715  */
716 KEY_SEC_DESC *lookup_sec_key(SK_MAP *sk_map, int count, int sk_off)
717 {
718         int i;
719
720         if (!sk_map) return NULL;
721
722         for (i = 0; i < count; i++) {
723
724                 if (sk_map[i].sk_off == sk_off)
725                         return sk_map[i].key_sec_desc;
726
727         }
728
729         return NULL;
730
731 }
732
733 /*
734  * Allocate a KEY_SEC_DESC if we can't find one in the map
735  */
736 static KEY_SEC_DESC *lookup_create_sec_key(REG_HANDLE *h, SK_MAP *sk_map, int sk_off)
737 {
738         REGF *regf = h->backend_data;
739         KEY_SEC_DESC *tmp = lookup_sec_key(regf->sk_map, regf->sk_count, sk_off);
740
741         if (tmp) {
742                 return tmp;
743         }
744         else { /* Allocate a new one */
745                 tmp = (KEY_SEC_DESC *)malloc(sizeof(KEY_SEC_DESC));
746                 memset(tmp, 0, sizeof(KEY_SEC_DESC)); /* Neatly sets offset to 0 */
747                 tmp->state = SEC_DESC_RES;
748                 if (!alloc_sk_map_entry(h, tmp, sk_off)) {
749                         return NULL;
750                 }
751                 return tmp;
752         }
753 }
754
755 static SEC_DESC *process_sec_desc(REG_HANDLE *regf, SEC_DESC *sec_desc)
756 {
757         SEC_DESC *tmp = NULL;
758
759         tmp = (SEC_DESC *)malloc(sizeof(SEC_DESC));
760
761         tmp->revision = SVAL(&sec_desc->revision,0);
762         tmp->type = SVAL(&sec_desc->type,0);
763         DEBUG(2, ("SEC_DESC Rev: %0X, Type: %0X\n", tmp->revision, tmp->type));
764         DEBUGADD(2, ("SEC_DESC Owner Off: %0X\n", IVAL(&sec_desc->off_owner_sid,0)));
765         DEBUGADD(2, ("SEC_DESC Group Off: %0X\n", IVAL(&sec_desc->off_grp_sid,0)));
766         DEBUGADD(2, ("SEC_DESC DACL Off: %0X\n", IVAL(&sec_desc->off_dacl,0)));
767         tmp->owner_sid = sid_dup_talloc(regf->mem_ctx, (DOM_SID *)((char *)sec_desc + IVAL(&sec_desc->off_owner_sid,0)));
768         if (!tmp->owner_sid) {
769                 free(tmp);
770                 return NULL;
771         }
772         tmp->grp_sid = sid_dup_talloc(regf->mem_ctx, (DOM_SID *)((char *)sec_desc + IVAL(&sec_desc->off_grp_sid,0)));
773         if (!tmp->grp_sid) {
774                 free(tmp);
775                 return NULL;
776         }
777
778         /* Now pick up the SACL and DACL */
779
780         DEBUG(0, ("%d, %d\n", IVAL(&sec_desc->off_sacl,0), IVAL(&sec_desc->off_dacl,0)));
781
782         if (sec_desc->off_sacl)
783                 tmp->sacl = dup_sec_acl(regf->mem_ctx, (SEC_ACL *)((char *)sec_desc + IVAL(&sec_desc->off_sacl,0)));
784         else
785                 tmp->sacl = NULL;
786
787         if (sec_desc->off_dacl)
788                 tmp->dacl = dup_sec_acl(regf->mem_ctx, (SEC_ACL *)((char *)sec_desc + IVAL(&sec_desc->off_dacl,0)));
789         else
790                 tmp->dacl = NULL;
791
792         return tmp;
793 }
794
795 static KEY_SEC_DESC *process_sk(REG_HANDLE *regf, SK_HDR *sk_hdr, int sk_off, int size)
796 {
797         KEY_SEC_DESC *tmp = NULL;
798         int sk_next_off, sk_prev_off, sk_size;
799         SEC_DESC *sec_desc;
800
801         if (!sk_hdr) return NULL;
802
803         if (SVAL(&sk_hdr->SK_ID,0) != str_to_dword("sk")) {
804                 DEBUG(0, ("Unrecognized SK Header ID: %08X, %s\n", (int)sk_hdr,
805                                   regf->regfile_name));
806                 return NULL;
807         }
808
809         if (-size < (sk_size = IVAL(&sk_hdr->rec_size,0))) {
810                 DEBUG(0, ("Incorrect SK record size: %d vs %d. %s\n",
811                                   -size, sk_size, regf->regfile_name));
812                 return NULL;
813         }
814
815         /* 
816          * Now, we need to look up the SK Record in the map, and return it
817          * Since the map contains the SK_OFF mapped to KEY_SEC_DESC, we can
818          * use that
819          */
820
821         if (regf->sk_map &&
822                 ((tmp = lookup_sec_key(regf->sk_map, regf->sk_count, sk_off)) != NULL)
823                 && (tmp->state == SEC_DESC_OCU)) {
824                 tmp->ref_cnt++;
825                 return tmp;
826         }
827
828         /* Here, we have an item in the map that has been reserved, or tmp==NULL. */
829
830         SMB_REG_ASSERT(tmp == NULL || (tmp && tmp->state != SEC_DESC_NON));
831
832         /*
833          * Now, allocate a KEY_SEC_DESC, and parse the structure here, and add the
834          * new KEY_SEC_DESC to the mapping structure, since the offset supplied is 
835          * the actual offset of structure. The same offset will be used by
836          * all future references to this structure
837          * We could put all this unpleasantness in a function.
838          */
839
840         if (!tmp) {
841                 tmp = (KEY_SEC_DESC *)malloc(sizeof(KEY_SEC_DESC));
842                 memset(tmp, 0, sizeof(KEY_SEC_DESC));
843
844                 /*
845                  * Allocate an entry in the SK_MAP ...
846                  * We don't need to free tmp, because that is done for us if the
847                  * sm_map entry can't be expanded when we need more space in the map.
848                  */
849
850                 if (!alloc_sk_map_entry(regf, tmp, sk_off)) {
851                         return NULL;
852                 }
853         }
854
855         tmp->ref_cnt++;
856         tmp->state = SEC_DESC_OCU;
857
858         /*
859          * Now, process the actual sec desc and plug the values in
860          */
861
862         sec_desc = (SEC_DESC *)&sk_hdr->sec_desc[0];
863         tmp->sec_desc = process_sec_desc(regf, sec_desc);
864
865         /*
866          * Now forward and back links. Here we allocate an entry in the sk_map
867          * if it does not exist, and mark it reserved
868          */
869
870         sk_prev_off = IVAL(&sk_hdr->prev_off,0);
871         tmp->prev = lookup_create_sec_key(regf, regf->sk_map, sk_prev_off);
872         SMB_REG_ASSERT(tmp->prev != NULL);
873         sk_next_off = IVAL(&sk_hdr->next_off,0);
874         tmp->next = lookup_create_sec_key(regf, regf->sk_map, sk_next_off);
875         SMB_REG_ASSERT(tmp->next != NULL);
876
877         return tmp;
878 }
879 #endif
880
881 /*
882  * Process a VK header and return a value
883  */
884 static REG_VAL *vk_to_val(REG_KEY *parent, VK_HDR *vk_hdr, int size)
885 {
886         char val_name[1024];
887         REGF *regf = parent->handle->backend_data;
888         int nam_len, dat_len, flag, dat_type, dat_off, vk_id;
889         const char *val_type;
890         REG_VAL *tmp = NULL; 
891
892         if (!vk_hdr) return NULL;
893
894         if ((vk_id = SVAL(&vk_hdr->VK_ID,0)) != str_to_dword("vk")) {
895                 DEBUG(0, ("Unrecognized VK header ID: %0X, block: %0X, %s\n",
896                                   vk_id, (int)vk_hdr, parent->handle->location));
897                 return NULL;
898         }
899
900         nam_len = SVAL(&vk_hdr->nam_len,0);
901         val_name[nam_len] = '\0';
902         flag = SVAL(&vk_hdr->flag,0);
903         dat_type = IVAL(&vk_hdr->dat_type,0);
904         dat_len = IVAL(&vk_hdr->dat_len,0);  /* If top bit, offset contains data */
905         dat_off = IVAL(&vk_hdr->dat_off,0);
906
907         tmp = reg_val_new(parent, NULL);
908         tmp->has_name = flag;
909         tmp->data_type = dat_type;
910
911         if (flag & 0x01) {
912                 strncpy(val_name, vk_hdr->dat_name, nam_len);
913                 tmp->name = strdup(val_name);
914         }
915         else
916                 strncpy(val_name, "<No Name>", 10);
917
918         /*
919          * Allocate space and copy the data as a BLOB
920          */
921
922         if (dat_len&0x7FFFFFFF) {
923
924                 char *dtmp = (char *)malloc(dat_len&0x7FFFFFFF);
925
926                 tmp->data_blk = dtmp;
927
928                 if ((dat_len&0x80000000) == 0) { /* The data is pointed to by the offset */
929                         char *dat_ptr = LOCN(regf->base, dat_off);
930                         memcpy(dtmp, dat_ptr, dat_len);
931                 }
932                 else { /* The data is in the offset or type */
933                         /*
934                          * FIXME.
935                          * Some registry files seem to have weird fields. If top bit is set,
936                          * but len is 0, the type seems to be the value ...
937                          * Not sure how to handle this last type for the moment ...
938                          */
939                         dat_len = dat_len & 0x7FFFFFFF;
940                         memcpy(dtmp, &dat_off, dat_len);
941                 }
942
943                 tmp->data_len = dat_len;
944         }
945
946         return tmp;
947 }
948
949 static BOOL vl_verify(VL_TYPE vl, int count, int size)
950 {
951         if(!vl) return False;
952         if (-size < (count+1)*sizeof(int)){
953                 DEBUG(0, ("Error in VL header format. Size less than space required. %d\n", -size));
954                 return False;
955         }
956         return True;
957 }
958
959 static BOOL lf_verify(REG_HANDLE *h, LF_HDR *lf_hdr, int size)
960 {
961         int lf_id;
962         if ((lf_id = SVAL(&lf_hdr->LF_ID,0)) != str_to_dword("lf")) {
963                 DEBUG(0, ("Unrecognized LF Header format: %0X, Block: %0X, %s.\n",
964                                   lf_id, (int)lf_hdr, h->location));
965                 return False;
966         }
967         return True;
968 }
969
970 static int lf_num_entries(REG_HANDLE *h, LF_HDR *lf_hdr, int size)
971 {
972         int count;
973
974         if(!lf_verify(h, lf_hdr, size)) return 0;
975
976         SMB_REG_ASSERT(size < 0);
977
978         count = SVAL(&lf_hdr->key_count,0);
979         DEBUG(2, ("Key Count: %u\n", count));
980         if (count <= 0) return 0;
981
982         return count;
983 }
984
985
986 static REG_KEY *nk_to_key(REG_HANDLE *regf, NK_HDR *nk_hdr, int size, REG_KEY *parent);
987
988
989
990 /*
991  * Process an LF Header and return a list of sub-keys
992  */
993 static REG_KEY *lf_get_entry(REG_KEY *parent, LF_HDR *lf_hdr, int size, int n)
994 {
995         REGF *regf = parent->handle->backend_data;
996         int count, nk_off;
997         NK_HDR *nk_hdr;
998
999         if (!lf_hdr) return NULL;
1000
1001         if(!lf_verify(parent->handle, lf_hdr, size)) return NULL;
1002
1003         SMB_REG_ASSERT(size < 0);
1004
1005         count = SVAL(&lf_hdr->key_count,0);
1006         DEBUG(2, ("Key Count: %u\n", count));
1007         if (count <= 0 || n > count) return NULL;
1008
1009         nk_off = IVAL(&lf_hdr->hr[n].nk_off,0);
1010         DEBUG(2, ("NK Offset: %0X\n", nk_off));
1011         nk_hdr = (NK_HDR *)LOCN(regf->base, nk_off);
1012         return nk_to_key(parent->handle, nk_hdr, BLK_SIZE(nk_hdr), parent);
1013 }
1014
1015 static REG_KEY *nk_to_key(REG_HANDLE *h, NK_HDR *nk_hdr, int size, REG_KEY *parent)
1016 {
1017         REGF *regf = h->backend_data;
1018         REG_KEY *tmp = NULL, *own;
1019         int name_len, clsname_len, sk_off, own_off;
1020         unsigned int nk_id;
1021         SK_HDR *sk_hdr;
1022         int type;
1023         char key_name[1024], cls_name[1024];
1024
1025         if (!nk_hdr) return NULL;
1026
1027         if ((nk_id = SVAL(&nk_hdr->NK_ID,0)) != str_to_dword("nk")) {
1028                 DEBUG(0, ("Unrecognized NK Header format: %08X, Block: %0X. %s\n", 
1029                                   nk_id, (int)nk_hdr, parent->handle->location));
1030                 return NULL;
1031         }
1032
1033         SMB_REG_ASSERT(size < 0);
1034
1035         name_len = SVAL(&nk_hdr->nam_len,0);
1036         clsname_len = SVAL(&nk_hdr->clsnam_len,0);
1037
1038         /*
1039          * The value of -size should be ge 
1040          * (sizeof(NK_HDR) - 1 + name_len)
1041          * The -1 accounts for the fact that we included the first byte of 
1042          * the name in the structure. clsname_len is the length of the thing 
1043          * pointed to by clsnam_off
1044          */
1045
1046         if (-size < (sizeof(NK_HDR) - 1 + name_len)) {
1047                 DEBUG(0, ("Incorrect NK_HDR size: %d, %0X\n", -size, (int)nk_hdr));
1048                 DEBUG(0, ("Sizeof NK_HDR: %d, name_len %d, clsname_len %d\n",
1049                                   sizeof(NK_HDR), name_len, clsname_len));
1050                 /*return NULL;*/
1051         }
1052
1053         DEBUG(2, ("NK HDR: Name len: %d, class name len: %d\n", name_len, clsname_len));
1054
1055         /* Fish out the key name and process the LF list */
1056
1057         SMB_REG_ASSERT(name_len < sizeof(key_name));
1058
1059         strncpy(key_name, nk_hdr->key_nam, name_len);
1060         key_name[name_len] = '\0';
1061
1062         type = (SVAL(&nk_hdr->type,0)==0x2C?REG_ROOT_KEY:REG_SUB_KEY);
1063         if(type == REG_ROOT_KEY && parent) {
1064                 DEBUG(0,("Root key encountered below root level!\n"));
1065                 return NULL;
1066         }
1067
1068         if(type == REG_ROOT_KEY) tmp = reg_key_new_abs(key_name, h, nk_hdr);
1069         else tmp = reg_key_new_rel(key_name, parent, nk_hdr);
1070
1071         DEBUG(2, ("Key name: %s\n", key_name));
1072
1073         /*
1074          * Fish out the class name, it is in UNICODE, while the key name is 
1075          * ASCII :-)
1076          */
1077
1078         if (clsname_len) { /* Just print in Ascii for now */
1079                 smb_ucs2_t *clsnamep;
1080                 int clsnam_off;
1081
1082                 clsnam_off = IVAL(&nk_hdr->clsnam_off,0);
1083                 clsnamep = (smb_ucs2_t *)LOCN(regf->base, clsnam_off);
1084                 DEBUG(2, ("Class Name Offset: %0X\n", clsnam_off));
1085
1086                 tmp->class_name = talloc_strdup_w(regf->mem_ctx, clsnamep);
1087
1088                 DEBUGADD(2,("  Class Name: %s\n", cls_name));
1089
1090         }
1091
1092         /*
1093          * Process the owner offset ...
1094          */
1095
1096         own_off = IVAL(&nk_hdr->own_off,0);
1097         own = (REG_KEY *)LOCN(regf->base, own_off);
1098         DEBUG(2, ("Owner Offset: %0X\n", own_off));
1099
1100         DEBUGADD(2, ("  Owner locn: %0X, Our locn: %0X\n", 
1101                                  (unsigned int)own, (unsigned int)nk_hdr));
1102
1103         /* 
1104          * We should verify that the owner field is correct ...
1105          * for now, we don't worry ...
1106          */
1107
1108         /* 
1109          * Also handle the SK header ...
1110          */
1111
1112         sk_off = IVAL(&nk_hdr->sk_off,0);
1113         sk_hdr = (SK_HDR *)LOCN(regf->base, sk_off);
1114         DEBUG(2, ("SK Offset: %0X\n", sk_off));
1115
1116         if (sk_off != -1) {
1117
1118 #if 0
1119                 tmp->security = process_sk(regf, sk_hdr, sk_off, BLK_SIZE(sk_hdr));
1120 #endif
1121
1122         } 
1123
1124         return tmp;
1125 }
1126
1127 /*
1128  * Allocate a new hbin block, set up the header for the block etc 
1129  */
1130 static HBIN_BLK *nt_create_hbin_blk(REG_HANDLE *h, int size)
1131 {
1132         REGF *regf = h->backend_data;
1133         HBIN_BLK *tmp;
1134         HBIN_HDR *hdr;
1135
1136         if (!regf || !size) return NULL;
1137
1138         /* Round size up to multiple of REGF_HDR_BLKSIZ */
1139
1140         size = (size + (REGF_HDR_BLKSIZ - 1)) & ~(REGF_HDR_BLKSIZ - 1);
1141
1142         tmp = (HBIN_BLK *)malloc(sizeof(HBIN_BLK));
1143         memset(tmp, 0, sizeof(HBIN_BLK));
1144
1145         tmp->data = malloc(size);
1146
1147         memset(tmp->data, 0, size);  /* Make it pristine */
1148
1149         tmp->size = size;
1150         /*FIXMEtmp->file_offset = regf->blk_tail->file_offset + regf->blk_tail->size;*/
1151
1152         tmp->free_space = size - (sizeof(HBIN_HDR) - sizeof(HBIN_SUB_HDR));
1153         tmp->fsp_off = size - tmp->free_space;
1154
1155         /* 
1156          * Now, build the header in the data block 
1157          */
1158         hdr = (HBIN_HDR *)tmp->data;
1159         hdr->HBIN_ID = str_to_dword("hbin");
1160         hdr->off_from_first = tmp->file_offset - REGF_HDR_BLKSIZ;
1161         hdr->off_to_next = tmp->size;
1162         hdr->blk_size = tmp->size;
1163
1164         /*
1165          * Now link it in
1166          */
1167
1168         regf->blk_tail->next = tmp;
1169         regf->blk_tail = tmp;
1170         if (!regf->free_space) regf->free_space = tmp;
1171
1172         return tmp;
1173 }
1174
1175 /*
1176  * Allocate a unit of space ... and return a pointer as function param
1177  * and the block's offset as a side effect
1178  */
1179 static void *nt_alloc_regf_space(REG_HANDLE *h, int size, unsigned int *off)
1180 {
1181         REGF *regf = h->backend_data;
1182         int tmp = 0;
1183         void *ret = NULL;
1184         HBIN_BLK *blk;
1185
1186         if (!regf || !size || !off) return NULL;
1187
1188         SMB_REG_ASSERT(regf->blk_head != NULL);
1189
1190         /*
1191          * round up size to include header and then to 8-byte boundary
1192          */
1193         size = (size + 4 + 7) & ~7;
1194
1195         /*
1196          * Check if there is space, if none, grab a block
1197          */
1198         if (!regf->free_space) {
1199                 if (!nt_create_hbin_blk(h, REGF_HDR_BLKSIZ))
1200                         return NULL;
1201         }
1202
1203         /*
1204          * Now, chain down the list of blocks looking for free space
1205          */
1206
1207         for (blk = regf->free_space; blk != NULL; blk = blk->next) {
1208                 if (blk->free_space <= size) {
1209                         tmp = blk->file_offset + blk->fsp_off - REGF_HDR_BLKSIZ;
1210                         ret = blk->data + blk->fsp_off;
1211                         blk->free_space -= size;
1212                         blk->fsp_off += size;
1213
1214                         /* Insert the header */
1215                         ((HBIN_SUB_HDR *)ret)->dblocksize = -size;
1216
1217                         /*
1218                          * Fix up the free space ptr
1219                          * If it is NULL, we fix it up next time
1220                          */
1221
1222                         if (!blk->free_space) 
1223                                 regf->free_space = blk->next;
1224
1225                         *off = tmp;
1226                         return (((char *)ret)+4);/* The pointer needs to be to the data struct */
1227                 }
1228         }
1229
1230         /*
1231          * If we got here, we need to add another block, which might be 
1232          * larger than one block -- deal with that later
1233          */
1234         if (nt_create_hbin_blk(h, REGF_HDR_BLKSIZ)) {
1235                 blk = regf->free_space;
1236                 tmp = blk->file_offset + blk->fsp_off - REGF_HDR_BLKSIZ;
1237                 ret = blk->data + blk->fsp_off;
1238                 blk->free_space -= size;
1239                 blk->fsp_off += size;
1240
1241                 /* Insert the header */
1242                 ((HBIN_SUB_HDR *)ret)->dblocksize = -size;
1243
1244                 /*
1245                  * Fix up the free space ptr
1246                  * If it is NULL, we fix it up next time
1247                  */
1248
1249                 if (!blk->free_space) 
1250                         regf->free_space = blk->next;
1251
1252                 *off = tmp;
1253                 return (((char *)ret) + 4);/* The pointer needs to be to the data struct */
1254         }
1255
1256         return NULL;
1257 }
1258
1259 /*
1260  * Store a SID at the location provided
1261  */
1262 static int nt_store_SID(REG_HANDLE *regf, DOM_SID *sid, unsigned char *locn)
1263 {
1264         int i;
1265         unsigned char *p = locn;
1266
1267         if (!regf || !sid || !locn) return 0;
1268
1269         *p = sid->sid_rev_num; p++;
1270         *p = sid->num_auths; p++;
1271
1272         for (i=0; i < 6; i++) {
1273                 *p = sid->id_auth[i]; p++;
1274         }
1275
1276         for (i=0; i < sid->num_auths; i++) {
1277                 SIVAL(p, 0, sid->sub_auths[i]); p+=4;
1278         }
1279
1280         return p - locn;
1281
1282 }
1283
1284 static int nt_store_ace(REG_HANDLE *regf, SEC_ACE *ace, unsigned char *locn)
1285 {
1286         int size = 0;
1287         SEC_ACE *reg_ace = (SEC_ACE *)locn;
1288         unsigned char *p;
1289
1290         if (!regf || !ace || !locn) return 0;
1291
1292         reg_ace->type = ace->type;
1293         reg_ace->flags = ace->flags;
1294
1295         /* Deal with the length when we have stored the SID */
1296
1297         p = (unsigned char *)&reg_ace->info.mask;
1298
1299         SIVAL(p, 0, ace->info.mask); p += 4;
1300
1301         size = nt_store_SID(regf, &ace->trustee, p);
1302
1303         size += 8; /* Size of the fixed header */
1304
1305         p = (unsigned char *)&reg_ace->size;
1306
1307         SSVAL(p, 0, size);
1308
1309         return size;
1310 }
1311
1312 /*
1313  * Store an ACL at the location provided
1314  */
1315 static int nt_store_acl(REG_HANDLE *regf, SEC_ACL *acl, unsigned char *locn) {
1316         int size = 0, i;
1317         unsigned char *p = locn, *s;
1318
1319         if (!regf || !acl || !locn) return 0;
1320
1321         /*
1322          * Now store the header and then the ACEs ...
1323          */
1324
1325         SSVAL(p, 0, acl->revision);
1326
1327         p += 2; s = p; /* Save this for the size field */
1328
1329         p += 2;
1330
1331         SIVAL(p, 0, acl->num_aces);
1332
1333         p += 4;
1334
1335         for (i = 0; i < acl->num_aces; i++) {
1336                 size = nt_store_ace(regf, &acl->ace[i], p);
1337                 p += size;
1338         }
1339
1340         size = s - locn;
1341         SSVAL(s, 0, size);
1342         return size;
1343 }
1344
1345 /*
1346  * Flatten and store the Sec Desc 
1347  * Windows lays out the DACL first, but since there is no SACL, it might be
1348  * that first, then the owner, then the group SID. So, we do it that way
1349  * too.
1350  */
1351 static unsigned int nt_store_sec_desc(REG_HANDLE *regf, SEC_DESC *sd, char *locn)
1352 {
1353         SEC_DESC *rsd = (SEC_DESC *)locn;
1354         unsigned int size = 0, off = 0;
1355
1356         if (!regf || !sd || !locn) return 0;
1357
1358         /* 
1359          * Now, fill in the first two fields, then lay out the various fields
1360          * as needed
1361          */
1362
1363         rsd->revision = SEC_DESC_REVISION;
1364         rsd->type = SEC_DESC_DACL_PRESENT | SEC_DESC_SELF_RELATIVE;  
1365
1366         off = 4 * sizeof(DWORD) + 4;
1367
1368         if (sd->sacl){
1369                 size = nt_store_acl(regf, sd->sacl, (char *)(locn + off));
1370                 rsd->off_sacl = off;
1371         }
1372         else
1373                 rsd->off_sacl = 0;
1374
1375         off += size;
1376
1377         if (sd->dacl) {
1378                 rsd->off_dacl = off;
1379                 size = nt_store_acl(regf, sd->dacl, (char *)(locn + off));
1380         }
1381         else {
1382                 rsd->off_dacl = 0;
1383         }
1384
1385         off += size;
1386
1387         /* Now the owner and group SIDs */
1388
1389         if (sd->owner_sid) {
1390                 rsd->off_owner_sid = off;
1391                 size = nt_store_SID(regf, sd->owner_sid, (char *)(locn + off));
1392         }
1393         else {
1394                 rsd->off_owner_sid = 0;
1395         }
1396
1397         off += size;
1398
1399         if (sd->grp_sid) {
1400                 rsd->off_grp_sid = off;
1401                 size = nt_store_SID(regf, sd->grp_sid, (char *)(locn + off));
1402         }
1403         else {
1404                 rsd->off_grp_sid = 0;
1405         }
1406
1407         off += size;
1408
1409         return size;
1410 }
1411
1412 /*
1413  * Store the security information
1414  *
1415  * If it has already been stored, just get its offset from record
1416  * otherwise, store it and record its offset
1417  */
1418 static unsigned int nt_store_security(REG_HANDLE *regf, KEY_SEC_DESC *sec)
1419 {
1420         int size = 0;
1421         unsigned int sk_off;
1422         SK_HDR *sk_hdr;
1423
1424         if (sec->offset) return sec->offset;
1425
1426         /*
1427          * OK, we don't have this one in the file yet. We must compute the 
1428          * size taken by the security descriptor as a self-relative SD, which
1429          * means making one pass over each structure and figuring it out
1430          */
1431
1432 //FIXME size = sec_desc_size(sec->sec_desc);
1433
1434         /* Allocate that much space */
1435
1436         sk_hdr = nt_alloc_regf_space(regf, size, &sk_off);
1437         sec->sk_hdr = sk_hdr;
1438
1439         if (!sk_hdr) return 0;
1440
1441         /* Now, lay out the sec_desc in the space provided */
1442
1443         sk_hdr->SK_ID = str_to_dword("sk");
1444
1445         /* 
1446          * We can't deal with the next and prev offset in the SK_HDRs until the
1447          * whole tree has been stored, then we can go and deal with them
1448          */
1449
1450         sk_hdr->ref_cnt = sec->ref_cnt;
1451         sk_hdr->rec_size = size;       /* Is this correct */
1452
1453         /* Now, lay out the sec_desc */
1454
1455         if (!nt_store_sec_desc(regf, sec->sec_desc, (char *)&sk_hdr->sec_desc))
1456                 return 0;
1457
1458         return sk_off;
1459
1460 }
1461
1462 #if 0
1463
1464 /*
1465  * Store a KEY in the file ...
1466  *
1467  * We store this depth first, and defer storing the lf struct until
1468  * all the sub-keys have been stored.
1469  * 
1470  * We store the NK hdr, any SK header, class name, and VK structure, then
1471  * recurse down the LF structures ... 
1472  * 
1473  * We return the offset of the NK struct
1474  * FIXME, FIXME, FIXME: Convert to using SIVAL and SSVAL ...
1475  */
1476 static int nt_store_reg_key(REG_HANDLE *regf, REG_KEY *key)
1477 {
1478         NK_HDR *nk_hdr; 
1479         unsigned int nk_off, sk_off, size;
1480
1481         if (!regf || !key) return 0;
1482
1483         size = sizeof(NK_HDR) + strlen(key->name) - 1;
1484         nk_hdr = nt_alloc_regf_space(regf, size, &nk_off);
1485         if (!nk_hdr) goto error;
1486
1487         key->offset = nk_off;  /* We will need this later */
1488
1489         /*
1490          * Now fill in each field etc ...
1491          */
1492
1493         nk_hdr->NK_ID = str_to_dword("nk"); 
1494         if (key->type == REG_ROOT_KEY)
1495                 nk_hdr->type = 0x2C;
1496         else
1497                 nk_hdr->type = 0x20;
1498
1499         /* FIXME: Fill in the time of last update */
1500
1501         if (key->type != REG_ROOT_KEY)
1502                 nk_hdr->own_off = key->owner->offset;
1503
1504         if (key->sub_keys)
1505                 nk_hdr->subk_num = key->sub_keys->key_count;
1506
1507         /*
1508          * Now, process the Sec Desc and then store its offset
1509          */
1510
1511         sk_off = nt_store_security(regf, key->security);
1512         nk_hdr->sk_off = sk_off;
1513
1514         /*
1515          * Then, store the val list and store its offset
1516          */
1517         if (key->values) {
1518                 nk_hdr->val_cnt = key->values->val_count;
1519                 nk_hdr->val_off = nt_store_val_list(regf, key->values);
1520         }
1521         else {
1522                 nk_hdr->val_off = -1;
1523                 nk_hdr->val_cnt = 0;
1524         }
1525
1526         /*
1527          * Finally, store the subkeys, and their offsets
1528          */
1529
1530 error:
1531         return 0;
1532 }
1533 #endif
1534
1535 /*
1536  * Store the registry header ...
1537  * We actually create the registry header block and link it to the chain
1538  * of output blocks.
1539  */
1540 static REGF_HDR *nt_get_reg_header(REG_HANDLE *h) {
1541         REGF *regf = h->backend_data;
1542         HBIN_BLK *tmp = NULL;
1543
1544         tmp = (HBIN_BLK *)malloc(sizeof(HBIN_BLK));
1545
1546         memset(tmp, 0, sizeof(HBIN_BLK));
1547         tmp->type = REG_OUTBLK_HDR;
1548         tmp->size = REGF_HDR_BLKSIZ;
1549         tmp->data = malloc(REGF_HDR_BLKSIZ);
1550         if (!tmp->data) goto error;
1551
1552         memset(tmp->data, 0, REGF_HDR_BLKSIZ);  /* Make it pristine, unlike Windows */
1553         regf->blk_head = regf->blk_tail = tmp;
1554
1555         return (REGF_HDR *)tmp->data;
1556
1557 error:
1558         if (tmp) free(tmp);
1559         return NULL;
1560 }
1561
1562 static BOOL nt_close_registry (REG_HANDLE *h) 
1563 {
1564         REGF *regf = h->backend_data;
1565         if (regf->base) munmap(regf->base, regf->sbuf.st_size);
1566         regf->base = NULL;
1567         close(regf->fd);    /* Ignore the error :-) */
1568
1569         free(regf->sk_map);
1570         regf->sk_count = regf->sk_map_size = 0;
1571
1572         free(regf);
1573         return False;
1574 }
1575
1576 static BOOL nt_open_registry (REG_HANDLE *h, const char *location, BOOL try_load) 
1577 {
1578         REGF *regf = (REGF *)malloc(sizeof(REGF));
1579         REGF_HDR *regf_hdr;
1580         unsigned int regf_id, hbin_id;
1581         HBIN_HDR *hbin_hdr;
1582
1583         memset(regf, 0, sizeof(REGF));
1584         regf->mem_ctx = talloc_init("regf");
1585         regf->owner_sid_str = def_owner_sid_str;
1586         h->backend_data = regf;
1587
1588         DEBUG(5, ("Attempting to load registry file\n"));
1589
1590         /* Get the header */
1591
1592         if ((regf_hdr = nt_get_regf_hdr(h)) == NULL) {
1593                 DEBUG(0, ("Unable to get header\n"));
1594                 return False;
1595         }
1596
1597         /* Now process that header and start to read the rest in */
1598
1599         if ((regf_id = IVAL(&regf_hdr->REGF_ID,0)) != str_to_dword("regf")) {
1600                 DEBUG(0, ("Unrecognized NT registry header id: %0X, %s\n",
1601                                   regf_id, h->location));
1602                 return False;
1603         }
1604
1605         /*
1606          * Validate the header ...
1607          */
1608         if (!valid_regf_hdr(regf_hdr)) {
1609                 DEBUG(0, ("Registry file header does not validate: %s\n",
1610                                   h->location));
1611                 return False;
1612         }
1613
1614         /* Update the last mod date, and then go get the first NK record and on */
1615
1616         TTTONTTIME(regf, IVAL(&regf_hdr->tim1,0), IVAL(&regf_hdr->tim2,0));
1617
1618         /* 
1619          * The hbin hdr seems to be just uninteresting garbage. Check that
1620          * it is there, but that is all.
1621          */
1622
1623         hbin_hdr = (HBIN_HDR *)(regf->base + REGF_HDR_BLKSIZ);
1624
1625         if ((hbin_id = IVAL(&hbin_hdr->HBIN_ID,0)) != str_to_dword("hbin")) {
1626                 DEBUG(0, ("Unrecognized registry hbin hdr ID: %0X, %s\n", 
1627                                   hbin_id, h->location));
1628                 return False;
1629         } 
1630
1631         /*
1632          * Get a pointer to the first key from the hreg_hdr
1633          */
1634
1635         DEBUG(2, ("First Key: %0X\n",
1636                           IVAL(&regf_hdr->first_key, 0)));
1637
1638         regf->first_key = (NK_HDR *)LOCN(regf->base, IVAL(&regf_hdr->first_key,0));
1639         DEBUGADD(2, ("First Key Offset: %0X\n", 
1640                                  IVAL(&regf_hdr->first_key, 0)));
1641
1642         DEBUGADD(2, ("Data Block Size: %d\n",
1643                                  IVAL(&regf_hdr->dblk_size, 0)));
1644
1645         DEBUGADD(2, ("Offset to next hbin block: %0X\n",
1646                                  IVAL(&hbin_hdr->off_to_next, 0)));
1647
1648         DEBUGADD(2, ("HBIN block size: %0X\n",
1649                                  IVAL(&hbin_hdr->blk_size, 0)));
1650
1651         /*
1652          * Unmap the registry file, as we might want to read in another
1653          * tree etc.
1654          */
1655
1656         h->backend_data = regf;
1657
1658         return True;
1659 }
1660
1661 static REG_KEY *nt_get_root_key(REG_HANDLE *h) 
1662
1663         return nk_to_key(h, ((REGF *)h->backend_data)->first_key, BLK_SIZE(((REGF *)h->backend_data)->first_key), NULL);
1664 }
1665
1666 static int nt_num_subkeys(REG_KEY *k) 
1667 {
1668         REGF *regf = k->handle->backend_data;
1669         LF_HDR *lf_hdr;
1670         int lf_off;
1671         NK_HDR *nk_hdr = k->backend_data;
1672         lf_off = IVAL(&nk_hdr->lf_off,0);
1673         DEBUG(2, ("SubKey list offset: %0X\n", lf_off));
1674         if(lf_off == -1) return 0;
1675         lf_hdr = (LF_HDR *)LOCN(regf->base, lf_off);
1676
1677         return lf_num_entries(k->handle, lf_hdr, BLK_SIZE(lf_hdr));
1678 }
1679
1680 static int nt_num_values(REG_KEY *k)
1681 {
1682         NK_HDR *nk_hdr = k->backend_data;
1683         return IVAL(&nk_hdr->val_cnt,0);
1684 }
1685
1686 static REG_VAL *nt_value_by_index(REG_KEY *k, int n)
1687 {
1688         VL_TYPE *vl;
1689         int val_off, vk_off;
1690         VK_HDR *vk_hdr;
1691         REGF *regf = k->handle->backend_data;
1692         NK_HDR *nk_hdr = k->backend_data;
1693         val_off = IVAL(&nk_hdr->val_off,0);
1694         vl = (VL_TYPE *)LOCN(regf->base, val_off);
1695         DEBUG(2, ("Val List Offset: %0X\n", val_off));
1696
1697         vk_off = IVAL(&vl[n],0);
1698         vk_hdr = (VK_HDR *)LOCN(regf->base, vk_off);
1699         return vk_to_val(k, vk_hdr, BLK_SIZE(vk_hdr));
1700 }
1701
1702 static REG_KEY *nt_key_by_index(REG_KEY *k, int n)
1703 {
1704         REGF *regf = k->handle->backend_data;
1705         int lf_off;
1706         NK_HDR *nk_hdr = k->backend_data;
1707         LF_HDR *lf_hdr;
1708         lf_off = IVAL(&nk_hdr->lf_off,0);
1709         DEBUG(2, ("SubKey list offset: %0X\n", lf_off));
1710
1711         /*
1712          * No more subkeys if lf_off == -1
1713          */
1714
1715         if (lf_off != -1) {
1716                 lf_hdr = (LF_HDR *)LOCN(regf->base, lf_off);
1717                 return lf_get_entry(k, lf_hdr, BLK_SIZE(lf_hdr), n);
1718         }
1719
1720         return NULL;
1721 }
1722
1723 static REG_OPS reg_backend_nt4 = {
1724         .name = "nt4",
1725         .open_registry = nt_open_registry,
1726         .close_registry = nt_close_registry,
1727         .open_root_key = nt_get_root_key,
1728         .num_subkeys = nt_num_subkeys,
1729         .num_values = nt_num_values,
1730         .get_subkey_by_index = nt_key_by_index,
1731         .get_value_by_index = nt_value_by_index,
1732
1733         /* TODO: 
1734         .add_key
1735         .add_value
1736         .del_key
1737         .del_value
1738         .update_value
1739         */
1740 };
1741
1742 NTSTATUS reg_nt4_init(void)
1743 {
1744         return register_backend("registry", &reg_backend_nt4);
1745 }