source3/include/regfio.h

   1 /*
   2  * Unix SMB/CIFS implementation.
   3  * Windows NT registry I/O library
   4  * Copyright (c) Gerald (Jerry) Carter               2005
   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 3 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, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 /************************************************************
  21  * Most of this information was obtained from
  22  * http://www.wednesday.demon.co.uk/dosreg.html
  23  * Thanks Nigel!
  24  ***********************************************************/
  25
  26 #include "registry/reg_parse_prs.h"
  27
  28 #ifndef _REGFIO_H
  29 #define _REGFIO_H
  30
  31 struct regsubkey_ctr;
  32
  33 /* Macros */
  34
  35 #define REGF_BLOCKSIZE          0x1000
  36 #define REGF_ALLOC_BLOCK        0x1000
  37
  38 /* header sizes for various records */
  39
  40 #define REGF_HDR_SIZE           4
  41 #define HBIN_HDR_SIZE           4
  42 #define HBIN_HEADER_REC_SIZE    0x24
  43 #define REC_HDR_SIZE            2
  44
  45 #define REGF_OFFSET_NONE        0xffffffff
  46
  47 /* Flags for the vk records */
  48
  49 #define VK_FLAG_NAME_PRESENT    0x0001
  50 #define VK_DATA_IN_OFFSET       0x80000000
  51
  52 /* NK record macros */
  53
  54 #define NK_TYPE_LINKKEY         0x0010
  55 #define NK_TYPE_NORMALKEY       0x0020
  56 #define NK_TYPE_ROOTKEY         0x002c
  57
  58 #define HBIN_STORE_REF(x, y)    { x->hbin = y; y->ref_count++ };
  59 #define HBIN_REMOVE_REF(x, y)   { x->hbin = NULL; y->ref_count-- /* if the count == 0; we can clean up */ };
  60
  61
  62 /* HBIN block */
  63 struct regf_hbin;
  64 typedef struct regf_hbin {
  65         struct regf_hbin *prev, *next;
  66         uint32 file_off;                /* my offset in the registry file */
  67         uint32 free_off;                /* offset to free space within the hbin record */
  68         uint32 free_size;               /* amount of data left in the block */
  69         int ref_count;                  /* how many active records are pointing to this block (not used currently) */
  70
  71         char   header[HBIN_HDR_SIZE];   /* "hbin" */
  72         uint32 first_hbin_off;          /* offset from first hbin block */
  73         uint32 block_size;              /* block size of this blockually a multiple of 4096Kb) */
  74
  75         prs_struct ps;                  /* data */
  76
  77         bool dirty;                     /* has this hbin block been modified? */
  78 } REGF_HBIN;
  79
  80 /* ??? List -- list of key offsets and hashed names for consistency */
  81
  82 typedef struct {
  83         uint32 nk_off;
  84         uint8 keycheck[sizeof(uint32)];
  85         char *fullname;
  86 } REGF_HASH_REC;
  87
  88 typedef struct {
  89         REGF_HBIN *hbin;        /* pointer to HBIN record (in memory) containing this nk record */
  90         uint32 hbin_off;        /* offset from beginning of this hbin block */
  91         uint32 rec_size;        /* ((start_offset - end_offset) & 0xfffffff8) */
  92
  93         char header[REC_HDR_SIZE];
  94         uint16 num_keys;
  95         REGF_HASH_REC *hashes;
  96 } REGF_LF_REC;
  97
  98 /* Key Value */
  99
 100 typedef struct {
 101         REGF_HBIN *hbin;        /* pointer to HBIN record (in memory) containing this nk record */
 102         uint32 hbin_off;        /* offset from beginning of this hbin block */
 103         uint32 rec_size;        /* ((start_offset - end_offset) & 0xfffffff8) */
 104         uint32 rec_off;         /* offset stored in the value list */
 105
 106         char header[REC_HDR_SIZE];
 107         char *valuename;
 108         uint32 data_size;
 109         uint32 data_off;
 110         uint8  *data;
 111         uint32 type;
 112         uint16 flag;
 113 } REGF_VK_REC;
 114
 115
 116 /* Key Security */
 117 struct _regf_sk_rec;
 118
 119 typedef struct _regf_sk_rec {
 120         struct _regf_sk_rec *next, *prev;
 121         REGF_HBIN *hbin;        /* pointer to HBIN record (in memory) containing this nk record */
 122         uint32 hbin_off;        /* offset from beginning of this hbin block */
 123         uint32 rec_size;        /* ((start_offset - end_offset) & 0xfffffff8) */
 124
 125         uint32 sk_off;          /* offset parsed from NK record used as a key
 126                                    to lookup reference to this SK record */
 127
 128         char header[REC_HDR_SIZE];
 129         uint32 prev_sk_off;
 130         uint32 next_sk_off;
 131         uint32 ref_count;
 132         uint32 size;
 133         struct security_descriptor *sec_desc;
 134 } REGF_SK_REC;
 135
 136 /* Key Name */
 137
 138 typedef struct {
 139         REGF_HBIN *hbin;        /* pointer to HBIN record (in memory) containing this nk record */
 140         uint32 hbin_off;        /* offset from beginning of this hbin block */
 141         uint32 subkey_index;    /* index to next subkey record to return */
 142         uint32 rec_size;        /* ((start_offset - end_offset) & 0xfffffff8) */
 143
 144         /* header information */
 145
 146         char header[REC_HDR_SIZE];
 147         uint16 key_type;
 148         NTTIME mtime;
 149         uint32 parent_off;      /* back pointer in registry hive */
 150         uint32 classname_off;
 151         char *classname;
 152         char *keyname;
 153
 154         /* max lengths */
 155
 156         uint32 max_bytes_subkeyname;            /* max subkey name * 2 */
 157         uint32 max_bytes_subkeyclassname;       /* max subkey classname length (as if) */
 158         uint32 max_bytes_valuename;             /* max valuename * 2 */
 159         uint32 max_bytes_value;                 /* max value data size */
 160
 161         /* unknowns */
 162
 163         uint32 unk_index;                       /* nigel says run time index ? */
 164
 165         /* children */
 166
 167         uint32 num_subkeys;
 168         uint32 subkeys_off;     /* hash records that point to NK records */
 169         uint32 num_values;
 170         uint32 values_off;      /* value lists which point to VK records */
 171         uint32 sk_off;          /* offset to SK record */
 172
 173         /* link in the other records here */
 174
 175         REGF_LF_REC subkeys;
 176         REGF_VK_REC *values;
 177         REGF_SK_REC *sec_desc;
 178
 179 } REGF_NK_REC;
 180
 181 /* REGF block */
 182
 183 typedef struct {
 184         /* run time information */
 185
 186         int fd;                         /* file descriptor */
 187         int open_flags;                 /* flags passed to the open() call */
 188         TALLOC_CTX *mem_ctx;            /* memory context for run-time file access information */
 189         REGF_HBIN *block_list;          /* list of open hbin blocks */
 190
 191         /* file format information */
 192
 193         char   header[REGF_HDR_SIZE];   /* "regf" */
 194         uint32 data_offset;             /* offset to record in the first (or any?) hbin block */
 195         uint32 last_block;              /* offset to last hbin block in file */
 196         uint32 checksum;                /* XOR of bytes 0x0000 - 0x01FB */
 197         NTTIME mtime;
 198
 199         REGF_SK_REC *sec_desc_list;     /* list of security descriptors referenced by NK records */
 200
 201         /* unknowns used to simply writing */
 202
 203         uint32 unknown1;
 204         uint32 unknown2;
 205         uint32 unknown3;
 206         uint32 unknown4;
 207         uint32 unknown5;
 208         uint32 unknown6;
 209
 210 } REGF_FILE;
 211
 212 /* Function Declarations */
 213
 214 REGF_FILE*    regfio_open( const char *filename, int flags, int mode );
 215 int           regfio_close( REGF_FILE *r );
 216
 217 REGF_NK_REC*  regfio_rootkey( REGF_FILE *file );
 218 REGF_NK_REC*  regfio_fetch_subkey( REGF_FILE *file, REGF_NK_REC *nk );
 219 REGF_NK_REC*  regfio_write_key ( REGF_FILE *file, const char *name,
 220                                  struct regval_ctr *values, struct regsubkey_ctr *subkeys,
 221                                  struct security_descriptor *sec_desc, REGF_NK_REC *parent );
 222
 223
 224 #endif  /* _REGFIO_H */
 225