r24665: Close file handles properly.
[sfrench/samba-autobuild/.git] / source4 / lib / registry / reg_backend_w95.c
1 /*
2    Samba Unix/Linux SMB client utility libeditreg.c 
3    Copyright (C) 2004 Jelmer Vernooij, jelmer@samba.org
4
5    Backend for Windows '95 registry files. Explanation of file format 
6    comes from http://www.cs.mun.ca/~michael/regutils/.
7
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 3 of the License, or
11    (at your option) any later version.
12    
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17    
18    You should have received a copy of the GNU General Public License
19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
20
21 #include "includes.h"
22 #include "registry.h"
23 #include "system/filesys.h"
24 #include "system/shmem.h"
25
26 /**
27  * The registry starts with a header that contains pointers to 
28  * the rgdb.
29  *
30  * After the main header follows the RGKN header (key index table).
31  * The RGKN keys are listed after each other. They are put into 
32  * blocks, the first having a length of 0x2000 bytes, the others 
33  * being 0x1000 bytes long.
34  *
35  * After the RGKN header follow one or more RGDB blocks. These blocks 
36  * contain keys. A key is followed by its name and its values.
37  *
38  * Values are followed by their name and then their data.
39  *
40  * Basically the idea is that the RGKN contains the associations between 
41  * the keys and the RGDB contains the actual data.
42  */
43
44 typedef uint32_t DWORD;
45 typedef unsigned short WORD;
46
47 typedef struct creg_block {
48         DWORD CREG_ID;          /* CREG */
49         DWORD uk1;
50         DWORD rgdb_offset;
51         DWORD chksum;
52         WORD  num_rgdb;
53         WORD  flags;
54         DWORD uk2;
55         DWORD uk3;
56         DWORD uk4;
57 } CREG_HDR;
58
59 typedef struct rgkn_block {
60         DWORD RGKN_ID;          /* RGKN */
61         DWORD size;
62         DWORD root_offset;
63         DWORD free_offset;
64         DWORD flags;
65         DWORD chksum;
66         DWORD uk1;
67         DWORD uk2;
68 } RGKN_HDR;
69
70 typedef struct reg_id {
71         WORD id;
72         WORD rgdb;
73 } REG_ID;
74
75 typedef struct rgkn_key {
76         DWORD type;                     /* 0x00000000 = normal key, 0x80000000 = free block */
77         DWORD hash;                     /* Contains either hash or size of free blocks that follows */
78         DWORD next_free;
79         DWORD parent_offset;
80         DWORD first_child_offset;
81         DWORD next_offset;
82         REG_ID id;
83 } RGKN_KEY;
84
85
86 typedef struct rgdb_block {
87         DWORD RGDB_ID;          /* RGDB */
88         DWORD size;
89         DWORD unused_size;
90         WORD flags;
91         WORD section;
92         DWORD free_offset;      /* -1 if there is no free space */
93         WORD max_id;
94         WORD first_free_id;
95         DWORD uk1;
96         DWORD chksum;
97 } RGDB_HDR;
98
99 typedef struct rgdb_key {
100         DWORD size;
101         REG_ID id;
102         DWORD used_size;
103         WORD  name_len;
104         WORD  num_values;
105         DWORD uk1;
106 } RGDB_KEY;
107
108 typedef struct rgdb_value {
109         DWORD type;
110         DWORD uk1;
111         WORD name_len;
112         WORD data_len;
113 } RGDB_VALUE;
114
115 typedef struct creg_struct_s {
116         int fd;
117         BOOL modified;
118         char *base;
119         struct stat sbuf;
120         CREG_HDR *creg_hdr;
121         RGKN_HDR *rgkn_hdr;
122         RGDB_KEY ***rgdb_keys;
123 } CREG;
124
125 #if 0 /* unused */
126 #define RGKN_START_SIZE 0x2000
127 #define RGKN_INC_SIZE   0x1000
128 #endif
129
130 #define LOCN_RGKN(creg, o) ((RGKN_KEY *)((creg)->base + sizeof(CREG_HDR) + o))
131 #define LOCN_RGDB_BLOCK(creg, o) (((creg)->base + (creg)->creg_hdr->rgdb_offset + o))
132 #define LOCN_RGDB_KEY(creg, rgdb, id) ((RGDB_KEY *)((creg)->rgdb_keys[(rgdb)][(id)]))
133
134 static DWORD str_to_dword(const char *a) {
135     int i;
136     unsigned long ret = 0;
137     for(i = strlen(a)-1; i >= 0; i--) {
138         ret = ret * 0x100 + a[i];
139     }
140     return ret;
141 }
142
143 #if 0 /* unused */
144
145 static DWORD calc_hash(const char *str) {
146         DWORD ret = 0;
147         int i;
148         for(i = 0; str[i] && str[i] != '\\'; i++) {
149                 ret+=toupper(str[i]);
150         }
151         return ret;
152 }
153
154 static void parse_rgkn_block(CREG *creg, off_t start_off, off_t end_off) 
155 {
156         off_t i;
157         for(i = start_off; end_off - i > sizeof(RGKN_KEY); i+= sizeof(RGKN_KEY)) {
158                 RGKN_KEY *key = (RGKN_KEY *)LOCN_RGKN(creg, i);
159                 if(key->type == 0) {
160                         DEBUG(4,("Regular, id: %d, %d, parent: %x, firstchild: %x, next: %x hash: %lX\n", key->id.id, key->id.rgdb, key->parent_offset, key->first_child_offset, key->next_offset, (long)key->hash));
161                 } else if(key->type == 0x80000000) {
162                         DEBUG(3,("free\n"));
163                         i += key->hash;
164                 } else {
165                         DEBUG(0,("Invalid key type in RGKN: %0X\n", key->type));
166                 }
167         }
168 }
169
170 #endif
171
172 static void parse_rgdb_block(CREG *creg, RGDB_HDR *rgdb_hdr)
173 {
174         DWORD used_size = rgdb_hdr->size - rgdb_hdr->unused_size;
175         DWORD offset = 0;
176
177         while(offset < used_size) {
178                 RGDB_KEY *key = (RGDB_KEY *)(((char *)rgdb_hdr) + sizeof(RGDB_HDR) + offset);
179                 
180                 if(!(key->id.id == 0xFFFF && key->id.rgdb == 0xFFFF))creg->rgdb_keys[key->id.rgdb][key->id.id] = key;
181                 offset += key->size;
182         }
183 }
184
185 static WERROR w95_open_reg (struct registry_hive *h, struct registry_key **root)
186 {
187         CREG *creg;
188         DWORD creg_id, rgkn_id;
189         DWORD i;
190         DWORD offset;
191
192         creg = talloc(h, CREG);
193         memset(creg, 0, sizeof(CREG));
194         h->backend_data = creg;
195
196         if((creg->fd = open(h->location, O_RDONLY, 0000)) < 0) {
197                 return WERR_FOOBAR;
198         }
199
200     if (fstat(creg->fd, &creg->sbuf) < 0) {
201                 return WERR_FOOBAR;
202     }
203
204     creg->base = mmap(0, creg->sbuf.st_size, PROT_READ, MAP_SHARED, creg->fd, 0);
205                                                                                                                                               
206     if (creg->base == (void *)-1) {
207                 DEBUG(0,("Could not mmap file: %s, %s\n", h->location, strerror(errno)));
208         return WERR_FOOBAR;
209     }
210
211         creg->creg_hdr = (CREG_HDR *)creg->base;
212
213         if ((creg_id = IVAL(&creg->creg_hdr->CREG_ID,0)) != str_to_dword("CREG")) {
214                 DEBUG(0, ("Unrecognized Windows 95 registry header id: 0x%0X, %s\n", 
215                                   creg_id, h->location));
216                 return WERR_FOOBAR;
217         }
218
219         creg->rgkn_hdr = (RGKN_HDR *)LOCN_RGKN(creg, 0);
220
221         if ((rgkn_id = IVAL(&creg->rgkn_hdr->RGKN_ID,0)) != str_to_dword("RGKN")) {
222                 DEBUG(0, ("Unrecognized Windows 95 registry key index id: 0x%0X, %s\n", 
223                                   rgkn_id, h->location));
224                 return WERR_FOOBAR;
225         }
226
227 #if 0   
228         /* If'ed out because we only need to parse this stuff when allocating new 
229          * entries (which we don't do at the moment */
230         /* First parse the 0x2000 long block */
231         parse_rgkn_block(creg, sizeof(RGKN_HDR), 0x2000);
232
233         /* Then parse the other 0x1000 length blocks */
234         for(offset = 0x2000; offset < creg->rgkn_hdr->size; offset+=0x1000) {
235                 parse_rgkn_block(creg, offset, offset+0x1000);
236         }
237 #endif
238
239         creg->rgdb_keys = talloc_array(h, RGDB_KEY **, creg->creg_hdr->num_rgdb);
240
241         offset = 0;
242         DEBUG(3, ("Reading %d rgdb entries\n", creg->creg_hdr->num_rgdb));
243         for(i = 0; i < creg->creg_hdr->num_rgdb; i++) {
244                 RGDB_HDR *rgdb_hdr = (RGDB_HDR *)LOCN_RGDB_BLOCK(creg, offset);
245                 
246                 if(strncmp((char *)&(rgdb_hdr->RGDB_ID), "RGDB", 4)) {
247                         DEBUG(0, ("unrecognized rgdb entry: %4d, %s\n", 
248                                           rgdb_hdr->RGDB_ID, h->location));
249                         return WERR_FOOBAR;
250                 } else {
251                         DEBUG(3, ("Valid rgdb entry, first free id: %d, max id: %d\n", rgdb_hdr->first_free_id, rgdb_hdr->max_id));
252                 }
253
254
255                 creg->rgdb_keys[i] = talloc_array(h, RGDB_KEY *, rgdb_hdr->max_id+1);
256                 memset(creg->rgdb_keys[i], 0, sizeof(RGDB_KEY *) * (rgdb_hdr->max_id+1));
257
258                 parse_rgdb_block(creg, rgdb_hdr);
259
260                 offset+=rgdb_hdr->size;
261         }
262         
263         /* First element in rgkn should be root key */
264         *root = talloc(h, struct registry_key);
265         (*root)->name = NULL;
266         (*root)->backend_data = LOCN_RGKN(creg, sizeof(RGKN_HDR));
267         
268         return WERR_OK;
269 }
270
271 static WERROR w95_get_subkey_by_index (TALLOC_CTX *mem_ctx, const struct registry_key *parent, int n, struct registry_key **key)
272 {
273         CREG *creg = parent->hive->backend_data;
274         RGKN_KEY *rgkn_key = parent->backend_data;
275         RGKN_KEY *child;
276         DWORD child_offset;
277         DWORD cur = 0;
278         
279         /* Get id of first child */
280         child_offset = rgkn_key->first_child_offset;
281
282         while(child_offset != 0xFFFFFFFF) {
283                 child = LOCN_RGKN(creg, child_offset);
284
285                 /* n == cur ? return! */
286                 if(cur == n) {
287                         RGDB_KEY *rgdb_key;
288                         rgdb_key = LOCN_RGDB_KEY(creg, child->id.rgdb, child->id.id);
289                         if(!rgdb_key) {
290                                 DEBUG(0, ("Can't find %d,%d in RGDB table!\n", child->id.rgdb, child->id.id));
291                                 return WERR_FOOBAR;
292                         }
293                         *key = talloc(mem_ctx, struct registry_key);
294                         (*key)->backend_data = child;
295                         (*key)->name = talloc_strndup(mem_ctx, (char *)rgdb_key + sizeof(RGDB_KEY), rgdb_key->name_len);
296                         return WERR_OK;
297                 }
298
299                 cur++;
300                 
301                 child_offset = child->next_offset;
302         }
303
304         return WERR_NO_MORE_ITEMS;
305 }
306
307 static WERROR w95_num_values(const struct registry_key *k, uint32_t *count)
308 {
309         RGKN_KEY *rgkn_key = k->backend_data;
310         RGDB_KEY *rgdb_key = LOCN_RGDB_KEY((CREG *)k->hive->backend_data, rgkn_key->id.rgdb, rgkn_key->id.id);
311
312         if(!rgdb_key) return WERR_FOOBAR;
313         
314         *count = rgdb_key->num_values;
315         
316         return WERR_OK;
317 }
318
319 static WERROR w95_get_value_by_id(TALLOC_CTX *mem_ctx, const struct registry_key *k, int idx, struct registry_value **value)
320 {
321         RGKN_KEY *rgkn_key = k->backend_data;
322         DWORD i;
323         DWORD offset = 0;
324         RGDB_KEY *rgdb_key = LOCN_RGDB_KEY((CREG *)k->hive->backend_data, rgkn_key->id.rgdb, rgkn_key->id.id);
325         RGDB_VALUE *curval = NULL;
326
327         if(!rgdb_key) return WERR_FOOBAR;
328         
329         if(idx >= rgdb_key->num_values) return WERR_NO_MORE_ITEMS;
330         
331         for(i = 0; i < idx; i++) {
332                 curval = (RGDB_VALUE *)(((char *)rgdb_key) + sizeof(RGDB_KEY) + rgdb_key->name_len + offset);
333                 offset+=sizeof(RGDB_VALUE) + curval->name_len + curval->data_len;
334         }
335
336         *value = talloc(mem_ctx, struct registry_value);
337         (*value)->name = talloc_strndup(mem_ctx, (char *)curval+sizeof(RGDB_VALUE), curval->name_len);
338                 
339         (*value)->data = data_blob_talloc(mem_ctx, curval+sizeof(RGDB_VALUE)+curval->name_len, curval->data_len);
340         (*value)->data_type = curval->type;
341         
342         return WERR_OK;
343 }
344
345 static struct hive_operations reg_backend_w95 = {
346         .name = "w95",
347         .open_hive = w95_open_reg,
348         .get_value_by_index = w95_get_value_by_id,
349         .num_values = w95_num_values,
350         .get_subkey_by_index = w95_get_subkey_by_index,
351 };
352
353 NTSTATUS registry_w95_init(void)
354 {
355         return registry_register(&reg_backend_w95);
356 }