source: trunk/include/regfio.h @ 63

Last change on this file since 63 was 61, checked in by tim, 18 years ago

various minor speedups and memory leak fixes. Added support for NONE and LINK types.
  • Property svn:keywords set to Id
File size: 7.9 KB
RevLine 
[30]1/*
2 * Branched from Samba project, Subversion repository version #6903:
3 *   http://websvn.samba.org/cgi-bin/viewcvs.cgi/trunk/source/include/regfio.h
4 *
5 * Unix SMB/CIFS implementation.
6 * Windows NT registry I/O library
7 *
[61]8 * Copyright (C) 2005-2006 Timothy D. Morgan
[30]9 * Copyright (C) 2005 Gerald (Jerry) Carter
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; version 2 of the License.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 *
24 * $Id: regfio.h 61 2006-07-18 01:56:59Z tim $
25 */
26
27/************************************************************
28 * Most of this information was obtained from
29 * http://www.wednesday.demon.co.uk/dosreg.html
30 * Thanks Nigel!
31 ***********************************************************/
32
33#ifndef _REGFIO_H
34#define _REGFIO_H
35
[31]36#include <stdlib.h>
37#include <stdio.h>
[30]38#include <stdbool.h>
[31]39#include <string.h>
[30]40#include <errno.h>
[31]41#include <time.h>
[30]42#include <fcntl.h>
43#include <sys/stat.h>
44#include <sys/types.h>
45#include <unistd.h>
46#include <assert.h>
47
48#include "smb_deps.h"
49
50/******************************************************************************/
51/* Macros */
52 
[32]53/* Registry data types */
54#define REG_NONE                       0
55#define REG_SZ                         1
56#define REG_EXPAND_SZ                  2
57#define REG_BINARY                     3
58#define REG_DWORD                      4
[54]59#define REG_DWORD_LE                   4  /* DWORD, little endian */
60#define REG_DWORD_BE                   5  /* DWORD, big endian */
[32]61#define REG_LINK                       6
62#define REG_MULTI_SZ                   7
63#define REG_RESOURCE_LIST              8
64#define REG_FULL_RESOURCE_DESCRIPTOR   9
65#define REG_RESOURCE_REQUIREMENTS_LIST 10
66/* Not a real type in the registry */
67#define REG_KEY                        255
68
69
[30]70#define REGF_BLOCKSIZE          0x1000
71#define REGF_ALLOC_BLOCK        0x1000
72
73/* header sizes for various records */
74
75#define REGF_HDR_SIZE           4
76#define HBIN_HDR_SIZE           4
77#define HBIN_HEADER_REC_SIZE    0x24
78#define REC_HDR_SIZE            2
79
80#define REGF_OFFSET_NONE        0xffffffff
81
82/* Flags for the vk records */
83
84#define VK_FLAG_NAME_PRESENT    0x0001
85#define VK_DATA_IN_OFFSET       0x80000000
86
87/* NK record macros */
88
89#define NK_TYPE_LINKKEY         0x0010
90#define NK_TYPE_NORMALKEY       0x0020
91#define NK_TYPE_ROOTKEY         0x002c
92
[54]93#define HBIN_STORE_REF(x, y) { x->hbin = y; y->ref_count++ };
94/* if the count == 0; we can clean up */
95#define HBIN_REMOVE_REF(x, y){ x->hbin = NULL; y->ref_count-- };
[30]96
97
98/* HBIN block */
99struct regf_hbin;
100typedef struct regf_hbin {
[53]101  struct regf_hbin* prev;
102  struct regf_hbin* next;
103  uint32 file_off;       /* my offset in the registry file */
104  uint32 free_off;       /* offset to free space within the hbin record */
105  uint32 free_size;      /* amount of data left in the block */
[54]106  int    ref_count;      /* how many active records are pointing to this
107                          * block (not used currently)
108                          */
[30]109       
[53]110  uint8  header[HBIN_HDR_SIZE]; /* "hbin" */
111  uint32 first_hbin_off; /* offset from first hbin block */
[54]112  uint32 block_size;     /* block size of this block is
113                          * usually a multiple of 4096Kb
114                          */
115  prs_struct ps;         /* data */
[53]116  bool dirty;            /* has this hbin block been modified? */
[30]117} REGF_HBIN;
118
119/* ??? List -- list of key offsets and hashed names for consistency */
120typedef struct {
[53]121  uint32 nk_off;
122  uint8 keycheck[sizeof(uint32)];
[30]123} REGF_HASH_REC;
124
125typedef struct {
[54]126  REGF_HBIN *hbin;       /* pointer to HBIN record (in memory) containing
127                          * this nk record
128                          */
129  uint32 hbin_off;       /* offset from beginning of this hbin block */
130  uint32 rec_size;       /* ((start_offset - end_offset) & 0xfffffff8) */
[53]131 
132  uint8 header[REC_HDR_SIZE];
133  uint16 num_keys;
134  REGF_HASH_REC *hashes;
[30]135} REGF_LF_REC;
136
137/* Key Value */
138
139typedef struct {
[54]140  REGF_HBIN *hbin;      /* pointer to HBIN record (in memory) containing
141                         * this nk record
142                         */
[53]143  uint32 hbin_off;      /* offset from beginning of this hbin block */
144  uint32 rec_size;      /* ((start_offset - end_offset) & 0xfffffff8) */
[54]145  uint32 rec_off;       /* offset stored in the value list */
[53]146 
147  uint8  header[REC_HDR_SIZE];
148  char*  valuename;
149  uint32 data_size;
150  uint32 data_off;
151  uint8* data;
152  uint32 type;
153  uint16 flag;
[30]154} REGF_VK_REC;
155
156
157/* Key Security */
158struct _regf_sk_rec;
159
160typedef struct _regf_sk_rec {
[53]161  struct _regf_sk_rec *next, *prev;
[54]162  REGF_HBIN *hbin;      /* pointer to HBIN record (in memory) containing
163                         * this nk record
164                         */
[53]165  uint32 hbin_off;      /* offset from beginning of this hbin block */
166  uint32 rec_size;      /* ((start_offset - end_offset) & 0xfffffff8) */
167 
[54]168  uint32 sk_off;        /* offset parsed from NK record used as a key
169                         * to lookup reference to this SK record
170                         */
[53]171 
172  uint8  header[REC_HDR_SIZE];
173  uint32 prev_sk_off;
174  uint32 next_sk_off;
175  uint32 ref_count;
176  uint32 size;
177  SEC_DESC *sec_desc;
[30]178} REGF_SK_REC;
179
180/* Key Name */ 
181
182typedef struct {
[54]183  REGF_HBIN *hbin;      /* pointer to HBIN record (in memory) containing
184                         * this nk record
185                         */
[53]186  uint32 hbin_off;      /* offset from beginning of this hbin block */
187  uint32 subkey_index;  /* index to next subkey record to return */
188  uint32 rec_size;      /* ((start_offset - end_offset) & 0xfffffff8) */
189 
190  /* header information */
191  uint8  header[REC_HDR_SIZE];
192  uint16 key_type;
193  NTTIME mtime;
194  uint32 parent_off;    /* back pointer in registry hive */
195  uint32 classname_off; 
196  char *classname;
197  char *keyname;
198 
199  /* max lengths */
[54]200  uint32 max_bytes_subkeyname;      /* max subkey name * 2 */
201  uint32 max_bytes_subkeyclassname; /* max subkey classname length (as if) */
202  uint32 max_bytes_valuename;       /* max valuename * 2 */
203  uint32 max_bytes_value;           /* max value data size */
[53]204 
205  /* unknowns */
[54]206  uint32 unk_index;                 /* nigel says run time index ? */
[53]207 
208  /* children */
209  uint32 num_subkeys;
210  uint32 subkeys_off;   /* hash records that point to NK records */     
211  uint32 num_values;
212  uint32 values_off;    /* value lists which point to VK records */
[54]213  uint32 sk_off;        /* offset to SK record */
[53]214 
215  /* link in the other records here */
216  REGF_LF_REC subkeys;
217  REGF_VK_REC *values;
218  REGF_SK_REC *sec_desc;
[30]219       
220} REGF_NK_REC;
221
222/* REGF block */
223 
224typedef struct {
[53]225  /* run time information */
[54]226  int fd;         /* file descriptor */
227  int open_flags; /* flags passed to the open() call */
228  void *mem_ctx;  /* memory context for run-time file access information */
229  REGF_HBIN *block_list; /* list of open hbin blocks */
[53]230 
231  /* file format information */
232 
233  uint8  header[REGF_HDR_SIZE]; /* "regf" */
[54]234  uint32 data_offset;           /* offset to record in the first (or any?)
235                                 * hbin block
236                                 */
[53]237  uint32 last_block;            /* offset to last hbin block in file */
238  uint32 checksum;              /* XOR of bytes 0x0000 - 0x01FB */
239  NTTIME mtime;
240 
[54]241  REGF_SK_REC *sec_desc_list;   /* list of security descriptors referenced
242                                 * by NK records
243                                 */
[53]244 
245  /* unknowns used to simply writing */
246  uint32 unknown1;
247  uint32 unknown2;
248  uint32 unknown3;
249  uint32 unknown4;
250  uint32 unknown5;
251  uint32 unknown6;
252} REGF_FILE;
[30]253
254
[54]255/******************************************************************************/
[30]256/* Function Declarations */
[54]257
[41]258const char*   regfio_type_val2str(unsigned int val);
259int           regfio_type_str2val(const char* str);
[32]260
[53]261char*         regfio_get_sacl(SEC_DESC *sec_desc);
262char*         regfio_get_dacl(SEC_DESC *sec_desc);
263char*         regfio_get_owner(SEC_DESC *sec_desc);
264char*         regfio_get_group(SEC_DESC *sec_desc);
265
[30]266REGF_FILE*    regfio_open( const char *filename );
267int           regfio_close( REGF_FILE *r );
268
269REGF_NK_REC*  regfio_rootkey( REGF_FILE *file );
270REGF_NK_REC*  regfio_fetch_subkey( REGF_FILE *file, REGF_NK_REC *nk );
271
272#endif  /* _REGFIO_H */
Note: See TracBrowser for help on using the repository browser.