r128: Another registry update. Changes:
[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 WERROR vk_to_val(REG_KEY *parent, VK_HDR *vk_hdr, int size, REG_VAL **value)
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 WERR_INVALID_PARAM;
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 WERR_GENERAL_FAILURE;
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         *value = tmp;
947         return WERR_OK;
948 }
949
950 static BOOL vl_verify(VL_TYPE vl, int count, int size)
951 {
952         if(!vl) return False;
953         if (-size < (count+1)*sizeof(int)){
954                 DEBUG(0, ("Error in VL header format. Size less than space required. %d\n", -size));
955                 return False;
956         }
957         return True;
958 }
959
960 static WERROR lf_verify(REG_HANDLE *h, LF_HDR *lf_hdr, int size)
961 {
962         int lf_id;
963         if ((lf_id = SVAL(&lf_hdr->LF_ID,0)) != str_to_dword("lf")) {
964                 DEBUG(0, ("Unrecognized LF Header format: %0X, Block: %0X, %s.\n",
965                                   lf_id, (int)lf_hdr, h->location));
966                 return WERR_INVALID_PARAM;
967         }
968         return WERR_OK;
969 }
970
971 static WERROR lf_num_entries(REG_HANDLE *h, LF_HDR *lf_hdr, int size, int *count)
972 {
973         WERROR error;
974
975         error = lf_verify(h, lf_hdr, size);
976         if(!W_ERROR_IS_OK(error)) return error;
977
978         SMB_REG_ASSERT(size < 0);
979
980         *count = SVAL(&lf_hdr->key_count,0);
981         DEBUG(2, ("Key Count: %u\n", *count));
982         if (*count <= 0) return WERR_INVALID_PARAM;
983
984         return WERR_OK;
985 }
986
987
988 static WERROR nk_to_key(REG_HANDLE *regf, NK_HDR *nk_hdr, int size, REG_KEY *parent, REG_KEY **);
989
990
991
992 /*
993  * Process an LF Header and return a list of sub-keys
994  */
995 static WERROR lf_get_entry(REG_KEY *parent, LF_HDR *lf_hdr, int size, int n, REG_KEY **key)
996 {
997         REGF *regf = parent->handle->backend_data;
998         int count, nk_off;
999         NK_HDR *nk_hdr;
1000         WERROR error;
1001
1002         if (!lf_hdr) return WERR_INVALID_PARAM;
1003
1004         error = lf_verify(parent->handle, lf_hdr, size);
1005         if(!W_ERROR_IS_OK(error)) return error;
1006
1007         SMB_REG_ASSERT(size < 0);
1008
1009         count = SVAL(&lf_hdr->key_count,0);
1010         DEBUG(2, ("Key Count: %u\n", count));
1011         if (count <= 0) return WERR_GENERAL_FAILURE;
1012         if (n >= count) return WERR_NO_MORE_ITEMS;
1013
1014         nk_off = IVAL(&lf_hdr->hr[n].nk_off,0);
1015         DEBUG(2, ("NK Offset: %0X\n", nk_off));
1016         nk_hdr = (NK_HDR *)LOCN(regf->base, nk_off);
1017         return nk_to_key(parent->handle, nk_hdr, BLK_SIZE(nk_hdr), parent, key);
1018 }
1019
1020 static WERROR nk_to_key(REG_HANDLE *h, NK_HDR *nk_hdr, int size, REG_KEY *parent, REG_KEY **key)
1021 {
1022         REGF *regf = h->backend_data;
1023         REG_KEY *tmp = NULL, *own;
1024         int name_len, clsname_len, sk_off, own_off;
1025         unsigned int nk_id;
1026         SK_HDR *sk_hdr;
1027         int type;
1028         char key_name[1024], cls_name[1024];
1029
1030         if (!nk_hdr) return WERR_INVALID_PARAM;
1031
1032         if ((nk_id = SVAL(&nk_hdr->NK_ID,0)) != str_to_dword("nk")) {
1033                 DEBUG(0, ("Unrecognized NK Header format: %08X, Block: %0X. %s\n", 
1034                                   nk_id, (int)nk_hdr, parent->handle->location));
1035                 return WERR_INVALID_PARAM;
1036         }
1037
1038         SMB_REG_ASSERT(size < 0);
1039
1040         name_len = SVAL(&nk_hdr->nam_len,0);
1041         clsname_len = SVAL(&nk_hdr->clsnam_len,0);
1042
1043         /*
1044          * The value of -size should be ge 
1045          * (sizeof(NK_HDR) - 1 + name_len)
1046          * The -1 accounts for the fact that we included the first byte of 
1047          * the name in the structure. clsname_len is the length of the thing 
1048          * pointed to by clsnam_off
1049          */
1050
1051         if (-size < (sizeof(NK_HDR) - 1 + name_len)) {
1052                 DEBUG(0, ("Incorrect NK_HDR size: %d, %0X\n", -size, (int)nk_hdr));
1053                 DEBUG(0, ("Sizeof NK_HDR: %d, name_len %d, clsname_len %d\n",
1054                                   sizeof(NK_HDR), name_len, clsname_len));
1055                 return WERR_GENERAL_FAILURE;
1056         }
1057
1058         DEBUG(2, ("NK HDR: Name len: %d, class name len: %d\n", name_len, clsname_len));
1059
1060         /* Fish out the key name and process the LF list */
1061
1062         SMB_REG_ASSERT(name_len < sizeof(key_name));
1063
1064         strncpy(key_name, nk_hdr->key_nam, name_len);
1065         key_name[name_len] = '\0';
1066
1067         type = (SVAL(&nk_hdr->type,0)==0x2C?REG_ROOT_KEY:REG_SUB_KEY);
1068         if(type == REG_ROOT_KEY && parent) {
1069                 DEBUG(0,("Root key encountered below root level!\n"));
1070                 return WERR_GENERAL_FAILURE;
1071         }
1072
1073         if(type == REG_ROOT_KEY) tmp = reg_key_new_abs(key_name, h, nk_hdr);
1074         else tmp = reg_key_new_rel(key_name, parent, nk_hdr);
1075
1076         DEBUG(2, ("Key name: %s\n", key_name));
1077
1078         /*
1079          * Fish out the class name, it is in UNICODE, while the key name is 
1080          * ASCII :-)
1081          */
1082
1083         if (clsname_len) { /* Just print in Ascii for now */
1084                 smb_ucs2_t *clsnamep;
1085                 int clsnam_off;
1086
1087                 clsnam_off = IVAL(&nk_hdr->clsnam_off,0);
1088                 clsnamep = (smb_ucs2_t *)LOCN(regf->base, clsnam_off);
1089                 DEBUG(2, ("Class Name Offset: %0X\n", clsnam_off));
1090
1091                 tmp->class_name = talloc_strdup_w(regf->mem_ctx, clsnamep);
1092
1093                 DEBUGADD(2,("  Class Name: %s\n", cls_name));
1094
1095         }
1096
1097         /*
1098          * Process the owner offset ...
1099          */
1100
1101         own_off = IVAL(&nk_hdr->own_off,0);
1102         own = (REG_KEY *)LOCN(regf->base, own_off);
1103         DEBUG(2, ("Owner Offset: %0X\n", own_off));
1104
1105         DEBUGADD(2, ("  Owner locn: %0X, Our locn: %0X\n", 
1106                                  (unsigned int)own, (unsigned int)nk_hdr));
1107
1108         /* 
1109          * We should verify that the owner field is correct ...
1110          * for now, we don't worry ...
1111          */
1112
1113         /* 
1114          * Also handle the SK header ...
1115          */
1116
1117         sk_off = IVAL(&nk_hdr->sk_off,0);
1118         sk_hdr = (SK_HDR *)LOCN(regf->base, sk_off);
1119         DEBUG(2, ("SK Offset: %0X\n", sk_off));
1120
1121         if (sk_off != -1) {
1122
1123 #if 0
1124                 tmp->security = process_sk(regf, sk_hdr, sk_off, BLK_SIZE(sk_hdr));
1125 #endif
1126
1127         } 
1128
1129         *key = tmp;
1130         return WERR_OK;
1131 }
1132
1133 /*
1134  * Allocate a new hbin block, set up the header for the block etc 
1135  */
1136 static HBIN_BLK *nt_create_hbin_blk(REG_HANDLE *h, int size)
1137 {
1138         REGF *regf = h->backend_data;
1139         HBIN_BLK *tmp;
1140         HBIN_HDR *hdr;
1141
1142         if (!regf || !size) return NULL;
1143
1144         /* Round size up to multiple of REGF_HDR_BLKSIZ */
1145
1146         size = (size + (REGF_HDR_BLKSIZ - 1)) & ~(REGF_HDR_BLKSIZ - 1);
1147
1148         tmp = (HBIN_BLK *)malloc(sizeof(HBIN_BLK));
1149         memset(tmp, 0, sizeof(HBIN_BLK));
1150
1151         tmp->data = malloc(size);
1152
1153         memset(tmp->data, 0, size);  /* Make it pristine */
1154
1155         tmp->size = size;
1156         /*FIXMEtmp->file_offset = regf->blk_tail->file_offset + regf->blk_tail->size;*/
1157
1158         tmp->free_space = size - (sizeof(HBIN_HDR) - sizeof(HBIN_SUB_HDR));
1159         tmp->fsp_off = size - tmp->free_space;
1160
1161         /* 
1162          * Now, build the header in the data block 
1163          */
1164         hdr = (HBIN_HDR *)tmp->data;
1165         hdr->HBIN_ID = str_to_dword("hbin");
1166         hdr->off_from_first = tmp->file_offset - REGF_HDR_BLKSIZ;
1167         hdr->off_to_next = tmp->size;
1168         hdr->blk_size = tmp->size;
1169
1170         /*
1171          * Now link it in
1172          */
1173
1174         regf->blk_tail->next = tmp;
1175         regf->blk_tail = tmp;
1176         if (!regf->free_space) regf->free_space = tmp;
1177
1178         return tmp;
1179 }
1180
1181 /*
1182  * Allocate a unit of space ... and return a pointer as function param
1183  * and the block's offset as a side effect
1184  */
1185 static void *nt_alloc_regf_space(REG_HANDLE *h, int size, unsigned int *off)
1186 {
1187         REGF *regf = h->backend_data;
1188         int tmp = 0;
1189         void *ret = NULL;
1190         HBIN_BLK *blk;
1191
1192         if (!regf || !size || !off) return NULL;
1193
1194         SMB_REG_ASSERT(regf->blk_head != NULL);
1195
1196         /*
1197          * round up size to include header and then to 8-byte boundary
1198          */
1199         size = (size + 4 + 7) & ~7;
1200
1201         /*
1202          * Check if there is space, if none, grab a block
1203          */
1204         if (!regf->free_space) {
1205                 if (!nt_create_hbin_blk(h, REGF_HDR_BLKSIZ))
1206                         return NULL;
1207         }
1208
1209         /*
1210          * Now, chain down the list of blocks looking for free space
1211          */
1212
1213         for (blk = regf->free_space; blk != NULL; blk = blk->next) {
1214                 if (blk->free_space <= size) {
1215                         tmp = blk->file_offset + blk->fsp_off - REGF_HDR_BLKSIZ;
1216                         ret = blk->data + blk->fsp_off;
1217                         blk->free_space -= size;
1218                         blk->fsp_off += size;
1219
1220                         /* Insert the header */
1221                         ((HBIN_SUB_HDR *)ret)->dblocksize = -size;
1222
1223                         /*
1224                          * Fix up the free space ptr
1225                          * If it is NULL, we fix it up next time
1226                          */
1227
1228                         if (!blk->free_space) 
1229                                 regf->free_space = blk->next;
1230
1231                         *off = tmp;
1232                         return (((char *)ret)+4);/* The pointer needs to be to the data struct */
1233                 }
1234         }
1235
1236         /*
1237          * If we got here, we need to add another block, which might be 
1238          * larger than one block -- deal with that later
1239          */
1240         if (nt_create_hbin_blk(h, REGF_HDR_BLKSIZ)) {
1241                 blk = regf->free_space;
1242                 tmp = blk->file_offset + blk->fsp_off - REGF_HDR_BLKSIZ;
1243                 ret = blk->data + blk->fsp_off;
1244                 blk->free_space -= size;
1245                 blk->fsp_off += size;
1246
1247                 /* Insert the header */
1248                 ((HBIN_SUB_HDR *)ret)->dblocksize = -size;
1249
1250                 /*
1251                  * Fix up the free space ptr
1252                  * If it is NULL, we fix it up next time
1253                  */
1254
1255                 if (!blk->free_space) 
1256                         regf->free_space = blk->next;
1257
1258                 *off = tmp;
1259                 return (((char *)ret) + 4);/* The pointer needs to be to the data struct */
1260         }
1261
1262         return NULL;
1263 }
1264
1265 /*
1266  * Store a SID at the location provided
1267  */
1268 static int nt_store_SID(REG_HANDLE *regf, DOM_SID *sid, unsigned char *locn)
1269 {
1270         int i;
1271         unsigned char *p = locn;
1272
1273         if (!regf || !sid || !locn) return 0;
1274
1275         *p = sid->sid_rev_num; p++;
1276         *p = sid->num_auths; p++;
1277
1278         for (i=0; i < 6; i++) {
1279                 *p = sid->id_auth[i]; p++;
1280         }
1281
1282         for (i=0; i < sid->num_auths; i++) {
1283                 SIVAL(p, 0, sid->sub_auths[i]); p+=4;
1284         }
1285
1286         return p - locn;
1287
1288 }
1289
1290 static int nt_store_ace(REG_HANDLE *regf, SEC_ACE *ace, unsigned char *locn)
1291 {
1292         int size = 0;
1293         SEC_ACE *reg_ace = (SEC_ACE *)locn;
1294         unsigned char *p;
1295
1296         if (!regf || !ace || !locn) return 0;
1297
1298         reg_ace->type = ace->type;
1299         reg_ace->flags = ace->flags;
1300
1301         /* Deal with the length when we have stored the SID */
1302
1303         p = (unsigned char *)&reg_ace->info.mask;
1304
1305         SIVAL(p, 0, ace->info.mask); p += 4;
1306
1307         size = nt_store_SID(regf, &ace->trustee, p);
1308
1309         size += 8; /* Size of the fixed header */
1310
1311         p = (unsigned char *)&reg_ace->size;
1312
1313         SSVAL(p, 0, size);
1314
1315         return size;
1316 }
1317
1318 /*
1319  * Store an ACL at the location provided
1320  */
1321 static int nt_store_acl(REG_HANDLE *regf, SEC_ACL *acl, unsigned char *locn) {
1322         int size = 0, i;
1323         unsigned char *p = locn, *s;
1324
1325         if (!regf || !acl || !locn) return 0;
1326
1327         /*
1328          * Now store the header and then the ACEs ...
1329          */
1330
1331         SSVAL(p, 0, acl->revision);
1332
1333         p += 2; s = p; /* Save this for the size field */
1334
1335         p += 2;
1336
1337         SIVAL(p, 0, acl->num_aces);
1338
1339         p += 4;
1340
1341         for (i = 0; i < acl->num_aces; i++) {
1342                 size = nt_store_ace(regf, &acl->ace[i], p);
1343                 p += size;
1344         }
1345
1346         size = s - locn;
1347         SSVAL(s, 0, size);
1348         return size;
1349 }
1350
1351 /*
1352  * Flatten and store the Sec Desc 
1353  * Windows lays out the DACL first, but since there is no SACL, it might be
1354  * that first, then the owner, then the group SID. So, we do it that way
1355  * too.
1356  */
1357 static unsigned int nt_store_sec_desc(REG_HANDLE *regf, SEC_DESC *sd, char *locn)
1358 {
1359         SEC_DESC *rsd = (SEC_DESC *)locn;
1360         unsigned int size = 0, off = 0;
1361
1362         if (!regf || !sd || !locn) return 0;
1363
1364         /* 
1365          * Now, fill in the first two fields, then lay out the various fields
1366          * as needed
1367          */
1368
1369         rsd->revision = SEC_DESC_REVISION;
1370         rsd->type = SEC_DESC_DACL_PRESENT | SEC_DESC_SELF_RELATIVE;  
1371
1372         off = 4 * sizeof(DWORD) + 4;
1373
1374         if (sd->sacl){
1375                 size = nt_store_acl(regf, sd->sacl, (char *)(locn + off));
1376                 rsd->off_sacl = off;
1377         }
1378         else
1379                 rsd->off_sacl = 0;
1380
1381         off += size;
1382
1383         if (sd->dacl) {
1384                 rsd->off_dacl = off;
1385                 size = nt_store_acl(regf, sd->dacl, (char *)(locn + off));
1386         }
1387         else {
1388                 rsd->off_dacl = 0;
1389         }
1390
1391         off += size;
1392
1393         /* Now the owner and group SIDs */
1394
1395         if (sd->owner_sid) {
1396                 rsd->off_owner_sid = off;
1397                 size = nt_store_SID(regf, sd->owner_sid, (char *)(locn + off));
1398         }
1399         else {
1400                 rsd->off_owner_sid = 0;
1401         }
1402
1403         off += size;
1404
1405         if (sd->grp_sid) {
1406                 rsd->off_grp_sid = off;
1407                 size = nt_store_SID(regf, sd->grp_sid, (char *)(locn + off));
1408         }
1409         else {
1410                 rsd->off_grp_sid = 0;
1411         }
1412
1413         off += size;
1414
1415         return size;
1416 }
1417
1418 /*
1419  * Store the security information
1420  *
1421  * If it has already been stored, just get its offset from record
1422  * otherwise, store it and record its offset
1423  */
1424 static unsigned int nt_store_security(REG_HANDLE *regf, KEY_SEC_DESC *sec)
1425 {
1426         int size = 0;
1427         unsigned int sk_off;
1428         SK_HDR *sk_hdr;
1429
1430         if (sec->offset) return sec->offset;
1431
1432         /*
1433          * OK, we don't have this one in the file yet. We must compute the 
1434          * size taken by the security descriptor as a self-relative SD, which
1435          * means making one pass over each structure and figuring it out
1436          */
1437
1438 //FIXME size = sec_desc_size(sec->sec_desc);
1439
1440         /* Allocate that much space */
1441
1442         sk_hdr = nt_alloc_regf_space(regf, size, &sk_off);
1443         sec->sk_hdr = sk_hdr;
1444
1445         if (!sk_hdr) return 0;
1446
1447         /* Now, lay out the sec_desc in the space provided */
1448
1449         sk_hdr->SK_ID = str_to_dword("sk");
1450
1451         /* 
1452          * We can't deal with the next and prev offset in the SK_HDRs until the
1453          * whole tree has been stored, then we can go and deal with them
1454          */
1455
1456         sk_hdr->ref_cnt = sec->ref_cnt;
1457         sk_hdr->rec_size = size;       /* Is this correct */
1458
1459         /* Now, lay out the sec_desc */
1460
1461         if (!nt_store_sec_desc(regf, sec->sec_desc, (char *)&sk_hdr->sec_desc))
1462                 return 0;
1463
1464         return sk_off;
1465
1466 }
1467
1468 #if 0
1469
1470 /*
1471  * Store a KEY in the file ...
1472  *
1473  * We store this depth first, and defer storing the lf struct until
1474  * all the sub-keys have been stored.
1475  * 
1476  * We store the NK hdr, any SK header, class name, and VK structure, then
1477  * recurse down the LF structures ... 
1478  * 
1479  * We return the offset of the NK struct
1480  * FIXME, FIXME, FIXME: Convert to using SIVAL and SSVAL ...
1481  */
1482 static int nt_store_reg_key(REG_HANDLE *regf, REG_KEY *key)
1483 {
1484         NK_HDR *nk_hdr; 
1485         unsigned int nk_off, sk_off, size;
1486
1487         if (!regf || !key) return 0;
1488
1489         size = sizeof(NK_HDR) + strlen(key->name) - 1;
1490         nk_hdr = nt_alloc_regf_space(regf, size, &nk_off);
1491         if (!nk_hdr) goto error;
1492
1493         key->offset = nk_off;  /* We will need this later */
1494
1495         /*
1496          * Now fill in each field etc ...
1497          */
1498
1499         nk_hdr->NK_ID = str_to_dword("nk"); 
1500         if (key->type == REG_ROOT_KEY)
1501                 nk_hdr->type = 0x2C;
1502         else
1503                 nk_hdr->type = 0x20;
1504
1505         /* FIXME: Fill in the time of last update */
1506
1507         if (key->type != REG_ROOT_KEY)
1508                 nk_hdr->own_off = key->owner->offset;
1509
1510         if (key->sub_keys)
1511                 nk_hdr->subk_num = key->sub_keys->key_count;
1512
1513         /*
1514          * Now, process the Sec Desc and then store its offset
1515          */
1516
1517         sk_off = nt_store_security(regf, key->security);
1518         nk_hdr->sk_off = sk_off;
1519
1520         /*
1521          * Then, store the val list and store its offset
1522          */
1523         if (key->values) {
1524                 nk_hdr->val_cnt = key->values->val_count;
1525                 nk_hdr->val_off = nt_store_val_list(regf, key->values);
1526         }
1527         else {
1528                 nk_hdr->val_off = -1;
1529                 nk_hdr->val_cnt = 0;
1530         }
1531
1532         /*
1533          * Finally, store the subkeys, and their offsets
1534          */
1535
1536 error:
1537         return 0;
1538 }
1539 #endif
1540
1541 /*
1542  * Store the registry header ...
1543  * We actually create the registry header block and link it to the chain
1544  * of output blocks.
1545  */
1546 static REGF_HDR *nt_get_reg_header(REG_HANDLE *h) {
1547         REGF *regf = h->backend_data;
1548         HBIN_BLK *tmp = NULL;
1549
1550         tmp = (HBIN_BLK *)malloc(sizeof(HBIN_BLK));
1551
1552         memset(tmp, 0, sizeof(HBIN_BLK));
1553         tmp->type = REG_OUTBLK_HDR;
1554         tmp->size = REGF_HDR_BLKSIZ;
1555         tmp->data = malloc(REGF_HDR_BLKSIZ);
1556         if (!tmp->data) goto error;
1557
1558         memset(tmp->data, 0, REGF_HDR_BLKSIZ);  /* Make it pristine, unlike Windows */
1559         regf->blk_head = regf->blk_tail = tmp;
1560
1561         return (REGF_HDR *)tmp->data;
1562
1563 error:
1564         if (tmp) free(tmp);
1565         return NULL;
1566 }
1567
1568 static WERROR nt_close_registry (REG_HANDLE *h) 
1569 {
1570         REGF *regf = h->backend_data;
1571         if (regf->base) munmap(regf->base, regf->sbuf.st_size);
1572         regf->base = NULL;
1573         close(regf->fd);    /* Ignore the error :-) */
1574
1575         free(regf->sk_map);
1576         regf->sk_count = regf->sk_map_size = 0;
1577
1578         free(regf);
1579         return WERR_OK;
1580 }
1581
1582 static WERROR nt_open_registry (REG_HANDLE *h, const char *location, const char *credentials) 
1583 {
1584         REGF *regf = (REGF *)malloc(sizeof(REGF));
1585         REGF_HDR *regf_hdr;
1586         unsigned int regf_id, hbin_id;
1587         HBIN_HDR *hbin_hdr;
1588
1589         memset(regf, 0, sizeof(REGF));
1590         regf->mem_ctx = talloc_init("regf");
1591         regf->owner_sid_str = credentials;
1592         h->backend_data = regf;
1593
1594         DEBUG(5, ("Attempting to load registry file\n"));
1595
1596         /* Get the header */
1597
1598         if ((regf_hdr = nt_get_regf_hdr(h)) == NULL) {
1599                 DEBUG(0, ("Unable to get header\n"));
1600                 return WERR_GENERAL_FAILURE;
1601         }
1602
1603         /* Now process that header and start to read the rest in */
1604
1605         if ((regf_id = IVAL(&regf_hdr->REGF_ID,0)) != str_to_dword("regf")) {
1606                 DEBUG(0, ("Unrecognized NT registry header id: %0X, %s\n",
1607                                   regf_id, h->location));
1608                 return WERR_GENERAL_FAILURE;
1609         }
1610
1611         /*
1612          * Validate the header ...
1613          */
1614         if (!valid_regf_hdr(regf_hdr)) {
1615                 DEBUG(0, ("Registry file header does not validate: %s\n",
1616                                   h->location));
1617                 return WERR_GENERAL_FAILURE;
1618         }
1619
1620         /* Update the last mod date, and then go get the first NK record and on */
1621
1622         TTTONTTIME(regf, IVAL(&regf_hdr->tim1,0), IVAL(&regf_hdr->tim2,0));
1623
1624         /* 
1625          * The hbin hdr seems to be just uninteresting garbage. Check that
1626          * it is there, but that is all.
1627          */
1628
1629         hbin_hdr = (HBIN_HDR *)(regf->base + REGF_HDR_BLKSIZ);
1630
1631         if ((hbin_id = IVAL(&hbin_hdr->HBIN_ID,0)) != str_to_dword("hbin")) {
1632                 DEBUG(0, ("Unrecognized registry hbin hdr ID: %0X, %s\n", 
1633                                   hbin_id, h->location));
1634                 return WERR_GENERAL_FAILURE;
1635         } 
1636
1637         /*
1638          * Get a pointer to the first key from the hreg_hdr
1639          */
1640
1641         DEBUG(2, ("First Key: %0X\n",
1642                           IVAL(&regf_hdr->first_key, 0)));
1643
1644         regf->first_key = (NK_HDR *)LOCN(regf->base, IVAL(&regf_hdr->first_key,0));
1645         DEBUGADD(2, ("First Key Offset: %0X\n", 
1646                                  IVAL(&regf_hdr->first_key, 0)));
1647
1648         DEBUGADD(2, ("Data Block Size: %d\n",
1649                                  IVAL(&regf_hdr->dblk_size, 0)));
1650
1651         DEBUGADD(2, ("Offset to next hbin block: %0X\n",
1652                                  IVAL(&hbin_hdr->off_to_next, 0)));
1653
1654         DEBUGADD(2, ("HBIN block size: %0X\n",
1655                                  IVAL(&hbin_hdr->blk_size, 0)));
1656
1657         /*
1658          * Unmap the registry file, as we might want to read in another
1659          * tree etc.
1660          */
1661
1662         h->backend_data = regf;
1663
1664         return WERR_OK;
1665 }
1666
1667 static WERROR nt_get_root_key(REG_HANDLE *h, REG_KEY **key) 
1668
1669         return nk_to_key(h, ((REGF *)h->backend_data)->first_key, BLK_SIZE(((REGF *)h->backend_data)->first_key), NULL, key);
1670 }
1671
1672 static WERROR nt_num_subkeys(REG_KEY *k, int *num) 
1673 {
1674         REGF *regf = k->handle->backend_data;
1675         LF_HDR *lf_hdr;
1676         int lf_off;
1677         NK_HDR *nk_hdr = k->backend_data;
1678         lf_off = IVAL(&nk_hdr->lf_off,0);
1679         DEBUG(2, ("SubKey list offset: %0X\n", lf_off));
1680         if(lf_off == -1) {
1681                 *num = 0;
1682                 return WERR_OK;
1683         }
1684         lf_hdr = (LF_HDR *)LOCN(regf->base, lf_off);
1685
1686         return lf_num_entries(k->handle, lf_hdr, BLK_SIZE(lf_hdr), num);
1687 }
1688
1689 static WERROR nt_num_values(REG_KEY *k, int *count)
1690 {
1691         NK_HDR *nk_hdr = k->backend_data;
1692         *count = IVAL(&nk_hdr->val_cnt,0);
1693         return WERR_OK;
1694 }
1695
1696 static WERROR nt_value_by_index(REG_KEY *k, int n, REG_VAL **value)
1697 {
1698         VL_TYPE *vl;
1699         int val_off, vk_off;
1700         VK_HDR *vk_hdr;
1701         REGF *regf = k->handle->backend_data;
1702         NK_HDR *nk_hdr = k->backend_data;
1703         val_off = IVAL(&nk_hdr->val_off,0);
1704         vl = (VL_TYPE *)LOCN(regf->base, val_off);
1705         DEBUG(2, ("Val List Offset: %0X\n", val_off));
1706
1707         vk_off = IVAL(&vl[n],0);
1708         vk_hdr = (VK_HDR *)LOCN(regf->base, vk_off);
1709         return vk_to_val(k, vk_hdr, BLK_SIZE(vk_hdr), value);
1710 }
1711
1712 static WERROR nt_key_by_index(REG_KEY *k, int n, REG_KEY **subkey)
1713 {
1714         REGF *regf = k->handle->backend_data;
1715         int lf_off;
1716         NK_HDR *nk_hdr = k->backend_data;
1717         LF_HDR *lf_hdr;
1718         lf_off = IVAL(&nk_hdr->lf_off,0);
1719         DEBUG(2, ("SubKey list offset: %0X\n", lf_off));
1720
1721         /*
1722          * No more subkeys if lf_off == -1
1723          */
1724
1725         if (lf_off != -1) {
1726                 lf_hdr = (LF_HDR *)LOCN(regf->base, lf_off);
1727                 return lf_get_entry(k, lf_hdr, BLK_SIZE(lf_hdr), n, subkey);
1728         }
1729
1730         return WERR_NO_MORE_ITEMS;
1731 }
1732
1733 static struct registry_ops reg_backend_nt4 = {
1734         .name = "nt4",
1735         .open_registry = nt_open_registry,
1736         .close_registry = nt_close_registry,
1737         .open_root_key = nt_get_root_key,
1738         .num_subkeys = nt_num_subkeys,
1739         .num_values = nt_num_values,
1740         .get_subkey_by_index = nt_key_by_index,
1741         .get_value_by_index = nt_value_by_index,
1742
1743         /* TODO: 
1744         .add_key
1745         .add_value
1746         .del_key
1747         .del_value
1748         .update_value
1749         */
1750 };
1751
1752 NTSTATUS reg_nt4_init(void)
1753 {
1754         return register_backend("registry", &reg_backend_nt4);
1755 }