← Back to branch summary

~vcs-imports/samba/main

« back to all changes in this revision

Viewing changes to source/include/regfio.h

  • Committer: jerry
  • Date: 2006-07-14 21:48:39 UTC
  • Revision ID: vcs-imports@canonical.com-20060714214839-586d8c489a8fcead
gutting trunk to move to svn:externals

Show diffs side-by-side

added added

removed removed

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