Adding upstream version 2:4.20.0+dfsg.upstream/2%4.20.0+dfsg

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 387 insertions, 0 deletions

diff --git a/source4/lib/registry/patchfile_preg.c b/source4/lib/registry/patchfile_preg.c
new file mode 100644
index 0000000..50bd141
--- /dev/null
+++ b/source4/lib/registry/patchfile_preg.c
@@ -0,0 +1,387 @@
+/*
+   Unix SMB/CIFS implementation.
+   Reading Registry.pol PReg registry files
+
+   Copyright (C) Wilco Baan Hofman 2006-2008
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include "includes.h"
+#include "lib/registry/registry.h"
+#include "system/filesys.h"
+#include "librpc/gen_ndr/winreg.h"
+#include "lib/util/sys_rw.h"
+
+#undef strcasecmp
+#undef strncasecmp
+
+struct preg_data {
+	int fd;
+	TALLOC_CTX *ctx;
+};
+
+static WERROR preg_read_utf16(int fd, char *c)
+{
+	uint16_t v;
+
+	if (read(fd, &v, sizeof(uint16_t)) < sizeof(uint16_t)) {
+		return WERR_GEN_FAILURE;
+	}
+	push_codepoint(c, v);
+	return WERR_OK;
+}
+static WERROR preg_write_utf16(int fd, const char *string)
+{
+	uint16_t v;
+	size_t i, size;
+
+	for (i = 0; i < strlen(string); i+=size) {
+		v = next_codepoint(&string[i], &size);
+		if (write(fd, &v, sizeof(uint16_t)) < sizeof(uint16_t)) {
+			return WERR_GEN_FAILURE;
+		}
+	}
+	return WERR_OK;
+}
+/* PReg does not support adding keys. */
+static WERROR reg_preg_diff_add_key(void *_data, const char *key_name)
+{
+	return WERR_OK;
+}
+
+static WERROR reg_preg_diff_set_value(void *_data, const char *key_name,
+				      const char *value_name,
+				      uint32_t value_type, DATA_BLOB value_data)
+{
+	struct preg_data *data = (struct preg_data *)_data;
+	uint32_t buf;
+	
+	preg_write_utf16(data->fd, "[");
+	preg_write_utf16(data->fd, key_name);
+	preg_write_utf16(data->fd, ";");
+	preg_write_utf16(data->fd, value_name);
+	preg_write_utf16(data->fd, ";");
+	SIVAL(&buf, 0, value_type);
+	sys_write_v(data->fd, &buf, sizeof(uint32_t));
+	preg_write_utf16(data->fd, ";");
+	SIVAL(&buf, 0, value_data.length);
+	sys_write_v(data->fd, &buf, sizeof(uint32_t));
+	preg_write_utf16(data->fd, ";");
+	sys_write_v(data->fd, value_data.data, value_data.length);
+	preg_write_utf16(data->fd, "]");
+	
+	return WERR_OK;
+}
+
+static WERROR reg_preg_diff_del_key(void *_data, const char *key_name)
+{
+	struct preg_data *data = (struct preg_data *)_data;
+	char *parent_name;
+	DATA_BLOB blob;
+	WERROR werr;
+
+	parent_name = talloc_strndup(data->ctx, key_name,
+				     strrchr(key_name, '\\')-key_name);
+	W_ERROR_HAVE_NO_MEMORY(parent_name);
+	blob.data = (uint8_t*)talloc_strndup(data->ctx,
+					     key_name+(strrchr(key_name, '\\')-key_name)+1,
+					     strlen(key_name)-(strrchr(key_name, '\\')-key_name));
+	W_ERROR_HAVE_NO_MEMORY(blob.data);
+	blob.length = strlen((char *)blob.data)+1;
+	
+
+	/* FIXME: These values should be accumulated to be written at done(). */
+	werr = reg_preg_diff_set_value(data, parent_name, "**DeleteKeys",
+				       REG_SZ, blob);
+
+	talloc_free(parent_name);
+	talloc_free(blob.data);
+
+	return werr;
+}
+
+static WERROR reg_preg_diff_del_value(void *_data, const char *key_name,
+				      const char *value_name)
+{
+	struct preg_data *data = (struct preg_data *)_data;
+	char *val;
+	DATA_BLOB blob;
+	WERROR werr;
+
+	val = talloc_asprintf(data->ctx, "**Del.%s", value_name);
+	W_ERROR_HAVE_NO_MEMORY(val);
+	blob.data = (uint8_t *)talloc(data->ctx, uint32_t);
+	W_ERROR_HAVE_NO_MEMORY(blob.data);
+	SIVAL(blob.data, 0, 0);
+	blob.length = sizeof(uint32_t);
+
+	werr = reg_preg_diff_set_value(data, key_name, val, REG_DWORD, blob);
+
+	talloc_free(val);
+	talloc_free(blob.data);
+
+	return werr;
+}
+
+static WERROR reg_preg_diff_del_all_values(void *_data, const char *key_name)
+{
+	struct preg_data *data = (struct preg_data *)_data;
+	DATA_BLOB blob;
+	WERROR werr;
+
+	blob.data = (uint8_t *)talloc(data->ctx, uint32_t);
+	W_ERROR_HAVE_NO_MEMORY(blob.data);
+	SIVAL(blob.data, 0, 0);
+	blob.length = sizeof(uint32_t);
+
+	werr = reg_preg_diff_set_value(data, key_name, "**DelVals.", REG_DWORD,
+				       blob);
+
+	talloc_free(blob.data);
+
+	return werr;
+}
+
+static WERROR reg_preg_diff_done(void *_data)
+{
+	struct preg_data *data = (struct preg_data *)_data;
+	
+	close(data->fd);
+	talloc_free(data);
+	return WERR_OK;
+}
+
+/**
+ * Save registry diff
+ */
+_PUBLIC_ WERROR reg_preg_diff_save(TALLOC_CTX *ctx, const char *filename,
+				   struct reg_diff_callbacks **callbacks,
+				   void **callback_data)
+{
+	struct preg_data *data;
+	struct {
+		char hdr[4];
+		uint32_t version;
+	} preg_header;
+
+
+	data = talloc_zero(ctx, struct preg_data);
+	*callback_data = data;
+
+	if (filename) {
+		data->fd = open(filename, O_CREAT|O_WRONLY, 0755);
+		if (data->fd < 0) {
+			DEBUG(0, ("Unable to open %s\n", filename));
+			return WERR_FILE_NOT_FOUND;
+		}
+	} else {
+		data->fd = STDOUT_FILENO;
+	}
+
+	memcpy(preg_header.hdr, "PReg", sizeof(preg_header.hdr));
+	SIVAL(&preg_header.version, 0, 1);
+	sys_write_v(data->fd, (uint8_t *)&preg_header, sizeof(preg_header));
+
+	data->ctx = ctx;
+
+	*callbacks = talloc(ctx, struct reg_diff_callbacks);
+
+	(*callbacks)->add_key = reg_preg_diff_add_key;
+	(*callbacks)->del_key = reg_preg_diff_del_key;
+	(*callbacks)->set_value = reg_preg_diff_set_value;
+	(*callbacks)->del_value = reg_preg_diff_del_value;
+	(*callbacks)->del_all_values = reg_preg_diff_del_all_values;
+	(*callbacks)->done = reg_preg_diff_done;
+
+	return WERR_OK;
+}
+/**
+ * Load diff file
+ */
+_PUBLIC_ WERROR reg_preg_diff_load(int fd,
+				   const struct reg_diff_callbacks *callbacks,
+				   void *callback_data)
+{
+	struct {
+		char hdr[4];
+		uint32_t version;
+	} preg_header;
+	char *buf;
+	size_t buf_size = 1024;
+	char *buf_ptr;
+	TALLOC_CTX *mem_ctx = talloc_init("reg_preg_diff_load");
+	WERROR ret = WERR_OK;
+
+	buf = talloc_array(mem_ctx, char, buf_size);
+	buf_ptr = buf;
+
+	/* Read first 8 bytes (the header) */
+	if (read(fd, &preg_header, sizeof(preg_header)) != sizeof(preg_header)) {
+		DEBUG(0, ("Could not read PReg file: %s\n",
+				strerror(errno)));
+		ret = WERR_GEN_FAILURE;
+		goto cleanup;
+	}
+	preg_header.version = IVAL(&preg_header.version, 0);
+
+	if (strncmp(preg_header.hdr, "PReg", 4) != 0) {
+		DEBUG(0, ("This file is not a valid preg registry file\n"));
+		ret = WERR_GEN_FAILURE;
+		goto cleanup;
+	}
+	if (preg_header.version > 1) {
+		DEBUG(0, ("Warning: file format version is higher than expected.\n"));
+	}
+
+	/* Read the entries */
+	while(1) {
+		uint32_t value_type, length;
+		char *key = NULL;
+		char *value_name = NULL;
+		DATA_BLOB data = {NULL, 0};
+
+		if (!W_ERROR_IS_OK(preg_read_utf16(fd, buf_ptr))) {
+			break;
+		}
+		if (*buf_ptr != '[') {
+			DEBUG(0, ("Error in PReg file.\n"));
+			ret = WERR_GEN_FAILURE;
+			goto cleanup;
+		}
+
+		/* Get the path */
+		buf_ptr = buf;
+		while (W_ERROR_IS_OK(preg_read_utf16(fd, buf_ptr)) &&
+		       *buf_ptr != ';' && buf_ptr-buf < buf_size) {
+			buf_ptr++;
+		}
+		buf[buf_ptr-buf] = '\0';
+		key = talloc_strdup(mem_ctx, buf);
+
+		/* Get the name */
+		buf_ptr = buf;
+		while (W_ERROR_IS_OK(preg_read_utf16(fd, buf_ptr)) &&
+		       *buf_ptr != ';' && buf_ptr-buf < buf_size) {
+			buf_ptr++;
+		}
+		buf[buf_ptr-buf] = '\0';
+		value_name = talloc_strdup(mem_ctx, buf);
+
+		/* Get the type */
+		if (read(fd, &value_type, sizeof(uint32_t)) < sizeof(uint32_t)) {
+			DEBUG(0, ("Error while reading PReg\n"));
+			ret = WERR_GEN_FAILURE;
+			goto cleanup;
+		}
+		value_type = IVAL(&value_type, 0);
+
+		/* Read past delimiter */
+		buf_ptr = buf;
+		if (!(W_ERROR_IS_OK(preg_read_utf16(fd, buf_ptr)) &&
+		    *buf_ptr == ';') && buf_ptr-buf < buf_size) {
+			DEBUG(0, ("Error in PReg file.\n"));
+			ret = WERR_GEN_FAILURE;
+			goto cleanup;
+		}
+
+		/* Get data length */
+		if (read(fd, &length, sizeof(uint32_t)) < sizeof(uint32_t)) {
+			DEBUG(0, ("Error while reading PReg\n"));
+			ret = WERR_GEN_FAILURE;
+			goto cleanup;
+		}
+		length = IVAL(&length, 0);
+
+		/* Read past delimiter */
+		buf_ptr = buf;
+		if (!(W_ERROR_IS_OK(preg_read_utf16(fd, buf_ptr)) &&
+		    *buf_ptr == ';') && buf_ptr-buf < buf_size) {
+			DEBUG(0, ("Error in PReg file.\n"));
+			ret = WERR_GEN_FAILURE;
+			goto cleanup;
+		}
+
+		/* Get the data */
+		buf_ptr = buf;
+		if (length < buf_size &&
+		    read(fd, buf_ptr, length) != length) {
+			DEBUG(0, ("Error while reading PReg\n"));
+			ret = WERR_GEN_FAILURE;
+			goto cleanup;
+		}
+		data = data_blob_talloc(mem_ctx, buf, length);
+
+		/* Check if delimiter is in place (whine if it isn't) */
+		buf_ptr = buf;
+		if (!(W_ERROR_IS_OK(preg_read_utf16(fd, buf_ptr)) &&
+		    *buf_ptr == ']') && buf_ptr-buf < buf_size) {
+			DEBUG(0, ("Warning: Missing ']' in PReg file, expected ']', got '%c' 0x%x.\n",
+				*buf_ptr, *buf_ptr));
+		}
+
+		if (strcasecmp(value_name, "**DelVals") == 0) {
+			callbacks->del_all_values(callback_data, key);
+		} else if (strncasecmp(value_name, "**Del.",6) == 0) {
+			char *p = value_name+6;
+
+			callbacks->del_value(callback_data, key, p);
+		} else 	if (strcasecmp(value_name, "**DeleteValues") == 0) {
+			char *p, *q;
+
+			p = (char *) data.data;
+
+			while ((q = strchr_m(p, ';'))) {
+				*q = '\0';
+				q++;
+
+				callbacks->del_value(callback_data, key, p);
+
+				p = q;
+			}
+			callbacks->del_value(callback_data, key, p);
+		} else if (strcasecmp(value_name, "**DeleteKeys") == 0) {
+			char *p, *q, *full_key;
+
+			p = (char *) data.data;
+
+			while ((q = strchr_m(p, ';'))) {
+				*q = '\0';
+				q++;
+
+				full_key = talloc_asprintf(mem_ctx, "%s\\%s",
+							   key, p);
+				callbacks->del_key(callback_data, full_key);
+				talloc_free(full_key);
+
+				p = q;
+			}
+			full_key = talloc_asprintf(mem_ctx, "%s\\%s", key, p);
+			callbacks->del_key(callback_data, full_key);
+			talloc_free(full_key);
+		} else {
+			callbacks->add_key(callback_data, key);
+			callbacks->set_value(callback_data, key, value_name,
+					     value_type, data);
+		}
+		TALLOC_FREE(key);
+		TALLOC_FREE(value_name);
+		data_blob_free(&data);
+	}
+cleanup:
+	close(fd);
+	TALLOC_FREE(mem_ctx);
+	return ret;
+}