r15356: Remove unused 'flags' argument from socket_send() and friends.
[bbaumbach/samba-autobuild/.git] / source4 / lib / registry / reg_backend_nt4.c
1 /*
2    Samba CIFS implementation
3    Registry backend for REGF files
4    Copyright (C) 2005 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 #include "includes.h"
21 #include "lib/registry/registry.h"
22 #include "system/filesys.h"
23 #include "system/time.h"
24 #include "lib/registry/tdr_regf.h"
25 #include "librpc/gen_ndr/ndr_security.h"
26
27 /* TODO:
28  *  - Return error codes that make more sense
29  *  - Locking
30  */
31
32 /*
33  * Read HBIN blocks into memory
34  */
35
36 struct regf_data {
37         int fd;
38         struct hbin_block **hbins;
39         struct regf_hdr *header;
40 };
41
42 static struct hbin_block *hbin_by_offset (const struct regf_data *data, uint32_t offset, uint32_t *rel_offset)
43 {
44         int i;
45
46         for (i = 0; data->hbins[i]; i++) {
47                 if (offset >= data->hbins[i]->offset_from_first && 
48                         offset < data->hbins[i]->offset_from_first+
49                                          data->hbins[i]->offset_to_next) {
50                         if (rel_offset)
51                                 *rel_offset = offset - data->hbins[i]->offset_from_first - 0x20;
52                         return data->hbins[i];
53                 }
54         }
55
56         return NULL;
57 }
58
59 /*
60  * Validate a regf header
61  * For now, do nothing, but we should check the checksum
62  */
63 static uint32_t regf_hdr_checksum(const uint8_t *buffer)
64 {
65         uint32_t checksum = 0, x;
66         int i;
67         
68         for (i = 0; i < 0x01FB; i+= 4) {
69                 x = IVAL(buffer, i);
70                 checksum ^= x;
71         }
72
73         return checksum;
74 }
75
76 static DATA_BLOB hbin_get(const struct regf_data *data, uint32_t offset)
77 {
78         DATA_BLOB ret;
79         struct hbin_block *hbin;
80         uint32_t rel_offset;
81         ret.data = NULL;
82         ret.length = 0;
83
84         hbin = hbin_by_offset(data, offset, &rel_offset);
85
86         if (hbin == NULL) {
87                 DEBUG(1, ("Can't find HBIN containing 0x%04x\n", offset));
88                 return ret;
89         }
90
91         ret.length = IVAL(hbin->data, rel_offset);
92         if (!(ret.length & 0x80000000)) {
93                 DEBUG(0, ("Trying to use dirty block at 0x%04x\n", offset));
94                 return ret;
95         }
96
97         /* remove high bit */
98         ret.length = (ret.length ^ 0xffffffff) + 1;
99
100         ret.length -= 4; /* 4 bytes for the length... */
101         ret.data = hbin->data + 
102                 (offset - hbin->offset_from_first - 0x20) + 4;
103         
104         return ret;
105 }
106
107 static BOOL hbin_get_tdr (struct regf_data *regf, uint32_t offset, TALLOC_CTX *ctx, tdr_pull_fn_t pull_fn, void *p)
108 {
109         struct tdr_pull pull;
110
111         ZERO_STRUCT(pull);
112
113         pull.data = hbin_get(regf, offset);
114         if (!pull.data.data) {
115                 DEBUG(1, ("Unable to get data at 0x%04x\n", offset));
116                 return False;
117         }
118         
119         if (NT_STATUS_IS_ERR(pull_fn(&pull, ctx, p))) {
120                 DEBUG(1, ("Error parsing record at 0x%04x using tdr\n", offset));
121                 return False;
122         }
123
124         return True;
125 }
126
127 /* Allocate some new data */
128 static DATA_BLOB hbin_alloc (struct regf_data *data, uint32_t size, uint32_t *offset)
129 {
130         DATA_BLOB ret;
131         uint32_t rel_offset = -1; /* Relative offset ! */
132         struct hbin_block *hbin = NULL;
133         int i;
134
135         if (size == 0)
136                 return data_blob(NULL, 0);
137
138         size += 4; /* Need to include uint32 for the length */
139
140         /* Allocate as a multiple of 8 */
141         size = (size + 7) & ~7;
142
143         ret.data = NULL;
144         ret.length = 0;
145
146         for (i = 0; (hbin = data->hbins[i]); i++) {
147                 int j;
148                 uint32_t my_size;
149                 for (j = 0; j < hbin->offset_to_next-0x20; j+= my_size) {
150                         uint32_t header = IVAL(hbin->data, j + 4);
151                         my_size = IVAL(hbin->data, j);
152
153                         if (my_size == 0x0) {
154                                 DEBUG(0, ("Invalid zero-length block! File is corrupt.\n"));
155                                 return ret;
156                         }
157
158                         if (my_size % 8 != 0) {
159                                 DEBUG(0, ("Encountered non-aligned block!\n"));
160                         }
161
162                         if (my_size & 0x80000000) { /* Used... */
163                                 my_size = (my_size ^ 0xffffffff) + 1;
164                         } else if (my_size == size) { /* exact match */
165                                 rel_offset = j;
166                                 DEBUG(4, ("Found free block of exact size %d in middle of HBIN\n", size));
167                                 break;
168                         } else if (my_size > size) { /* data will remain */
169                                 rel_offset = j;
170                                 SIVAL(hbin->data, rel_offset+size, my_size-size); 
171                                 DEBUG(4, ("Found free block of size %d (needing %d) in middle of HBIN\n", my_size, size));
172                                 break;
173                         }
174
175                         if (header == 0xffffffff &&
176                                 hbin->offset_to_next-rel_offset >= size)  {
177                                 rel_offset = j;
178
179                                 DEBUG(4, ("Found free block of size %d at end of HBIN\n", size));
180                                 /* Mark new free block size */
181                                 SIVAL(hbin->data, rel_offset+size,hbin->offset_to_next - rel_offset - size - 0x20);
182                                 SIVAL(hbin->data, rel_offset+size+0x4, 0xffffffff);
183                                 break;
184                         }
185
186                         if (header == 0xffffffff)  {
187                                 break;
188                         }
189                 }
190
191                 if (rel_offset != -1)
192                         break;
193         }
194         
195         /* No space available in previous hbins, 
196          * allocate new one */
197         if (data->hbins[i] == NULL) { 
198                 DEBUG(4, ("No space available in other HBINs for block of size %d, allocating new HBIN\n", size));
199                 data->hbins = talloc_realloc(data, data->hbins, struct hbin_block *, i+2);
200                 hbin = talloc(data->hbins, struct hbin_block);
201                 data->hbins[i] = hbin;
202                 data->hbins[i+1] = NULL;
203
204                 hbin->HBIN_ID = talloc_strdup(hbin, "hbin");
205                 hbin->offset_from_first = (i == 0?0:data->hbins[i-1]->offset_from_first+data->hbins[i-1]->offset_to_next);
206                 hbin->offset_to_next = 0x1000;
207                 hbin->unknown[0] = 0;
208                 hbin->unknown[0] = 0;
209                 unix_to_nt_time(&hbin->last_change, time(NULL));
210                 hbin->block_size = hbin->offset_to_next;
211                 hbin->data = talloc_zero_array(hbin, uint8_t, hbin->block_size - 0x20);
212
213                 rel_offset = 0x0;
214                 SIVAL(hbin->data, size, hbin->block_size - size - 0x20);
215                 SIVAL(hbin->data, size + 0x4, 0xffffffff);
216         }
217
218         /* Set size and mark as used */
219         SIVAL(hbin->data, rel_offset, size | 0x80000000);
220
221         ret.data = hbin->data + rel_offset + 0x4; /* Skip past length */
222         ret.length = size - 0x4;
223         if (offset) {
224                 uint32_t new_rel_offset;
225                 *offset = hbin->offset_from_first + rel_offset + 0x20;
226                 SMB_ASSERT(hbin_by_offset(data, *offset, &new_rel_offset) == hbin);
227                 SMB_ASSERT(new_rel_offset == rel_offset);
228         }
229
230         return ret;
231 }
232
233 /* Store a data blob. Return the offset at which it was stored */
234 static uint32_t hbin_store (struct regf_data *data, DATA_BLOB blob)
235 {
236         uint32_t ret;
237         DATA_BLOB dest = hbin_alloc(data, blob.length, &ret);
238
239         memcpy(dest.data, blob.data, blob.length);
240
241         return ret;
242 }
243
244 static uint32_t hbin_store_tdr (struct regf_data *data, tdr_push_fn_t push_fn, void *p)
245 {
246         struct tdr_push *push = talloc_zero(data, struct tdr_push);
247         uint32_t ret;
248         
249         if (NT_STATUS_IS_ERR(push_fn(push, p))) {
250                 DEBUG(0, ("Error during push\n"));
251                 return -1;
252         }
253
254         ret = hbin_store(data, push->data);
255
256         talloc_free(push);
257
258         return ret;
259 }
260
261
262 /* Free existing data */
263 static void hbin_free (struct regf_data *data, uint32_t offset)
264 {
265         uint32_t size;
266         uint32_t rel_offset;
267         struct hbin_block *hbin;
268
269         SMB_ASSERT (offset > 0);
270         
271         hbin = hbin_by_offset(data, offset, &rel_offset);
272
273         if (hbin == NULL)
274                 return;
275         
276         /* Get original size */
277         size = IVAL(hbin->data, rel_offset);
278
279         if (!(size & 0x80000000)) {
280                 DEBUG(1, ("Trying to free already freed block at 0x%04x\n", offset));
281                 return;
282         }
283
284         /* Mark block as free */
285         SIVAL(hbin->data, rel_offset, size &~ 0x80000000);
286 }
287
288 /* Store a data blob data was already stored, but hsa changed in size
289  * Will try to save it at the current location if possible, otherwise 
290  * does a free + store */
291 static uint32_t hbin_store_resize (struct regf_data *data, uint32_t orig_offset, DATA_BLOB blob)
292 {
293         uint32_t rel_offset;
294         struct hbin_block *hbin = hbin_by_offset(data, orig_offset, &rel_offset);
295         uint32_t my_size;
296         uint32_t orig_size;
297         uint32_t needed_size;
298         uint32_t possible_size;
299         int i;
300
301         SMB_ASSERT(orig_offset > 0);
302
303         if (!hbin)
304                 return hbin_store(data, blob);
305
306         /* Get original size */
307         orig_size = IVAL(hbin->data, rel_offset);
308
309         needed_size = blob.length + 4; /* Add uint32 containing length */
310         needed_size = (needed_size + 7) & ~7; /* Align */
311
312         /* Fits into current allocated block */
313         if (orig_size >= needed_size) {
314                 memcpy(hbin->data + rel_offset + 0x4, blob.data, blob.length);
315                 return orig_offset;
316         }
317
318         possible_size = orig_size;
319
320         /* Check if it can be combined with the next few free records */
321         for (i = rel_offset; 
322                  i < hbin->offset_to_next - 0x20; 
323                  i += my_size) {
324                 uint32_t header;
325                 if (IVAL(hbin->data, i) & 0x80000000) /* Used */
326                         break;
327
328                 my_size = IVAL(hbin->data, i);
329                 header = IVAL(hbin->data, i + 4);
330                 if (header == 0xffffffff) {
331                         possible_size = hbin->offset_to_next - 0x20 - rel_offset;
332                 } else if (my_size == 0x0) {
333                         DEBUG(0, ("Invalid zero-length block! File is corrupt.\n"));
334                         break;
335                 } else {
336                         possible_size += my_size;
337                 }
338
339                 if (possible_size >= blob.length) {
340                         SIVAL(hbin->data, rel_offset, possible_size);
341                         memcpy(hbin->data + rel_offset + 0x4, blob.data, blob.length);
342                         return orig_offset;
343                 }
344
345                 if (header == 0xffffffff) 
346                         break;
347         }
348
349         hbin_free(data, orig_offset);
350         return hbin_store(data, blob);
351 }
352
353 static uint32_t hbin_store_tdr_resize (struct regf_data *regf, tdr_push_fn_t push_fn, uint32_t orig_offset, void *p)
354 {
355         struct tdr_push *push = talloc_zero(regf, struct tdr_push);
356         uint32_t ret;
357         
358         if (NT_STATUS_IS_ERR(push_fn(push, p))) {
359                 DEBUG(0, ("Error during push\n"));
360                 return -1;
361         }
362
363         ret = hbin_store_resize(regf, orig_offset, push->data);
364
365         talloc_free(push);
366
367         return ret;
368 }
369
370 static WERROR regf_num_subkeys (const struct registry_key *key, uint32_t *count)
371 {
372         struct nk_block *nk = key->backend_data;
373
374         *count = nk->num_subkeys;
375         
376         return WERR_OK;
377 }
378
379 static WERROR regf_num_values (const struct registry_key *key, uint32_t *count)
380 {
381         struct nk_block *nk = key->backend_data;
382
383         *count = nk->num_values;
384
385         return WERR_OK;
386 }
387
388 static struct registry_key *regf_get_key (TALLOC_CTX *ctx, struct regf_data *regf, uint32_t offset)
389 {
390         struct registry_key *ret;
391         struct nk_block *nk;
392
393         ret = talloc_zero(ctx, struct registry_key);
394         nk = talloc(ret, struct nk_block);
395         if (!hbin_get_tdr(regf, offset, nk, (tdr_pull_fn_t)tdr_pull_nk_block, nk)) {
396                 DEBUG(0, ("Unable to find HBIN data for offset %d\n", offset));
397                 return NULL;
398         }
399
400         if (strcmp(nk->header, "nk") != 0) {
401                 DEBUG(0, ("Expected nk record, got %s\n", nk->header));
402                 talloc_free(ret);
403                 return NULL;
404         }
405
406         ret->name = talloc_steal(ret, nk->key_name);
407         ret->last_mod = nk->last_change;
408
409         if (nk->clsname_offset != -1) {
410                 DATA_BLOB data = hbin_get(regf, nk->clsname_offset);
411                 ret->class_name = talloc_strndup(ret, (char*)data.data, nk->clsname_length);
412         }
413         ret->backend_data = nk;
414
415         return ret;
416 }
417
418 static WERROR regf_get_value (TALLOC_CTX *ctx, const struct registry_key *key, int idx, struct registry_value **ret)
419 {
420         struct nk_block *nk = key->backend_data;
421         struct vk_block *vk;
422         struct regf_data *regf = key->hive->backend_data;
423         uint32_t vk_offset;
424         DATA_BLOB data;
425
426         if (idx >= nk->num_values)
427                 return WERR_NO_MORE_ITEMS;
428
429         data = hbin_get(regf, nk->values_offset);
430         if (!data.data) {
431                 DEBUG(0, ("Unable to find value list\n"));
432                 return WERR_GENERAL_FAILURE;
433         }
434
435         if (data.length < nk->num_values * 4) {
436                 DEBUG(1, ("Value counts mismatch\n"));
437         }
438
439         vk_offset = IVAL(data.data, idx * 4);
440
441         *ret = talloc_zero(ctx, struct registry_value);
442         if (!(*ret)) 
443                 return WERR_NOMEM;
444
445         vk = talloc(*ret, struct vk_block);
446         if (!vk)
447                 return WERR_NOMEM;
448         
449         if (!hbin_get_tdr(regf, vk_offset, vk, (tdr_pull_fn_t)tdr_pull_vk_block, vk)) {
450                 DEBUG(0, ("Unable to get VK block at %d\n", vk_offset));
451                 return WERR_GENERAL_FAILURE;
452         }
453
454         (*ret)->name = talloc_steal(*ret, vk->data_name);
455         (*ret)->data_type = vk->data_type;
456         if (vk->data_length & 0x80000000) { 
457                 vk->data_length &=~0x80000000;
458                 (*ret)->data.data = (uint8_t *)&vk->data_offset;
459                 (*ret)->data.length = vk->data_length;
460         } else {
461                 (*ret)->data = hbin_get(regf, vk->data_offset);
462         }
463
464         if ((*ret)->data.length < vk->data_length) {
465                 DEBUG(1, ("Read data less then indicated data length!\n"));
466         }
467         
468         return WERR_OK;
469 }
470
471 static WERROR regf_get_subkey (TALLOC_CTX *ctx, const struct registry_key *key, int idx, struct registry_key **ret)
472 {
473         DATA_BLOB data;
474         struct nk_block *nk = key->backend_data;
475         uint32_t key_off;
476
477         if (idx >= nk->num_subkeys)
478                 return WERR_NO_MORE_ITEMS;
479
480         data = hbin_get(key->hive->backend_data, nk->subkeys_offset);
481         if (!data.data) {
482                 DEBUG(0, ("Unable to find subkey list\n"));
483                 return WERR_GENERAL_FAILURE;
484         }
485
486         if (!strncmp((char *)data.data, "li", 2)) {
487                 DEBUG(4, ("Subkeys in LI list\n"));
488                 SMB_ASSERT(0);
489         } else if (!strncmp((char *)data.data, "lf", 2)) {
490                 struct lf_block lf;
491                 struct tdr_pull pull;
492
493                 DEBUG(10, ("Subkeys in LF list\n"));
494                 ZERO_STRUCT(pull);
495                 pull.data = data;
496
497                 if (NT_STATUS_IS_ERR(tdr_pull_lf_block(&pull, nk, &lf))) {
498                         DEBUG(0, ("Error parsing LF list\n"));
499                         return WERR_GENERAL_FAILURE;
500                 }
501
502                 if (lf.key_count != nk->num_subkeys) {
503                         DEBUG(0, ("Subkey counts don't match\n"));
504                         return WERR_GENERAL_FAILURE;
505                 }
506
507                 key_off = lf.hr[idx].nk_off;
508         } else if (!strncmp((char *)data.data, "ri", 2)) {
509                 DEBUG(4, ("Subkeys in RI list\n"));
510                 SMB_ASSERT(0);
511         } else if (!strncmp((char *)data.data, "lh", 2)) {
512                 DEBUG(4, ("Subkeys in LH list\n"));
513                 SMB_ASSERT(0);
514         } else {
515                 DEBUG(0, ("Unknown type for subkey list (0x%04x): %c%c\n", nk->subkeys_offset, data.data[0], data.data[1]));
516                 return WERR_GENERAL_FAILURE;
517         }
518
519         *ret = regf_get_key (ctx, key->hive->backend_data, key_off);
520
521         return WERR_OK;
522 }
523
524
525 static WERROR regf_set_sec_desc (const struct registry_key *key, const struct security_descriptor *sec_desc)
526 {
527         /* FIXME */
528         return WERR_NOT_SUPPORTED;
529 }
530
531 static WERROR regf_get_sec_desc(TALLOC_CTX *ctx, const struct registry_key *key, struct security_descriptor **sd)
532 {
533         struct nk_block *nk = key->backend_data;
534         struct sk_block sk;
535         struct regf_data *regf = key->hive->backend_data;
536         DATA_BLOB data;
537
538         if (!hbin_get_tdr(regf, nk->sk_offset, ctx, (tdr_pull_fn_t) tdr_pull_sk_block, &sk)) {
539                 DEBUG(0, ("Unable to find security descriptor\n"));
540                 return WERR_GENERAL_FAILURE;
541         }
542                 
543         if (strcmp(sk.header, "sk") != 0) {
544                 DEBUG(0, ("Expected 'sk', got '%s'\n", sk.header));
545                 return WERR_GENERAL_FAILURE;
546         }
547
548         *sd = talloc(ctx, struct security_descriptor);
549         if (!*sd)
550                 return WERR_NOMEM;
551
552         data.data = sk.sec_desc;
553         data.length = sk.rec_size;
554         if (NT_STATUS_IS_ERR(ndr_pull_struct_blob(&data, ctx, *sd, (ndr_pull_flags_fn_t)ndr_pull_security_descriptor))) {
555                 DEBUG(0, ("Error parsing security descriptor\n"));
556                 return WERR_GENERAL_FAILURE;
557         }
558
559         return WERR_OK;
560 }
561
562 static uint32_t lf_add_entry (struct regf_data *regf, uint32_t list_offset, const char *name, uint32_t key_offset)
563 {
564         uint32_t ret;
565         struct lf_block lf;
566
567         /* Add to subkeys list */
568         if (list_offset == -1) { /* Need to create subkeys list */
569                 lf.header = "lf";
570                 lf.key_count = 0;
571                 lf.hr = NULL;
572         } else {
573                 if (!hbin_get_tdr(regf, list_offset, regf, (tdr_pull_fn_t)tdr_pull_lf_block, &lf)) {
574                         DEBUG(0, ("Can't get subkeys list\n"));
575                         return -1;
576                 }
577         }
578
579         lf.hr = talloc_realloc(regf, lf.hr, struct hash_record, lf.key_count+1);
580         lf.hr[lf.key_count].nk_off = key_offset;
581         lf.hr[lf.key_count].hash = talloc_strndup(regf, name, 4);
582         lf.key_count++;
583
584         ret = hbin_store_tdr_resize(regf, (tdr_push_fn_t)tdr_push_lf_block, list_offset, &lf);
585
586         talloc_free(lf.hr);
587         
588         return ret;
589 }
590
591 static WERROR regf_del_value (const struct registry_key *parent, const char *name)
592 {
593         /* FIXME */
594         return WERR_NOT_SUPPORTED;
595 }
596
597
598 static WERROR regf_del_key (const struct registry_key *parent, const char *name)
599 {
600         struct nk_block *nk = parent->backend_data;
601
602         SMB_ASSERT(nk);
603         
604         if (nk->subkeys_offset == -1) 
605                 return WERR_BADFILE;
606
607         /* FIXME */
608
609         return WERR_NOT_SUPPORTED;
610 }
611
612 static WERROR regf_add_key (TALLOC_CTX *ctx, const struct registry_key *parent, const char *name, uint32_t access_mask, struct security_descriptor *sec_desc, struct registry_key **ret)
613 {
614         struct nk_block *parent_nk = parent->backend_data, nk;
615         struct regf_data *regf = parent->hive->backend_data;
616         uint32_t offset;
617
618         nk.header = "nk";
619         nk.type = REG_SUB_KEY;
620         unix_to_nt_time(&nk.last_change, time(NULL));
621         nk.uk1 = 0;
622         nk.parent_offset = 0; /* FIXME */
623         nk.num_subkeys = 0;
624         nk.uk2 = 0;
625         nk.subkeys_offset = -1;
626         nk.unknown_offset = -1;
627         nk.num_values = 0;
628         nk.sk_offset = 0;
629         memset(nk.unk3, 0, 5);
630         nk.clsname_offset = -1;
631         nk.clsname_length = 0;
632         nk.key_name = name;
633         
634         offset = hbin_store_tdr(regf, (tdr_push_fn_t) tdr_push_nk_block, &nk);
635
636         parent_nk->subkeys_offset = lf_add_entry(regf, parent_nk->subkeys_offset, name, nk.parent_offset);
637
638         parent_nk->num_subkeys++;
639
640         hbin_store_tdr_resize(regf, (tdr_push_fn_t) tdr_push_nk_block, nk.parent_offset, parent_nk);
641
642         *ret = regf_get_key(ctx, regf, offset);
643
644         /* FIXME: Set sec desc ! */
645         return WERR_OK;
646 }
647
648 static WERROR regf_set_value (const struct registry_key *key, const char *name, uint32_t type, const DATA_BLOB data)
649 {
650         /* FIXME */
651
652         return WERR_NOT_SUPPORTED;
653 }
654
655 #if 0 /* Unused */
656
657 static WERROR regf_save_hbin(struct registry_hive *hive, struct hbin_block *hbin)
658 {
659         struct regf_data *regf = hive->backend_data;
660
661         /* go to right offset */
662         if (lseek(regf->fd, SEEK_SET, regf->header->data_offset + hbin->offset_from_first) == -1) {
663                 DEBUG(0, ("Error lseeking in regf file\n"));
664                 return WERR_GENERAL_FAILURE;
665         }
666
667         if (NT_STATUS_IS_ERR(tdr_push_to_fd(regf->fd, (tdr_push_fn_t)tdr_push_hbin_block, hbin))) {
668                 DEBUG(0, ("Error writing HBIN block\n"));       
669                 return WERR_GENERAL_FAILURE;
670         }
671
672         return WERR_OK;
673 }
674
675 #endif
676
677 static WERROR nt_open_hive (struct registry_hive *h, struct registry_key **key)
678 {
679         struct regf_data *regf;
680         struct regf_hdr *regf_hdr;
681         struct tdr_pull pull;
682         int i;
683
684         regf = (struct regf_data *)talloc_zero(h, struct regf_data);
685         h->backend_data = regf;
686
687         DEBUG(5, ("Attempting to load registry file\n"));
688
689         /* Get the header */
690         regf->fd = open(h->location, O_RDWR);
691
692         if (regf->fd == -1) {
693                 DEBUG(0,("Could not load file: %s, %s\n", h->location,
694                                  strerror(errno)));
695                 return WERR_GENERAL_FAILURE;
696         }
697
698         ZERO_STRUCT(pull);
699         pull.data.data = (uint8_t*)fd_load(regf->fd, &pull.data.length, regf);
700
701         if (pull.data.data == NULL) {
702                 DEBUG(0, ("Error reading data\n"));
703                 return WERR_GENERAL_FAILURE;
704         }
705
706         regf_hdr = talloc(regf, struct regf_hdr);
707         if (NT_STATUS_IS_ERR(tdr_pull_regf_hdr(&pull, regf_hdr, regf_hdr))) {
708                 return WERR_GENERAL_FAILURE;
709         }
710
711         regf->header = regf_hdr;
712
713         if (strcmp(regf_hdr->REGF_ID, "regf") != 0) {
714                 DEBUG(0, ("Unrecognized NT registry header id: %s, %s\n",
715                                   regf_hdr->REGF_ID, h->location));
716         }
717
718         DEBUG(1, ("Registry '%s' read. Version %d.%d.%d.%d\n", 
719                           regf_hdr->description, regf_hdr->version.major,
720                           regf_hdr->version.minor, regf_hdr->version.release,
721                           regf_hdr->version.build));
722
723         /*
724          * Validate the header ...
725          */
726         if (regf_hdr_checksum(pull.data.data) != regf_hdr->chksum) {
727                 DEBUG(0, ("Registry file checksum error: %s: %d,%d\n",
728                                   h->location, regf_hdr->chksum, regf_hdr_checksum(pull.data.data)));
729                 return WERR_GENERAL_FAILURE;
730         }
731
732         pull.offset = 0x1000;
733
734         i = 0;
735         /* Read in all hbin blocks */
736         regf->hbins = talloc_array(regf, struct hbin_block *, 1);
737         regf->hbins[0] = NULL;
738
739         while (pull.offset < pull.data.length) {
740                 struct hbin_block *hbin = talloc(regf->hbins, struct hbin_block);
741
742                 if (NT_STATUS_IS_ERR(tdr_pull_hbin_block(&pull, hbin, hbin))) {
743                         DEBUG(0, ("[%d] Error parsing HBIN block\n", i));
744                         return WERR_FOOBAR;
745                 }
746
747                 if (strcmp(hbin->HBIN_ID, "hbin") != 0) {
748                         DEBUG(0, ("[%d] Expected 'hbin', got '%s'\n", i, hbin->HBIN_ID));
749                         return WERR_FOOBAR;
750                 }
751
752                 regf->hbins[i] = hbin;
753                 i++;
754                 regf->hbins = talloc_realloc(regf, regf->hbins, struct hbin_block *, i+2);
755                 regf->hbins[i] = NULL;
756         } 
757
758         DEBUG(1, ("%d HBIN blocks read\n", i));
759
760         *key = regf_get_key(h, regf, 0x20);
761
762         return WERR_OK;
763 }
764
765 static struct hive_operations reg_backend_nt4 = {
766         .name = "nt4",
767         .open_hive = nt_open_hive,
768         .num_subkeys = regf_num_subkeys,
769         .num_values = regf_num_values,
770         .get_subkey_by_index = regf_get_subkey,
771         .get_value_by_index = regf_get_value,
772         .key_get_sec_desc = regf_get_sec_desc,
773         .key_set_sec_desc = regf_set_sec_desc,
774         .add_key = regf_add_key,
775         .set_value = regf_set_value,
776         .del_key = regf_del_key,
777         .del_value = regf_del_value,
778 };
779
780 NTSTATUS registry_nt4_init(void)
781 {
782         return registry_register(&reg_backend_nt4);
783 }