summaryrefslogtreecommitdiff
path: root/source4/lib/registry/reg_backend_nt4
diff options
context:
space:
mode:
authorJelmer Vernooij <jelmer@samba.org>2004-04-04 16:24:08 +0000
committerGerald (Jerry) Carter <jerry@samba.org>2007-10-10 12:50:33 -0500
commitc424c2b857fe08587eb81a5c5e3625545119d1c2 (patch)
tree03505d09ccd72cdfd1218066d355e2d01d403bd0 /source4/lib/registry/reg_backend_nt4
parent3855ee0164d1c8ff3c3c4ba8a5556d8cfb6546b3 (diff)
downloadsamba-c424c2b857fe08587eb81a5c5e3625545119d1c2.tar.gz
samba-c424c2b857fe08587eb81a5c5e3625545119d1c2.tar.bz2
samba-c424c2b857fe08587eb81a5c5e3625545119d1c2.zip
r20: Add the registry library. Still needs a lot of work,
see source/lib/registry/TODO for details. (This used to be commit 7cab3a00d7b4b1d95a3bfa6b28f318b4aaa5d493)
Diffstat (limited to 'source4/lib/registry/reg_backend_nt4')
-rw-r--r--source4/lib/registry/reg_backend_nt4/reg_backend_nt4.c1745
1 files changed, 1745 insertions, 0 deletions
diff --git a/source4/lib/registry/reg_backend_nt4/reg_backend_nt4.c b/source4/lib/registry/reg_backend_nt4/reg_backend_nt4.c
new file mode 100644
index 0000000000..ef2565bda8
--- /dev/null
+++ b/source4/lib/registry/reg_backend_nt4/reg_backend_nt4.c
@@ -0,0 +1,1745 @@
+/*
+ Samba Unix/Linux SMB client utility libeditreg.c
+ Copyright (C) 2002 Richard Sharpe, rsharpe@richardsharpe.com
+ Copyright (C) 2003-2004 Jelmer Vernooij, jelmer@samba.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+/*************************************************************************
+
+ A utility to edit a Windows NT/2K etc registry file.
+
+ Many of the ideas in here come from other people and software.
+ I first looked in Wine in misc/registry.c and was also influenced by
+ http://www.wednesday.demon.co.uk/dosreg.html
+
+ Which seems to contain comments from someone else. I reproduce them here
+ incase the site above disappears. It actually comes from
+ http://home.eunet.no/~pnordahl/ntpasswd/WinReg.txt.
+
+ The goal here is to read the registry into memory, manipulate it, and then
+ write it out if it was changed by any actions of the user.
+
+The windows NT registry has 2 different blocks, where one can occur many
+times...
+
+the "regf"-Block
+================
+
+"regf" is obviously the abbreviation for "Registry file". "regf" is the
+signature of the header-block which is always 4kb in size, although only
+the first 64 bytes seem to be used and a checksum is calculated over
+the first 0x200 bytes only!
+
+Offset Size Contents
+0x00000000 D-Word ID: ASCII-"regf" = 0x66676572
+0x00000004 D-Word ???? //see struct REG_HANDLE
+0x00000008 D-Word ???? Always the same value as at 0x00000004
+0x0000000C Q-Word last modify date in WinNT date-format
+0x00000014 D-Word 1
+0x00000018 D-Word 3
+0x0000001C D-Word 0
+0x00000020 D-Word 1
+0x00000024 D-Word Offset of 1st key record
+0x00000028 D-Word Size of the data-blocks (Filesize-4kb)
+0x0000002C D-Word 1
+0x000001FC D-Word Sum of all D-Words from 0x00000000 to
+0x000001FB //XOR of all words. Nigel
+
+I have analyzed more registry files (from multiple machines running
+NT 4.0 german version) and could not find an explanation for the values
+marked with ???? the rest of the first 4kb page is not important...
+
+the "hbin"-Block
+================
+I don't know what "hbin" stands for, but this block is always a multiple
+of 4kb in size.
+
+Inside these hbin-blocks the different records are placed. The memory-
+management looks like a C-compiler heap management to me...
+
+hbin-Header
+===========
+Offset Size Contents
+0x0000 D-Word ID: ASCII-"hbin" = 0x6E696268
+0x0004 D-Word Offset from the 1st hbin-Block
+0x0008 D-Word Offset to the next hbin-Block
+0x001C D-Word Block-size
+
+The values in 0x0008 and 0x001C should be the same, so I don't know
+if they are correct or swapped...
+
+From offset 0x0020 inside a hbin-block data is stored with the following
+format:
+
+Offset Size Contents
+0x0000 D-Word Data-block size //this size must be a
+multiple of 8. Nigel
+0x0004 ???? Data
+
+If the size field is negative (bit 31 set), the corresponding block
+is free and has a size of -blocksize!
+
+That does not seem to be true. All block lengths seem to be negative!
+(Richard Sharpe)
+
+The data is stored as one record per block. Block size is a multiple
+of 4 and the last block reaches the next hbin-block, leaving no room.
+
+(That also seems incorrect, in that the block size if a multiple of 8.
+That is, the block, including the 4 byte header, is always a multiple of
+8 bytes. Richard Sharpe.)
+
+Records in the hbin-blocks
+==========================
+
+nk-Record
+
+ The nk-record can be treated as a combination of tree-record and
+ key-record of the win 95 registry.
+
+lf-Record
+
+ The lf-record is the counterpart to the RGKN-record (the
+ hash-function)
+
+vk-Record
+
+ The vk-record consists information to a single value (value key).
+
+sk-Record
+
+ sk (? Security Key ?) is the ACL of the registry.
+
+Value-Lists
+
+ The value-lists contain information about which values are inside a
+ sub-key and don't have a header.
+
+Datas
+
+ The datas of the registry are (like the value-list) stored without a
+ header.
+
+All offset-values are relative to the first hbin-block and point to the
+block-size field of the record-entry. to get the file offset, you have to add
+the header size (4kb) and the size field (4 bytes)...
+
+the nk-Record
+=============
+Offset Size Contents
+0x0000 Word ID: ASCII-"nk" = 0x6B6E
+0x0002 Word for the root-key: 0x2C, otherwise 0x20 //key symbolic links 0x10. Nigel
+0x0004 Q-Word write-date/time in windows nt notation
+0x0010 D-Word Offset of Owner/Parent key
+0x0014 D-Word number of sub-Keys
+0x001C D-Word Offset of the sub-key lf-Records
+0x0024 D-Word number of values
+0x0028 D-Word Offset of the Value-List
+0x002C D-Word Offset of the sk-Record
+
+0x0030 D-Word Offset of the Class-Name //see NK structure for the use of these fields. Nigel
+0x0044 D-Word Unused (data-trash) //some kind of run time index. Does not appear to be important. Nigel
+0x0048 Word name-length
+0x004A Word class-name length
+0x004C ???? key-name
+
+the Value-List
+==============
+Offset Size Contents
+0x0000 D-Word Offset 1st Value
+0x0004 D-Word Offset 2nd Value
+0x???? D-Word Offset nth Value
+
+To determine the number of values, you have to look at the owner-nk-record!
+
+Der vk-Record
+=============
+Offset Size Contents
+0x0000 Word ID: ASCII-"vk" = 0x6B76
+0x0002 Word name length
+0x0004 D-Word length of the data //if top bit is set when offset contains data. Nigel
+0x0008 D-Word Offset of Data
+0x000C D-Word Type of value
+0x0010 Word Flag
+0x0012 Word Unused (data-trash)
+0x0014 ???? Name
+
+If bit 0 of the flag-word is set, a name is present, otherwise the value has no name (=default)
+
+If the data-size is lower 5, the data-offset value is used to store the data itself!
+
+The data-types
+==============
+Wert Beteutung
+0x0001 RegSZ: character string (in UNICODE!)
+0x0002 ExpandSZ: string with "%var%" expanding (UNICODE!)
+0x0003 RegBin: raw-binary value
+0x0004 RegDWord: Dword
+0x0007 RegMultiSZ: multiple strings, seperated with 0
+ (UNICODE!)
+
+The "lf"-record
+===============
+Offset Size Contents
+0x0000 Word ID: ASCII-"lf" = 0x666C
+0x0002 Word number of keys
+0x0004 ???? Hash-Records
+
+Hash-Record
+===========
+Offset Size Contents
+0x0000 D-Word Offset of corresponding "nk"-Record
+0x0004 D-Word ASCII: the first 4 characters of the key-name, padded with 0's. Case sensitiv!
+
+Keep in mind, that the value at 0x0004 is used for checking the data-consistency! If you change the
+key-name you have to change the hash-value too!
+
+//These hashrecords must be sorted low to high within the lf record. Nigel.
+
+The "sk"-block
+==============
+(due to the complexity of the SAM-info, not clear jet)
+(This is just a self-relative security descriptor in the data. R Sharpe.)
+
+
+Offset Size Contents
+0x0000 Word ID: ASCII-"sk" = 0x6B73
+0x0002 Word Unused
+0x0004 D-Word Offset of previous "sk"-Record
+0x0008 D-Word Offset of next "sk"-Record
+0x000C D-Word usage-counter
+0x0010 D-Word Size of "sk"-record in bytes
+???? //standard self
+relative security desciptor. Nigel
+???? ???? Security and auditing settings...
+????
+
+The usage counter counts the number of references to this
+"sk"-record. You can use one "sk"-record for the entire registry!
+
+Windows nt date/time format
+===========================
+The time-format is a 64-bit integer which is incremented every
+0,0000001 seconds by 1 (I don't know how accurate it realy is!)
+It starts with 0 at the 1st of january 1601 0:00! All values are
+stored in GMT time! The time-zone is important to get the real
+time!
+
+Common values for win95 and win-nt
+==================================
+Offset values marking an "end of list", are either 0 or -1 (0xFFFFFFFF).
+If a value has no name (length=0, flag(bit 0)=0), it is treated as the
+"Default" entry...
+If a value has no data (length=0), it is displayed as empty.
+
+simplyfied win-3.?? registry:
+=============================
+
++-----------+
+| next rec. |---+ +----->+------------+
+| first sub | | | | Usage cnt. |
+| name | | +-->+------------+ | | length |
+| value | | | | next rec. | | | text |------->+-------+
++-----------+ | | | name rec. |--+ +------------+ | xxxxx |
+ +------------+ | | value rec. |-------->+------------+ +-------+
+ v | +------------+ | Usage cnt. |
++-----------+ | | length |
+| next rec. | | | text |------->+-------+
+| first sub |------+ +------------+ | xxxxx |
+| name | +-------+
+| value |
++-----------+
+
+Greatly simplyfied structure of the nt-registry:
+================================================
+
++---------------------------------------------------------------+
+| |
+v |
++---------+ +---------->+-----------+ +----->+---------+ |
+| "nk" | | | lf-rec. | | | nk-rec. | |
+| ID | | | # of keys | | | parent |---+
+| Date | | | 1st key |--+ | .... |
+| parent | | +-----------+ +---------+
+| suk-keys|-----+
+| values |--------------------->+----------+
+| SK-rec. |---------------+ | 1. value |--> +----------+
+| class |--+ | +----------+ | vk-rec. |
++---------+ | | | .... |
+ v | | data |--> +-------+
+ +------------+ | +----------+ | xxxxx |
+ | Class name | | +-------+
+ +------------+ |
+ v
+ +---------+ +---------+
+ +----->| next sk |--->| Next sk |--+
+ | +---| prev sk |<---| prev sk | |
+ | | | .... | | ... | |
+ | | +---------+ +---------+ |
+ | | ^ |
+ | | | |
+ | +--------------------+ |
+ +----------------------------------+
+
+---------------------------------------------------------------------------
+
+Hope this helps.... (Although it was "fun" for me to uncover this things,
+ it took me several sleepless nights ;)
+
+ B.D.
+
+*************************************************************************/
+
+#include "includes.h"
+#include "lib/registry/common/registry.h"
+
+#define REG_KEY_LIST_SIZE 10
+/*FIXME*/
+
+/*
+ * Structures for dealing with the on-disk format of the registry
+ */
+
+const char *def_owner_sid_str = NULL;
+
+/*
+ * These definitions are for the in-memory registry structure.
+ * It is a tree structure that mimics what you see with tools like regedit
+ */
+
+
+/*
+ * Definition of a Key. It has a name, classname, date/time last modified,
+ * sub-keys, values, and a security descriptor
+ */
+
+#define REG_ROOT_KEY 1
+#define REG_SUB_KEY 2
+#define REG_SYM_LINK 3
+
+/*
+ * All of the structures below actually have a four-byte length before them
+ * which always seems to be negative. The following macro retrieves that
+ * size as an integer
+ */
+
+#define BLK_SIZE(b) ((int)*(int *)(((int *)b)-1))
+
+typedef unsigned int DWORD;
+typedef unsigned short WORD;
+
+typedef struct sk_struct SK_HDR;
+/*
+ * This structure keeps track of the output format of the registry
+ */
+#define REG_OUTBLK_HDR 1
+#define REG_OUTBLK_HBIN 2
+
+typedef struct regf_block {
+ DWORD REGF_ID; /* regf */
+ DWORD uk1;
+ DWORD uk2;
+ DWORD tim1, tim2;
+ DWORD uk3; /* 1 */
+ DWORD uk4; /* 3 */
+ DWORD uk5; /* 0 */
+ DWORD uk6; /* 1 */
+ DWORD first_key; /* offset */
+ unsigned int dblk_size;
+ DWORD uk7[116]; /* 1 */
+ DWORD chksum;
+} REGF_HDR;
+
+typedef struct hbin_sub_struct {
+ DWORD dblocksize;
+ char data[1];
+} HBIN_SUB_HDR;
+
+typedef struct hbin_struct {
+ DWORD HBIN_ID; /* hbin */
+ DWORD off_from_first;
+ DWORD off_to_next;
+ DWORD uk1;
+ DWORD uk2;
+ DWORD uk3;
+ DWORD uk4;
+ DWORD blk_size;
+ HBIN_SUB_HDR hbin_sub_hdr;
+} HBIN_HDR;
+
+typedef struct nk_struct {
+ WORD NK_ID;
+ WORD type;
+ DWORD t1, t2;
+ DWORD uk1;
+ DWORD own_off;
+ DWORD subk_num;
+ DWORD uk2;
+ DWORD lf_off;
+ DWORD uk3;
+ DWORD val_cnt;
+ DWORD val_off;
+ DWORD sk_off;
+ DWORD clsnam_off;
+ DWORD unk4[4];
+ DWORD unk5;
+ WORD nam_len;
+ WORD clsnam_len;
+ char key_nam[1]; /* Actual length determined by nam_len */
+} NK_HDR;
+
+struct sk_struct {
+ WORD SK_ID;
+ WORD uk1;
+ DWORD prev_off;
+ DWORD next_off;
+ DWORD ref_cnt;
+ DWORD rec_size;
+ char sec_desc[1];
+};
+
+typedef struct key_sec_desc_s {
+ struct key_sec_desc_s *prev, *next;
+ int ref_cnt;
+ int state;
+ int offset;
+ SK_HDR *sk_hdr; /* This means we must keep the registry in memory */
+ SEC_DESC *sec_desc;
+} KEY_SEC_DESC;
+
+/* A map of sk offsets in the regf to KEY_SEC_DESCs for quick lookup etc */
+typedef struct sk_map_s {
+ int sk_off;
+ KEY_SEC_DESC *key_sec_desc;
+} SK_MAP;
+
+typedef struct vk_struct {
+ WORD VK_ID;
+ WORD nam_len;
+ DWORD dat_len; /* If top-bit set, offset contains the data */
+ DWORD dat_off;
+ DWORD dat_type;
+ WORD flag; /* =1, has name, else no name (=Default). */
+ WORD unk1;
+ char dat_name[1]; /* Name starts here ... */
+} VK_HDR;
+
+typedef DWORD VL_TYPE[1]; /* Value list is an array of vk rec offsets */
+
+typedef struct hash_struct {
+ DWORD nk_off;
+ char hash[4];
+} HASH_REC;
+
+
+typedef struct lf_struct {
+ WORD LF_ID;
+ WORD key_count;
+ struct hash_struct hr[1]; /* Array of hash records, depending on key_count */} LF_HDR;
+
+
+
+/*
+ * This structure keeps track of the output format of the registry
+ */
+#define REG_OUTBLK_HDR 1
+#define REG_OUTBLK_HBIN 2
+
+typedef struct hbin_blk_s {
+ int type, size;
+ struct hbin_blk_s *next;
+ char *data; /* The data block */
+ unsigned int file_offset; /* Offset in file */
+ unsigned int free_space; /* Amount of free space in block */
+ unsigned int fsp_off; /* Start of free space in block */
+ int complete, stored;
+} HBIN_BLK;
+
+typedef struct regf_struct_s {
+ int reg_type;
+ int fd;
+ struct stat sbuf;
+ char *base;
+ int modified;
+ NTTIME last_mod_time;
+ NK_HDR *first_key;
+ int sk_count, sk_map_size;
+ SK_MAP *sk_map;
+ const char *owner_sid_str;
+ SEC_DESC *def_sec_desc;
+ /*
+ * These next pointers point to the blocks used to contain the
+ * keys when we are preparing to write them to a file
+ */
+ HBIN_BLK *blk_head, *blk_tail, *free_space;
+ TALLOC_CTX *mem_ctx;
+} REGF;
+
+DWORD str_to_dword(const char *a) {
+ int i;
+ unsigned long ret = 0;
+ for(i = strlen(a)-1; i >= 0; i--) {
+ ret = ret * 0x100 + a[i];
+ }
+ return ret;
+}
+
+#if 0
+
+/*
+ * Create an ACE
+ */
+static BOOL nt_create_ace(SEC_ACE *ace, int type, int flags, uint32 perms, const char *sid)
+{
+ DOM_SID s;
+ SEC_ACCESS access;
+ access.mask = perms;
+ if(!string_to_sid(&s, sid))return False;
+ init_sec_ace(ace, &s, type, access, flags);
+ return True;
+}
+
+/*
+ * Create a default ACL
+ */
+static SEC_ACL *nt_create_default_acl(REG_HANDLE *regf)
+{
+ SEC_ACE aces[8];
+
+ if(!nt_create_ace(&aces[0], 0x00, 0x0, 0xF003F, regf->owner_sid_str)) return NULL;
+ if(!nt_create_ace(&aces[1], 0x00, 0x0, 0xF003F, "S-1-5-18")) return NULL;
+ if(!nt_create_ace(&aces[2], 0x00, 0x0, 0xF003F, "S-1-5-32-544")) return NULL;
+ if(!nt_create_ace(&aces[3], 0x00, 0x0, 0x20019, "S-1-5-12")) return NULL;
+ if(!nt_create_ace(&aces[4], 0x00, 0x0B, GENERIC_RIGHT_ALL_ACCESS, regf->owner_sid_str)) return NULL;
+ if(!nt_create_ace(&aces[5], 0x00, 0x0B, 0x10000000, "S-1-5-18")) return NULL;
+ if(!nt_create_ace(&aces[6], 0x00, 0x0B, 0x10000000, "S-1-5-32-544")) return NULL;
+ if(!nt_create_ace(&aces[7], 0x00, 0x0B, 0x80000000, "S-1-5-12")) return NULL;
+
+ return make_sec_acl(regf->mem_ctx, 2, 8, aces);
+}
+
+/*
+ * Create a default security descriptor. We pull in things from env
+ * if need be
+ */
+static SEC_DESC *nt_create_def_sec_desc(REG_HANDLE *regf)
+{
+ SEC_DESC *tmp;
+
+ tmp = (SEC_DESC *)malloc(sizeof(SEC_DESC));
+
+ tmp->revision = 1;
+ tmp->type = SEC_DESC_SELF_RELATIVE | SEC_DESC_DACL_PRESENT;
+ if (!string_to_sid(tmp->owner_sid, "S-1-5-32-544")) goto error;
+ if (!string_to_sid(tmp->grp_sid, "S-1-5-18")) goto error;
+ tmp->sacl = NULL;
+ tmp->dacl = nt_create_default_acl(regf);
+
+ return tmp;
+
+ error:
+ if (tmp) nt_delete_sec_desc(tmp);
+ return NULL;
+}
+
+/*
+ * We will implement inheritence that is based on what the parent's SEC_DESC
+ * says, but the Owner and Group SIDs can be overwridden from the command line
+ * and additional ACEs can be applied from the command line etc.
+ */
+static KEY_SEC_DESC *nt_inherit_security(REG_KEY *key)
+{
+
+ if (!key) return NULL;
+ return key->security;
+}
+
+/*
+ * Create an initial security descriptor and init other structures, if needed
+ * We assume that the initial security stuff is empty ...
+ */
+static KEY_SEC_DESC *nt_create_init_sec(REG_HANDLE *h)
+{
+ REGF *regf = h->backend_data;
+ KEY_SEC_DESC *tsec = NULL;
+
+ tsec = (KEY_SEC_DESC *)malloc(sizeof(KEY_SEC_DESC));
+
+ tsec->ref_cnt = 1;
+ tsec->state = SEC_DESC_NBK;
+ tsec->offset = 0;
+
+ tsec->sec_desc = regf->def_sec_desc;
+
+ return tsec;
+}
+#endif
+
+/*
+ * Get the starting record for NT Registry file
+ */
+
+/*
+ * Where we keep all the regf stuff for one registry.
+ * This is the structure that we use to tie the in memory tree etc
+ * together. By keeping separate structs, we can operate on different
+ * registries at the same time.
+ * Currently, the SK_MAP is an array of mapping structure.
+ * Since we only need this on input and output, we fill in the structure
+ * as we go on input. On output, we know how many SK items we have, so
+ * we can allocate the structure as we need to.
+ * If you add stuff here that is dynamically allocated, add the
+ * appropriate free statements below.
+ */
+
+#define REG_HANDLE_REGTYPE_NONE 0
+#define REG_HANDLE_REGTYPE_NT 1
+#define REG_HANDLE_REGTYPE_W9X 2
+
+#define TTTONTTIME(r, t1, t2) (r)->last_mod_time.low = (t1); \
+ (r)->last_mod_time.high = (t2);
+
+#define REGF_HDR_BLKSIZ 0x1000
+
+#define OFF(f) ((f) + REGF_HDR_BLKSIZ + 4)
+#define LOCN(base, f) ((base) + OFF(f))
+
+/* Get the header of the registry. Return a pointer to the structure
+ * If the mmap'd area has not been allocated, then mmap the input file
+ */
+static REGF_HDR *nt_get_regf_hdr(REG_HANDLE *h)
+{
+ REGF *regf = h->backend_data;
+ SMB_REG_ASSERT(regf);
+
+ if (!regf->base) { /* Try to mmap etc the file */
+
+ if ((regf->fd = open(h->location, O_RDONLY, 0000)) <0) {
+ return NULL; /* What about errors? */
+ }
+
+ if (fstat(regf->fd, &regf->sbuf) < 0) {
+ return NULL;
+ }
+
+ regf->base = mmap(0, regf->sbuf.st_size, PROT_READ, MAP_SHARED, regf->fd, 0);
+
+ if ((int)regf->base == 1) {
+ DEBUG(0,("Could not mmap file: %s, %s\n", h->location,
+ strerror(errno)));
+ return NULL;
+ }
+ }
+
+ /*
+ * At this point, regf->base != NULL, and we should be able to read the
+ * header
+ */
+
+ SMB_REG_ASSERT(regf->base != NULL);
+
+ return (REGF_HDR *)regf->base;
+}
+
+/*
+ * Validate a regf header
+ * For now, do nothing, but we should check the checksum
+ */
+static int valid_regf_hdr(REGF_HDR *regf_hdr)
+{
+ if (!regf_hdr) return 0;
+
+ return 1;
+}
+
+#if 0
+
+/*
+ * Process an SK header ...
+ * Every time we see a new one, add it to the map. Otherwise, just look it up.
+ * We will do a simple linear search for the moment, since many KEYs have the
+ * same security descriptor.
+ * We allocate the map in increments of 10 entries.
+ */
+
+/*
+ * Create a new entry in the map, and increase the size of the map if needed
+ */
+static SK_MAP *alloc_sk_map_entry(REG_HANDLE *h, KEY_SEC_DESC *tmp, int sk_off)
+{
+ REGF *regf = h->backend_data;
+ if (!regf->sk_map) { /* Allocate a block of 10 */
+ regf->sk_map = (SK_MAP *)malloc(sizeof(SK_MAP) * 10);
+ regf->sk_map_size = 10;
+ regf->sk_count = 1;
+ (regf->sk_map)[0].sk_off = sk_off;
+ (regf->sk_map)[0].key_sec_desc = tmp;
+ }
+ else { /* Simply allocate a new slot, unless we have to expand the list */
+ int ndx = regf->sk_count;
+ if (regf->sk_count >= regf->sk_map_size) {
+ regf->sk_map = (SK_MAP *)realloc(regf->sk_map,
+ (regf->sk_map_size + 10)*sizeof(SK_MAP));
+ if (!regf->sk_map) {
+ free(tmp);
+ return NULL;
+ }
+ /*
+ * ndx already points at the first entry of the new block
+ */
+ regf->sk_map_size += 10;
+ }
+ (regf->sk_map)[ndx].sk_off = sk_off;
+ (regf->sk_map)[ndx].key_sec_desc = tmp;
+ regf->sk_count++;
+ }
+ return regf->sk_map;
+}
+
+/*
+ * Search for a KEY_SEC_DESC in the sk_map, but don't create one if not
+ * found
+ */
+KEY_SEC_DESC *lookup_sec_key(SK_MAP *sk_map, int count, int sk_off)
+{
+ int i;
+
+ if (!sk_map) return NULL;
+
+ for (i = 0; i < count; i++) {
+
+ if (sk_map[i].sk_off == sk_off)
+ return sk_map[i].key_sec_desc;
+
+ }
+
+ return NULL;
+
+}
+
+/*
+ * Allocate a KEY_SEC_DESC if we can't find one in the map
+ */
+static KEY_SEC_DESC *lookup_create_sec_key(REG_HANDLE *h, SK_MAP *sk_map, int sk_off)
+{
+ REGF *regf = h->backend_data;
+ KEY_SEC_DESC *tmp = lookup_sec_key(regf->sk_map, regf->sk_count, sk_off);
+
+ if (tmp) {
+ return tmp;
+ }
+ else { /* Allocate a new one */
+ tmp = (KEY_SEC_DESC *)malloc(sizeof(KEY_SEC_DESC));
+ memset(tmp, 0, sizeof(KEY_SEC_DESC)); /* Neatly sets offset to 0 */
+ tmp->state = SEC_DESC_RES;
+ if (!alloc_sk_map_entry(h, tmp, sk_off)) {
+ return NULL;
+ }
+ return tmp;
+ }
+}
+
+static SEC_DESC *process_sec_desc(REG_HANDLE *regf, SEC_DESC *sec_desc)
+{
+ SEC_DESC *tmp = NULL;
+
+ tmp = (SEC_DESC *)malloc(sizeof(SEC_DESC));
+
+ tmp->revision = SVAL(&sec_desc->revision,0);
+ tmp->type = SVAL(&sec_desc->type,0);
+ DEBUG(2, ("SEC_DESC Rev: %0X, Type: %0X\n", tmp->revision, tmp->type));
+ DEBUGADD(2, ("SEC_DESC Owner Off: %0X\n", IVAL(&sec_desc->off_owner_sid,0)));
+ DEBUGADD(2, ("SEC_DESC Group Off: %0X\n", IVAL(&sec_desc->off_grp_sid,0)));
+ DEBUGADD(2, ("SEC_DESC DACL Off: %0X\n", IVAL(&sec_desc->off_dacl,0)));
+ tmp->owner_sid = sid_dup_talloc(regf->mem_ctx, (DOM_SID *)((char *)sec_desc + IVAL(&sec_desc->off_owner_sid,0)));
+ if (!tmp->owner_sid) {
+ free(tmp);
+ return NULL;
+ }
+ tmp->grp_sid = sid_dup_talloc(regf->mem_ctx, (DOM_SID *)((char *)sec_desc + IVAL(&sec_desc->off_grp_sid,0)));
+ if (!tmp->grp_sid) {
+ free(tmp);
+ return NULL;
+ }
+
+ /* Now pick up the SACL and DACL */
+
+ DEBUG(0, ("%d, %d\n", IVAL(&sec_desc->off_sacl,0), IVAL(&sec_desc->off_dacl,0)));
+
+ if (sec_desc->off_sacl)
+ tmp->sacl = dup_sec_acl(regf->mem_ctx, (SEC_ACL *)((char *)sec_desc + IVAL(&sec_desc->off_sacl,0)));
+ else
+ tmp->sacl = NULL;
+
+ if (sec_desc->off_dacl)
+ tmp->dacl = dup_sec_acl(regf->mem_ctx, (SEC_ACL *)((char *)sec_desc + IVAL(&sec_desc->off_dacl,0)));
+ else
+ tmp->dacl = NULL;
+
+ return tmp;
+}
+
+static KEY_SEC_DESC *process_sk(REG_HANDLE *regf, SK_HDR *sk_hdr, int sk_off, int size)
+{
+ KEY_SEC_DESC *tmp = NULL;
+ int sk_next_off, sk_prev_off, sk_size;
+ SEC_DESC *sec_desc;
+
+ if (!sk_hdr) return NULL;
+
+ if (SVAL(&sk_hdr->SK_ID,0) != str_to_dword("sk")) {
+ DEBUG(0, ("Unrecognized SK Header ID: %08X, %s\n", (int)sk_hdr,
+ regf->regfile_name));
+ return NULL;
+ }
+
+ if (-size < (sk_size = IVAL(&sk_hdr->rec_size,0))) {
+ DEBUG(0, ("Incorrect SK record size: %d vs %d. %s\n",
+ -size, sk_size, regf->regfile_name));
+ return NULL;
+ }
+
+ /*
+ * Now, we need to look up the SK Record in the map, and return it
+ * Since the map contains the SK_OFF mapped to KEY_SEC_DESC, we can
+ * use that
+ */
+
+ if (regf->sk_map &&
+ ((tmp = lookup_sec_key(regf->sk_map, regf->sk_count, sk_off)) != NULL)
+ && (tmp->state == SEC_DESC_OCU)) {
+ tmp->ref_cnt++;
+ return tmp;
+ }
+
+ /* Here, we have an item in the map that has been reserved, or tmp==NULL. */
+
+ SMB_REG_ASSERT(tmp == NULL || (tmp && tmp->state != SEC_DESC_NON));
+
+ /*
+ * Now, allocate a KEY_SEC_DESC, and parse the structure here, and add the
+ * new KEY_SEC_DESC to the mapping structure, since the offset supplied is
+ * the actual offset of structure. The same offset will be used by
+ * all future references to this structure
+ * We could put all this unpleasantness in a function.
+ */
+
+ if (!tmp) {
+ tmp = (KEY_SEC_DESC *)malloc(sizeof(KEY_SEC_DESC));
+ memset(tmp, 0, sizeof(KEY_SEC_DESC));
+
+ /*
+ * Allocate an entry in the SK_MAP ...
+ * We don't need to free tmp, because that is done for us if the
+ * sm_map entry can't be expanded when we need more space in the map.
+ */
+
+ if (!alloc_sk_map_entry(regf, tmp, sk_off)) {
+ return NULL;
+ }
+ }
+
+ tmp->ref_cnt++;
+ tmp->state = SEC_DESC_OCU;
+
+ /*
+ * Now, process the actual sec desc and plug the values in
+ */
+
+ sec_desc = (SEC_DESC *)&sk_hdr->sec_desc[0];
+ tmp->sec_desc = process_sec_desc(regf, sec_desc);
+
+ /*
+ * Now forward and back links. Here we allocate an entry in the sk_map
+ * if it does not exist, and mark it reserved
+ */
+
+ sk_prev_off = IVAL(&sk_hdr->prev_off,0);
+ tmp->prev = lookup_create_sec_key(regf, regf->sk_map, sk_prev_off);
+ SMB_REG_ASSERT(tmp->prev != NULL);
+ sk_next_off = IVAL(&sk_hdr->next_off,0);
+ tmp->next = lookup_create_sec_key(regf, regf->sk_map, sk_next_off);
+ SMB_REG_ASSERT(tmp->next != NULL);
+
+ return tmp;
+}
+#endif
+
+/*
+ * Process a VK header and return a value
+ */
+static REG_VAL *vk_to_val(REG_KEY *parent, VK_HDR *vk_hdr, int size)
+{
+ char val_name[1024];
+ REGF *regf = parent->handle->backend_data;
+ int nam_len, dat_len, flag, dat_type, dat_off, vk_id;
+ const char *val_type;
+ REG_VAL *tmp = NULL;
+
+ if (!vk_hdr) return NULL;
+
+ if ((vk_id = SVAL(&vk_hdr->VK_ID,0)) != str_to_dword("vk")) {
+ DEBUG(0, ("Unrecognized VK header ID: %0X, block: %0X, %s\n",
+ vk_id, (int)vk_hdr, parent->handle->location));
+ return NULL;
+ }
+
+ nam_len = SVAL(&vk_hdr->nam_len,0);
+ val_name[nam_len] = '\0';
+ flag = SVAL(&vk_hdr->flag,0);
+ dat_type = IVAL(&vk_hdr->dat_type,0);
+ dat_len = IVAL(&vk_hdr->dat_len,0); /* If top bit, offset contains data */
+ dat_off = IVAL(&vk_hdr->dat_off,0);
+
+ tmp = reg_val_new(parent, NULL);
+ tmp->has_name = flag;
+ tmp->data_type = dat_type;
+
+ if (flag & 0x01) {
+ strncpy(val_name, vk_hdr->dat_name, nam_len);
+ tmp->name = strdup(val_name);
+ }
+ else
+ strncpy(val_name, "<No Name>", 10);
+
+ /*
+ * Allocate space and copy the data as a BLOB
+ */
+
+ if (dat_len&0x7FFFFFFF) {
+
+ char *dtmp = (char *)malloc(dat_len&0x7FFFFFFF);
+
+ tmp->data_blk = dtmp;
+
+ if ((dat_len&0x80000000) == 0) { /* The data is pointed to by the offset */
+ char *dat_ptr = LOCN(regf->base, dat_off);
+ memcpy(dtmp, dat_ptr, dat_len);
+ }
+ else { /* The data is in the offset or type */
+ /*
+ * FIXME.
+ * Some registry files seem to have weird fields. If top bit is set,
+ * but len is 0, the type seems to be the value ...
+ * Not sure how to handle this last type for the moment ...
+ */
+ dat_len = dat_len & 0x7FFFFFFF;
+ memcpy(dtmp, &dat_off, dat_len);
+ }
+
+ tmp->data_len = dat_len;
+ }
+
+ return tmp;
+}
+
+static BOOL vl_verify(VL_TYPE vl, int count, int size)
+{
+ if(!vl) return False;
+ if (-size < (count+1)*sizeof(int)){
+ DEBUG(0, ("Error in VL header format. Size less than space required. %d\n", -size));
+ return False;
+ }
+ return True;
+}
+
+static BOOL lf_verify(REG_HANDLE *h, LF_HDR *lf_hdr, int size)
+{
+ int lf_id;
+ if ((lf_id = SVAL(&lf_hdr->LF_ID,0)) != str_to_dword("lf")) {
+ DEBUG(0, ("Unrecognized LF Header format: %0X, Block: %0X, %s.\n",
+ lf_id, (int)lf_hdr, h->location));
+ return False;
+ }
+ return True;
+}
+
+static int lf_num_entries(REG_HANDLE *h, LF_HDR *lf_hdr, int size)
+{
+ int count;
+
+ if(!lf_verify(h, lf_hdr, size)) return 0;
+
+ SMB_REG_ASSERT(size < 0);
+
+ count = SVAL(&lf_hdr->key_count,0);
+ DEBUG(2, ("Key Count: %u\n", count));
+ if (count <= 0) return 0;
+
+ return count;
+}
+
+
+static REG_KEY *nk_to_key(REG_HANDLE *regf, NK_HDR *nk_hdr, int size, REG_KEY *parent);
+
+
+
+/*
+ * Process an LF Header and return a list of sub-keys
+ */
+static REG_KEY *lf_get_entry(REG_KEY *parent, LF_HDR *lf_hdr, int size, int n)
+{
+ REGF *regf = parent->handle->backend_data;
+ int count, nk_off;
+ NK_HDR *nk_hdr;
+
+ if (!lf_hdr) return NULL;
+
+ if(!lf_verify(parent->handle, lf_hdr, size)) return NULL;
+
+ SMB_REG_ASSERT(size < 0);
+
+ count = SVAL(&lf_hdr->key_count,0);
+ DEBUG(2, ("Key Count: %u\n", count));
+ if (count <= 0 || n > count) return NULL;
+
+ nk_off = IVAL(&lf_hdr->hr[n].nk_off,0);
+ DEBUG(2, ("NK Offset: %0X\n", nk_off));
+ nk_hdr = (NK_HDR *)LOCN(regf->base, nk_off);
+ return nk_to_key(parent->handle, nk_hdr, BLK_SIZE(nk_hdr), parent);
+}
+
+static REG_KEY *nk_to_key(REG_HANDLE *h, NK_HDR *nk_hdr, int size, REG_KEY *parent)
+{
+ REGF *regf = h->backend_data;
+ REG_KEY *tmp = NULL, *own;
+ int name_len, clsname_len, sk_off, own_off;
+ unsigned int nk_id;
+ SK_HDR *sk_hdr;
+ int type;
+ char key_name[1024], cls_name[1024];
+
+ if (!nk_hdr) return NULL;
+
+ if ((nk_id = SVAL(&nk_hdr->NK_ID,0)) != str_to_dword("nk")) {
+ DEBUG(0, ("Unrecognized NK Header format: %08X, Block: %0X. %s\n",
+ nk_id, (int)nk_hdr, parent->handle->location));
+ return NULL;
+ }
+
+ SMB_REG_ASSERT(size < 0);
+
+ name_len = SVAL(&nk_hdr->nam_len,0);
+ clsname_len = SVAL(&nk_hdr->clsnam_len,0);
+
+ /*
+ * The value of -size should be ge
+ * (sizeof(NK_HDR) - 1 + name_len)
+ * The -1 accounts for the fact that we included the first byte of
+ * the name in the structure. clsname_len is the length of the thing
+ * pointed to by clsnam_off
+ */
+
+ if (-size < (sizeof(NK_HDR) - 1 + name_len)) {
+ DEBUG(0, ("Incorrect NK_HDR size: %d, %0X\n", -size, (int)nk_hdr));
+ DEBUG(0, ("Sizeof NK_HDR: %d, name_len %d, clsname_len %d\n",
+ sizeof(NK_HDR), name_len, clsname_len));
+ /*return NULL;*/
+ }
+
+ DEBUG(2, ("NK HDR: Name len: %d, class name len: %d\n", name_len, clsname_len));
+
+ /* Fish out the key name and process the LF list */
+
+ SMB_REG_ASSERT(name_len < sizeof(key_name));
+
+ strncpy(key_name, nk_hdr->key_nam, name_len);
+ key_name[name_len] = '\0';
+
+ type = (SVAL(&nk_hdr->type,0)==0x2C?REG_ROOT_KEY:REG_SUB_KEY);
+ if(type == REG_ROOT_KEY && parent) {
+ DEBUG(0,("Root key encountered below root level!\n"));
+ return NULL;
+ }
+
+ if(type == REG_ROOT_KEY) tmp = reg_key_new_abs(key_name, h, nk_hdr);
+ else tmp = reg_key_new_rel(key_name, parent, nk_hdr);
+
+ DEBUG(2, ("Key name: %s\n", key_name));
+
+ /*
+ * Fish out the class name, it is in UNICODE, while the key name is
+ * ASCII :-)
+ */
+
+ if (clsname_len) { /* Just print in Ascii for now */
+ smb_ucs2_t *clsnamep;
+ int clsnam_off;
+
+ clsnam_off = IVAL(&nk_hdr->clsnam_off,0);
+ clsnamep = (smb_ucs2_t *)LOCN(regf->base, clsnam_off);
+ DEBUG(2, ("Class Name Offset: %0X\n", clsnam_off));
+
+ tmp->class_name = talloc_strdup_w(regf->mem_ctx, clsnamep);
+
+ DEBUGADD(2,(" Class Name: %s\n", cls_name));
+
+ }
+
+ /*
+ * Process the owner offset ...
+ */
+
+ own_off = IVAL(&nk_hdr->own_off,0);
+ own = (REG_KEY *)LOCN(regf->base, own_off);
+ DEBUG(2, ("Owner Offset: %0X\n", own_off));
+
+ DEBUGADD(2, (" Owner locn: %0X, Our locn: %0X\n",
+ (unsigned int)own, (unsigned int)nk_hdr));
+
+ /*
+ * We should verify that the owner field is correct ...
+ * for now, we don't worry ...
+ */
+
+ /*
+ * Also handle the SK header ...
+ */
+
+ sk_off = IVAL(&nk_hdr->sk_off,0);
+ sk_hdr = (SK_HDR *)LOCN(regf->base, sk_off);
+ DEBUG(2, ("SK Offset: %0X\n", sk_off));
+
+ if (sk_off != -1) {
+
+#if 0
+ tmp->security = process_sk(regf, sk_hdr, sk_off, BLK_SIZE(sk_hdr));
+#endif
+
+ }
+
+ return tmp;
+}
+
+/*
+ * Allocate a new hbin block, set up the header for the block etc
+ */
+static HBIN_BLK *nt_create_hbin_blk(REG_HANDLE *h, int size)
+{
+ REGF *regf = h->backend_data;
+ HBIN_BLK *tmp;
+ HBIN_HDR *hdr;
+
+ if (!regf || !size) return NULL;
+
+ /* Round size up to multiple of REGF_HDR_BLKSIZ */
+
+ size = (size + (REGF_HDR_BLKSIZ - 1)) & ~(REGF_HDR_BLKSIZ - 1);
+
+ tmp = (HBIN_BLK *)malloc(sizeof(HBIN_BLK));
+ memset(tmp, 0, sizeof(HBIN_BLK));
+
+ tmp->data = malloc(size);
+
+ memset(tmp->data, 0, size); /* Make it pristine */
+
+ tmp->size = size;
+ /*FIXMEtmp->file_offset = regf->blk_tail->file_offset + regf->blk_tail->size;*/
+
+ tmp->free_space = size - (sizeof(HBIN_HDR) - sizeof(HBIN_SUB_HDR));
+ tmp->fsp_off = size - tmp->free_space;
+
+ /*
+ * Now, build the header in the data block
+ */
+ hdr = (HBIN_HDR *)tmp->data;
+ hdr->HBIN_ID = str_to_dword("hbin");
+ hdr->off_from_first = tmp->file_offset - REGF_HDR_BLKSIZ;
+ hdr->off_to_next = tmp->size;
+ hdr->blk_size = tmp->size;
+
+ /*
+ * Now link it in
+ */
+
+ regf->blk_tail->next = tmp;
+ regf->blk_tail = tmp;
+ if (!regf->free_space) regf->free_space = tmp;
+
+ return tmp;
+}
+
+/*
+ * Allocate a unit of space ... and return a pointer as function param
+ * and the block's offset as a side effect
+ */
+static void *nt_alloc_regf_space(REG_HANDLE *h, int size, unsigned int *off)
+{
+ REGF *regf = h->backend_data;
+ int tmp = 0;
+ void *ret = NULL;
+ HBIN_BLK *blk;
+
+ if (!regf || !size || !off) return NULL;
+
+ SMB_REG_ASSERT(regf->blk_head != NULL);
+
+ /*
+ * round up size to include header and then to 8-byte boundary
+ */
+ size = (size + 4 + 7) & ~7;
+
+ /*
+ * Check if there is space, if none, grab a block
+ */
+ if (!regf->free_space) {
+ if (!nt_create_hbin_blk(h, REGF_HDR_BLKSIZ))
+ return NULL;
+ }
+
+ /*
+ * Now, chain down the list of blocks looking for free space
+ */
+
+ for (blk = regf->free_space; blk != NULL; blk = blk->next) {
+ if (blk->free_space <= size) {
+ tmp = blk->file_offset + blk->fsp_off - REGF_HDR_BLKSIZ;
+ ret = blk->data + blk->fsp_off;
+ blk->free_space -= size;
+ blk->fsp_off += size;
+
+ /* Insert the header */
+ ((HBIN_SUB_HDR *)ret)->dblocksize = -size;
+
+ /*
+ * Fix up the free space ptr
+ * If it is NULL, we fix it up next time
+ */
+
+ if (!blk->free_space)
+ regf->free_space = blk->next;
+
+ *off = tmp;
+ return (((char *)ret)+4);/* The pointer needs to be to the data struct */
+ }
+ }
+
+ /*
+ * If we got here, we need to add another block, which might be
+ * larger than one block -- deal with that later
+ */
+ if (nt_create_hbin_blk(h, REGF_HDR_BLKSIZ)) {
+ blk = regf->free_space;
+ tmp = blk->file_offset + blk->fsp_off - REGF_HDR_BLKSIZ;
+ ret = blk->data + blk->fsp_off;
+ blk->free_space -= size;
+ blk->fsp_off += size;
+
+ /* Insert the header */
+ ((HBIN_SUB_HDR *)ret)->dblocksize = -size;
+
+ /*
+ * Fix up the free space ptr
+ * If it is NULL, we fix it up next time
+ */
+
+ if (!blk->free_space)
+ regf->free_space = blk->next;
+
+ *off = tmp;
+ return (((char *)ret) + 4);/* The pointer needs to be to the data struct */
+ }
+
+ return NULL;
+}
+
+/*
+ * Store a SID at the location provided
+ */
+static int nt_store_SID(REG_HANDLE *regf, DOM_SID *sid, unsigned char *locn)
+{
+ int i;
+ unsigned char *p = locn;
+
+ if (!regf || !sid || !locn) return 0;
+
+ *p = sid->sid_rev_num; p++;
+ *p = sid->num_auths; p++;
+
+ for (i=0; i < 6; i++) {
+ *p = sid->id_auth[i]; p++;
+ }
+
+ for (i=0; i < sid->num_auths; i++) {
+ SIVAL(p, 0, sid->sub_auths[i]); p+=4;
+ }
+
+ return p - locn;
+
+}
+
+static int nt_store_ace(REG_HANDLE *regf, SEC_ACE *ace, unsigned char *locn)
+{
+ int size = 0;
+ SEC_ACE *reg_ace = (SEC_ACE *)locn;
+ unsigned char *p;
+
+ if (!regf || !ace || !locn) return 0;
+
+ reg_ace->type = ace->type;
+ reg_ace->flags = ace->flags;
+
+ /* Deal with the length when we have stored the SID */
+
+ p = (unsigned char *)&reg_ace->info.mask;
+
+ SIVAL(p, 0, ace->info.mask); p += 4;
+
+ size = nt_store_SID(regf, &ace->trustee, p);
+
+ size += 8; /* Size of the fixed header */
+
+ p = (unsigned char *)&reg_ace->size;
+
+ SSVAL(p, 0, size);
+
+ return size;
+}
+
+/*
+ * Store an ACL at the location provided
+ */
+static int nt_store_acl(REG_HANDLE *regf, SEC_ACL *acl, unsigned char *locn) {
+ int size = 0, i;
+ unsigned char *p = locn, *s;
+
+ if (!regf || !acl || !locn) return 0;
+
+ /*
+ * Now store the header and then the ACEs ...
+ */
+
+ SSVAL(p, 0, acl->revision);
+
+ p += 2; s = p; /* Save this for the size field */
+
+ p += 2;
+
+ SIVAL(p, 0, acl->num_aces);
+
+ p += 4;
+
+ for (i = 0; i < acl->num_aces; i++) {
+ size = nt_store_ace(regf, &acl->ace[i], p);
+ p += size;
+ }
+
+ size = s - locn;
+ SSVAL(s, 0, size);
+ return size;
+}
+
+/*
+ * Flatten and store the Sec Desc
+ * Windows lays out the DACL first, but since there is no SACL, it might be
+ * that first, then the owner, then the group SID. So, we do it that way
+ * too.
+ */
+static unsigned int nt_store_sec_desc(REG_HANDLE *regf, SEC_DESC *sd, char *locn)
+{
+ SEC_DESC *rsd = (SEC_DESC *)locn;
+ unsigned int size = 0, off = 0;
+
+ if (!regf || !sd || !locn) return 0;
+
+ /*
+ * Now, fill in the first two fields, then lay out the various fields
+ * as needed
+ */
+
+ rsd->revision = SEC_DESC_REVISION;
+ rsd->type = SEC_DESC_DACL_PRESENT | SEC_DESC_SELF_RELATIVE;
+
+ off = 4 * sizeof(DWORD) + 4;
+
+ if (sd->sacl){
+ size = nt_store_acl(regf, sd->sacl, (char *)(locn + off));
+ rsd->off_sacl = off;
+ }
+ else
+ rsd->off_sacl = 0;
+
+ off += size;
+
+ if (sd->dacl) {
+ rsd->off_dacl = off;
+ size = nt_store_acl(regf, sd->dacl, (char *)(locn + off));
+ }
+ else {
+ rsd->off_dacl = 0;
+ }
+
+ off += size;
+
+ /* Now the owner and group SIDs */
+
+ if (sd->owner_sid) {
+ rsd->off_owner_sid = off;
+ size = nt_store_SID(regf, sd->owner_sid, (char *)(locn + off));
+ }
+ else {
+ rsd->off_owner_sid = 0;
+ }
+
+ off += size;
+
+ if (sd->grp_sid) {
+ rsd->off_grp_sid = off;
+ size = nt_store_SID(regf, sd->grp_sid, (char *)(locn + off));
+ }
+ else {
+ rsd->off_grp_sid = 0;
+ }
+
+ off += size;
+
+ return size;
+}
+
+/*
+ * Store the security information
+ *
+ * If it has already been stored, just get its offset from record
+ * otherwise, store it and record its offset
+ */
+static unsigned int nt_store_security(REG_HANDLE *regf, KEY_SEC_DESC *sec)
+{
+ int size = 0;
+ unsigned int sk_off;
+ SK_HDR *sk_hdr;
+
+ if (sec->offset) return sec->offset;
+
+ /*
+ * OK, we don't have this one in the file yet. We must compute the
+ * size taken by the security descriptor as a self-relative SD, which
+ * means making one pass over each structure and figuring it out
+ */
+
+//FIXME size = sec_desc_size(sec->sec_desc);
+
+ /* Allocate that much space */
+
+ sk_hdr = nt_alloc_regf_space(regf, size, &sk_off);
+ sec->sk_hdr = sk_hdr;
+
+ if (!sk_hdr) return 0;
+
+ /* Now, lay out the sec_desc in the space provided */
+
+ sk_hdr->SK_ID = str_to_dword("sk");
+
+ /*
+ * We can't deal with the next and prev offset in the SK_HDRs until the
+ * whole tree has been stored, then we can go and deal with them
+ */
+
+ sk_hdr->ref_cnt = sec->ref_cnt;
+ sk_hdr->rec_size = size; /* Is this correct */
+
+ /* Now, lay out the sec_desc */
+
+ if (!nt_store_sec_desc(regf, sec->sec_desc, (char *)&sk_hdr->sec_desc))
+ return 0;
+
+ return sk_off;
+
+}
+
+#if 0
+
+/*
+ * Store a KEY in the file ...
+ *
+ * We store this depth first, and defer storing the lf struct until
+ * all the sub-keys have been stored.
+ *
+ * We store the NK hdr, any SK header, class name, and VK structure, then
+ * recurse down the LF structures ...
+ *
+ * We return the offset of the NK struct
+ * FIXME, FIXME, FIXME: Convert to using SIVAL and SSVAL ...
+ */
+static int nt_store_reg_key(REG_HANDLE *regf, REG_KEY *key)
+{
+ NK_HDR *nk_hdr;
+ unsigned int nk_off, sk_off, size;
+
+ if (!regf || !key) return 0;
+
+ size = sizeof(NK_HDR) + strlen(key->name) - 1;
+ nk_hdr = nt_alloc_regf_space(regf, size, &nk_off);
+ if (!nk_hdr) goto error;
+
+ key->offset = nk_off; /* We will need this later */
+
+ /*
+ * Now fill in each field etc ...
+ */
+
+ nk_hdr->NK_ID = str_to_dword("nk");
+ if (key->type == REG_ROOT_KEY)
+ nk_hdr->type = 0x2C;
+ else
+ nk_hdr->type = 0x20;
+
+ /* FIXME: Fill in the time of last update */
+
+ if (key->type != REG_ROOT_KEY)
+ nk_hdr->own_off = key->owner->offset;
+
+ if (key->sub_keys)
+ nk_hdr->subk_num = key->sub_keys->key_count;
+
+ /*
+ * Now, process the Sec Desc and then store its offset
+ */
+
+ sk_off = nt_store_security(regf, key->security);
+ nk_hdr->sk_off = sk_off;
+
+ /*
+ * Then, store the val list and store its offset
+ */
+ if (key->values) {
+ nk_hdr->val_cnt = key->values->val_count;
+ nk_hdr->val_off = nt_store_val_list(regf, key->values);
+ }
+ else {
+ nk_hdr->val_off = -1;
+ nk_hdr->val_cnt = 0;
+ }
+
+ /*
+ * Finally, store the subkeys, and their offsets
+ */
+
+error:
+ return 0;
+}
+#endif
+
+/*
+ * Store the registry header ...
+ * We actually create the registry header block and link it to the chain
+ * of output blocks.
+ */
+static REGF_HDR *nt_get_reg_header(REG_HANDLE *h) {
+ REGF *regf = h->backend_data;
+ HBIN_BLK *tmp = NULL;
+
+ tmp = (HBIN_BLK *)malloc(sizeof(HBIN_BLK));
+
+ memset(tmp, 0, sizeof(HBIN_BLK));
+ tmp->type = REG_OUTBLK_HDR;
+ tmp->size = REGF_HDR_BLKSIZ;
+ tmp->data = malloc(REGF_HDR_BLKSIZ);
+ if (!tmp->data) goto error;
+
+ memset(tmp->data, 0, REGF_HDR_BLKSIZ); /* Make it pristine, unlike Windows */
+ regf->blk_head = regf->blk_tail = tmp;
+
+ return (REGF_HDR *)tmp->data;
+
+error:
+ if (tmp) free(tmp);
+ return NULL;
+}
+
+static BOOL nt_close_registry (REG_HANDLE *h)
+{
+ REGF *regf = h->backend_data;
+ if (regf->base) munmap(regf->base, regf->sbuf.st_size);
+ regf->base = NULL;
+ close(regf->fd); /* Ignore the error :-) */
+
+ free(regf->sk_map);
+ regf->sk_count = regf->sk_map_size = 0;
+
+ free(regf);
+ return False;
+}
+
+static BOOL nt_open_registry (REG_HANDLE *h, const char *location, BOOL try_load)
+{
+ REGF *regf = (REGF *)malloc(sizeof(REGF));
+ REGF_HDR *regf_hdr;
+ unsigned int regf_id, hbin_id;
+ HBIN_HDR *hbin_hdr;
+
+ memset(regf, 0, sizeof(REGF));
+ regf->mem_ctx = talloc_init("regf");
+ regf->owner_sid_str = def_owner_sid_str;
+ h->backend_data = regf;
+
+ DEBUG(5, ("Attempting to load registry file\n"));
+
+ /* Get the header */
+
+ if ((regf_hdr = nt_get_regf_hdr(h)) == NULL) {
+ DEBUG(0, ("Unable to get header\n"));
+ return False;
+ }
+
+ /* Now process that header and start to read the rest in */
+
+ if ((regf_id = IVAL(&regf_hdr->REGF_ID,0)) != str_to_dword("regf")) {
+ DEBUG(0, ("Unrecognized NT registry header id: %0X, %s\n",
+ regf_id, h->location));
+ return False;
+ }
+
+ /*
+ * Validate the header ...
+ */
+ if (!valid_regf_hdr(regf_hdr)) {
+ DEBUG(0, ("Registry file header does not validate: %s\n",
+ h->location));
+ return False;
+ }
+
+ /* Update the last mod date, and then go get the first NK record and on */
+
+ TTTONTTIME(regf, IVAL(&regf_hdr->tim1,0), IVAL(&regf_hdr->tim2,0));
+
+ /*
+ * The hbin hdr seems to be just uninteresting garbage. Check that
+ * it is there, but that is all.
+ */
+
+ hbin_hdr = (HBIN_HDR *)(regf->base + REGF_HDR_BLKSIZ);
+
+ if ((hbin_id = IVAL(&hbin_hdr->HBIN_ID,0)) != str_to_dword("hbin")) {
+ DEBUG(0, ("Unrecognized registry hbin hdr ID: %0X, %s\n",
+ hbin_id, h->location));
+ return False;
+ }
+
+ /*
+ * Get a pointer to the first key from the hreg_hdr
+ */
+
+ DEBUG(2, ("First Key: %0X\n",
+ IVAL(&regf_hdr->first_key, 0)));
+
+ regf->first_key = (NK_HDR *)LOCN(regf->base, IVAL(&regf_hdr->first_key,0));
+ DEBUGADD(2, ("First Key Offset: %0X\n",
+ IVAL(&regf_hdr->first_key, 0)));
+
+ DEBUGADD(2, ("Data Block Size: %d\n",
+ IVAL(&regf_hdr->dblk_size, 0)));
+
+ DEBUGADD(2, ("Offset to next hbin block: %0X\n",
+ IVAL(&hbin_hdr->off_to_next, 0)));
+
+ DEBUGADD(2, ("HBIN block size: %0X\n",
+ IVAL(&hbin_hdr->blk_size, 0)));
+
+ /*
+ * Unmap the registry file, as we might want to read in another
+ * tree etc.
+ */
+
+ h->backend_data = regf;
+
+ return True;
+}
+
+static REG_KEY *nt_get_root_key(REG_HANDLE *h)
+{
+ return nk_to_key(h, ((REGF *)h->backend_data)->first_key, BLK_SIZE(((REGF *)h->backend_data)->first_key), NULL);
+}
+
+static int nt_num_subkeys(REG_KEY *k)
+{
+ REGF *regf = k->handle->backend_data;
+ LF_HDR *lf_hdr;
+ int lf_off;
+ NK_HDR *nk_hdr = k->backend_data;
+ lf_off = IVAL(&nk_hdr->lf_off,0);
+ DEBUG(2, ("SubKey list offset: %0X\n", lf_off));
+ if(lf_off == -1) return 0;
+ lf_hdr = (LF_HDR *)LOCN(regf->base, lf_off);
+
+ return lf_num_entries(k->handle, lf_hdr, BLK_SIZE(lf_hdr));
+}
+
+static int nt_num_values(REG_KEY *k)
+{
+ NK_HDR *nk_hdr = k->backend_data;
+ return IVAL(&nk_hdr->val_cnt,0);
+}
+
+static REG_VAL *nt_value_by_index(REG_KEY *k, int n)
+{
+ VL_TYPE *vl;
+ int val_off, vk_off;
+ VK_HDR *vk_hdr;
+ REGF *regf = k->handle->backend_data;
+ NK_HDR *nk_hdr = k->backend_data;
+ val_off = IVAL(&nk_hdr->val_off,0);
+ vl = (VL_TYPE *)LOCN(regf->base, val_off);
+ DEBUG(2, ("Val List Offset: %0X\n", val_off));
+
+ vk_off = IVAL(&vl[n],0);
+ vk_hdr = (VK_HDR *)LOCN(regf->base, vk_off);
+ return vk_to_val(k, vk_hdr, BLK_SIZE(vk_hdr));
+}
+
+static REG_KEY *nt_key_by_index(REG_KEY *k, int n)
+{
+ REGF *regf = k->handle->backend_data;
+ int lf_off;
+ NK_HDR *nk_hdr = k->backend_data;
+ LF_HDR *lf_hdr;
+ lf_off = IVAL(&nk_hdr->lf_off,0);
+ DEBUG(2, ("SubKey list offset: %0X\n", lf_off));
+
+ /*
+ * No more subkeys if lf_off == -1
+ */
+
+ if (lf_off != -1) {
+ lf_hdr = (LF_HDR *)LOCN(regf->base, lf_off);
+ return lf_get_entry(k, lf_hdr, BLK_SIZE(lf_hdr), n);
+ }
+
+ return NULL;
+}
+
+static REG_OPS reg_backend_nt4 = {
+ .name = "nt4",
+ .open_registry = nt_open_registry,
+ .close_registry = nt_close_registry,
+ .open_root_key = nt_get_root_key,
+ .num_subkeys = nt_num_subkeys,
+ .num_values = nt_num_values,
+ .get_subkey_by_index = nt_key_by_index,
+ .get_value_by_index = nt_value_by_index,
+
+ /* TODO:
+ .add_key
+ .add_value
+ .del_key
+ .del_value
+ .update_value
+ */
+};
+
+NTSTATUS reg_nt4_init(void)
+{
+ return register_backend("registry", &reg_backend_nt4);
+}