2 Unix SMB/CIFS implementation.
3 Reading Registry.pol PReg registry files
5 Copyright (C) Wilco Baan Hofman 2006-2008
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 #include "lib/registry/registry.h"
24 #include "system/filesys.h"
25 #include "librpc/gen_ndr/winreg.h"
26 #include "lib/util/sys_rw.h"
33 static WERROR preg_read_utf16(int fd, char *c)
37 if (read(fd, &v, sizeof(uint16_t)) < sizeof(uint16_t)) {
38 return WERR_GEN_FAILURE;
43 static WERROR preg_write_utf16(int fd, const char *string)
48 for (i = 0; i < strlen(string); i+=size) {
49 v = next_codepoint(&string[i], &size);
50 if (write(fd, &v, sizeof(uint16_t)) < sizeof(uint16_t)) {
51 return WERR_GEN_FAILURE;
56 /* PReg does not support adding keys. */
57 static WERROR reg_preg_diff_add_key(void *_data, const char *key_name)
62 static WERROR reg_preg_diff_set_value(void *_data, const char *key_name,
63 const char *value_name,
64 uint32_t value_type, DATA_BLOB value_data)
66 struct preg_data *data = (struct preg_data *)_data;
69 preg_write_utf16(data->fd, "[");
70 preg_write_utf16(data->fd, key_name);
71 preg_write_utf16(data->fd, ";");
72 preg_write_utf16(data->fd, value_name);
73 preg_write_utf16(data->fd, ";");
74 SIVAL(&buf, 0, value_type);
75 sys_write_v(data->fd, &buf, sizeof(uint32_t));
76 preg_write_utf16(data->fd, ";");
77 SIVAL(&buf, 0, value_data.length);
78 sys_write_v(data->fd, &buf, sizeof(uint32_t));
79 preg_write_utf16(data->fd, ";");
80 sys_write_v(data->fd, value_data.data, value_data.length);
81 preg_write_utf16(data->fd, "]");
86 static WERROR reg_preg_diff_del_key(void *_data, const char *key_name)
88 struct preg_data *data = (struct preg_data *)_data;
93 parent_name = talloc_strndup(data->ctx, key_name,
94 strrchr(key_name, '\\')-key_name);
95 W_ERROR_HAVE_NO_MEMORY(parent_name);
96 blob.data = (uint8_t*)talloc_strndup(data->ctx,
97 key_name+(strrchr(key_name, '\\')-key_name)+1,
98 strlen(key_name)-(strrchr(key_name, '\\')-key_name));
99 W_ERROR_HAVE_NO_MEMORY(blob.data);
100 blob.length = strlen((char *)blob.data)+1;
103 /* FIXME: These values should be accumulated to be written at done(). */
104 werr = reg_preg_diff_set_value(data, parent_name, "**DeleteKeys",
107 talloc_free(parent_name);
108 talloc_free(blob.data);
113 static WERROR reg_preg_diff_del_value(void *_data, const char *key_name,
114 const char *value_name)
116 struct preg_data *data = (struct preg_data *)_data;
121 val = talloc_asprintf(data->ctx, "**Del.%s", value_name);
122 W_ERROR_HAVE_NO_MEMORY(val);
123 blob.data = (uint8_t *)talloc(data->ctx, uint32_t);
124 W_ERROR_HAVE_NO_MEMORY(blob.data);
125 SIVAL(blob.data, 0, 0);
126 blob.length = sizeof(uint32_t);
128 werr = reg_preg_diff_set_value(data, key_name, val, REG_DWORD, blob);
131 talloc_free(blob.data);
136 static WERROR reg_preg_diff_del_all_values(void *_data, const char *key_name)
138 struct preg_data *data = (struct preg_data *)_data;
142 blob.data = (uint8_t *)talloc(data->ctx, uint32_t);
143 W_ERROR_HAVE_NO_MEMORY(blob.data);
144 SIVAL(blob.data, 0, 0);
145 blob.length = sizeof(uint32_t);
147 werr = reg_preg_diff_set_value(data, key_name, "**DelVals.", REG_DWORD,
150 talloc_free(blob.data);
155 static WERROR reg_preg_diff_done(void *_data)
157 struct preg_data *data = (struct preg_data *)_data;
167 _PUBLIC_ WERROR reg_preg_diff_save(TALLOC_CTX *ctx, const char *filename,
168 struct reg_diff_callbacks **callbacks,
169 void **callback_data)
171 struct preg_data *data;
178 data = talloc_zero(ctx, struct preg_data);
179 *callback_data = data;
182 data->fd = open(filename, O_CREAT|O_WRONLY, 0755);
184 DEBUG(0, ("Unable to open %s\n", filename));
185 return WERR_FILE_NOT_FOUND;
188 data->fd = STDOUT_FILENO;
191 memcpy(preg_header.hdr, "PReg", sizeof(preg_header.hdr));
192 SIVAL(&preg_header.version, 0, 1);
193 sys_write_v(data->fd, (uint8_t *)&preg_header, sizeof(preg_header));
197 *callbacks = talloc(ctx, struct reg_diff_callbacks);
199 (*callbacks)->add_key = reg_preg_diff_add_key;
200 (*callbacks)->del_key = reg_preg_diff_del_key;
201 (*callbacks)->set_value = reg_preg_diff_set_value;
202 (*callbacks)->del_value = reg_preg_diff_del_value;
203 (*callbacks)->del_all_values = reg_preg_diff_del_all_values;
204 (*callbacks)->done = reg_preg_diff_done;
211 _PUBLIC_ WERROR reg_preg_diff_load(int fd,
212 const struct reg_diff_callbacks *callbacks,
220 size_t buf_size = 1024;
222 TALLOC_CTX *mem_ctx = talloc_init("reg_preg_diff_load");
223 WERROR ret = WERR_OK;
225 buf = talloc_array(mem_ctx, char, buf_size);
228 /* Read first 8 bytes (the header) */
229 if (read(fd, &preg_header, sizeof(preg_header)) != sizeof(preg_header)) {
230 DEBUG(0, ("Could not read PReg file: %s\n",
232 ret = WERR_GEN_FAILURE;
235 preg_header.version = IVAL(&preg_header.version, 0);
237 if (strncmp(preg_header.hdr, "PReg", 4) != 0) {
238 DEBUG(0, ("This file is not a valid preg registry file\n"));
239 ret = WERR_GEN_FAILURE;
242 if (preg_header.version > 1) {
243 DEBUG(0, ("Warning: file format version is higher than expected.\n"));
246 /* Read the entries */
248 uint32_t value_type, length;
250 char *value_name = NULL;
251 DATA_BLOB data = {NULL, 0};
253 if (!W_ERROR_IS_OK(preg_read_utf16(fd, buf_ptr))) {
256 if (*buf_ptr != '[') {
257 DEBUG(0, ("Error in PReg file.\n"));
258 ret = WERR_GEN_FAILURE;
264 while (W_ERROR_IS_OK(preg_read_utf16(fd, buf_ptr)) &&
265 *buf_ptr != ';' && buf_ptr-buf < buf_size) {
268 buf[buf_ptr-buf] = '\0';
269 key = talloc_strdup(mem_ctx, buf);
273 while (W_ERROR_IS_OK(preg_read_utf16(fd, buf_ptr)) &&
274 *buf_ptr != ';' && buf_ptr-buf < buf_size) {
277 buf[buf_ptr-buf] = '\0';
278 value_name = talloc_strdup(mem_ctx, buf);
281 if (read(fd, &value_type, sizeof(uint32_t)) < sizeof(uint32_t)) {
282 DEBUG(0, ("Error while reading PReg\n"));
283 ret = WERR_GEN_FAILURE;
286 value_type = IVAL(&value_type, 0);
288 /* Read past delimiter */
290 if (!(W_ERROR_IS_OK(preg_read_utf16(fd, buf_ptr)) &&
291 *buf_ptr == ';') && buf_ptr-buf < buf_size) {
292 DEBUG(0, ("Error in PReg file.\n"));
293 ret = WERR_GEN_FAILURE;
297 /* Get data length */
298 if (read(fd, &length, sizeof(uint32_t)) < sizeof(uint32_t)) {
299 DEBUG(0, ("Error while reading PReg\n"));
300 ret = WERR_GEN_FAILURE;
303 length = IVAL(&length, 0);
305 /* Read past delimiter */
307 if (!(W_ERROR_IS_OK(preg_read_utf16(fd, buf_ptr)) &&
308 *buf_ptr == ';') && buf_ptr-buf < buf_size) {
309 DEBUG(0, ("Error in PReg file.\n"));
310 ret = WERR_GEN_FAILURE;
316 if (length < buf_size &&
317 read(fd, buf_ptr, length) != length) {
318 DEBUG(0, ("Error while reading PReg\n"));
319 ret = WERR_GEN_FAILURE;
322 data = data_blob_talloc(mem_ctx, buf, length);
324 /* Check if delimiter is in place (whine if it isn't) */
326 if (!(W_ERROR_IS_OK(preg_read_utf16(fd, buf_ptr)) &&
327 *buf_ptr == ']') && buf_ptr-buf < buf_size) {
328 DEBUG(0, ("Warning: Missing ']' in PReg file, expected ']', got '%c' 0x%x.\n",
329 *buf_ptr, *buf_ptr));
332 if (strcasecmp(value_name, "**DelVals") == 0) {
333 callbacks->del_all_values(callback_data, key);
334 } else if (strncasecmp(value_name, "**Del.",6) == 0) {
335 char *p = value_name+6;
337 callbacks->del_value(callback_data, key, p);
338 } else if (strcasecmp(value_name, "**DeleteValues") == 0) {
341 p = (char *) data.data;
343 while ((q = strchr_m(p, ';'))) {
347 callbacks->del_value(callback_data, key, p);
351 callbacks->del_value(callback_data, key, p);
352 } else if (strcasecmp(value_name, "**DeleteKeys") == 0) {
353 char *p, *q, *full_key;
355 p = (char *) data.data;
357 while ((q = strchr_m(p, ';'))) {
361 full_key = talloc_asprintf(mem_ctx, "%s\\%s",
363 callbacks->del_key(callback_data, full_key);
364 talloc_free(full_key);
368 full_key = talloc_asprintf(mem_ctx, "%s\\%s", key, p);
369 callbacks->del_key(callback_data, full_key);
370 talloc_free(full_key);
372 callbacks->add_key(callback_data, key);
373 callbacks->set_value(callback_data, key, value_name,
377 TALLOC_FREE(value_name);
378 data_blob_free(&data);
382 TALLOC_FREE(mem_ctx);