From 9cbafc42ee5cbaae9dfb9d147eefd0e59ff953d0 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Thu, 29 Sep 2005 12:00:49 +0000
Subject: r10605: Forgot one file... (This used to be commit
 441419a08f0845af2b4c8023e1e5bcfda24a6d62)

---
 source4/lib/registry/patchfile.c | 416 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 416 insertions(+)
 create mode 100644 source4/lib/registry/patchfile.c

(limited to 'source4/lib/registry/patchfile.c')

diff --git a/source4/lib/registry/patchfile.c b/source4/lib/registry/patchfile.c
new file mode 100644
index 0000000000..cdf35c7b70
--- /dev/null
+++ b/source4/lib/registry/patchfile.c
@@ -0,0 +1,416 @@
+/* 
+   Unix SMB/CIFS implementation.
+   Reading .REG files
+   
+   Copyright (C) Jelmer Vernooij 2004
+
+   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 2 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 "dynconfig.h"
+#include "lib/registry/registry.h"
+#include "lib/cmdline/popt_common.h"
+#include "system/filesys.h"
+
+#define DEFAULT_IDENT_STRING "SAMBA4 REGISTRY"
+
+static struct reg_diff_key *diff_find_add_key(struct reg_diff *diff, const char *path)
+{
+	int i;
+	
+	for (i = 0; diff->numkeys; i++) {
+		if (!strcasecmp(diff->keys[i].name, path))
+			return &diff->keys[i];
+	}
+
+	diff->keys = talloc_realloc(diff, diff->keys, struct reg_diff_key, diff->numkeys+2);
+	diff->keys[diff->numkeys].name = talloc_strdup(diff->keys, path);
+	diff->keys[diff->numkeys].changetype = REG_DIFF_CHANGE_KEY;
+	diff->keys[diff->numkeys].numvalues = 0;
+	diff->keys[diff->numkeys].values = NULL;
+
+	diff->numkeys++;
+	return NULL;
+}
+
+/*
+ * Generate difference between two keys
+ */
+static WERROR reg_generate_diff_key(struct reg_diff *diff, struct registry_key *oldkey, struct registry_key *newkey)
+{
+	int i;
+	struct registry_key *t1, *t2;
+	struct registry_value *v1, *v2;
+	WERROR error1, error2;
+	TALLOC_CTX *mem_ctx = talloc_init("writediff");
+
+	/* Subkeys that were deleted */
+	for(i = 0; W_ERROR_IS_OK(error1 = reg_key_get_subkey_by_index(mem_ctx, oldkey, i, &t1)); i++) {
+		error2 = reg_key_get_subkey_by_name(mem_ctx, newkey, t1->name, &t2);
+
+		if (W_ERROR_IS_OK(error2))
+			continue;
+
+		if (!W_ERROR_EQUAL(error2, WERR_DEST_NOT_FOUND)) {
+			DEBUG(0, ("Error occured while getting subkey by name: %d\n", W_ERROR_V(error2)));
+			return error2;
+		}
+
+		/* newkey didn't have such a subkey, add del diff */
+		diff->keys = talloc_realloc(diff, diff->keys, struct reg_diff_key, diff->numkeys+2);
+		diff->keys[diff->numkeys].name = talloc_strdup(diff->keys, t1->path);
+		diff->keys[diff->numkeys].changetype = REG_DIFF_DEL_KEY;
+		diff->numkeys++;
+	}
+
+	if(!W_ERROR_EQUAL(error1, WERR_NO_MORE_ITEMS)) {
+		DEBUG(0, ("Error occured while getting subkey by index: %d\n", W_ERROR_V(error1)));
+		talloc_free(mem_ctx);
+		return error1;
+	}
+
+	/* Subkeys that were added */
+	for(i = 0; W_ERROR_IS_OK(error1 = reg_key_get_subkey_by_index(mem_ctx, newkey, i, &t1)); i++) {
+		error2 = reg_key_get_subkey_by_name(mem_ctx, oldkey, t1->name, &t2);
+			
+		if (W_ERROR_IS_OK(error2))
+			continue;
+		
+		if (!W_ERROR_EQUAL(error2, WERR_DEST_NOT_FOUND)) {
+			DEBUG(0, ("Error occured while getting subkey by name: %d\n", W_ERROR_V(error2)));
+			return error2;
+		}
+
+		/* oldkey didn't have such a subkey, add add diff */
+		diff->keys = talloc_realloc(diff, diff->keys, struct reg_diff_key, diff->numkeys+2);
+		diff->keys[diff->numkeys].name = talloc_strdup(diff->keys, t1->path);
+		diff->keys[diff->numkeys].changetype = REG_DIFF_CHANGE_KEY;
+		diff->keys[diff->numkeys].numvalues = 0;
+		diff->keys[diff->numkeys].values = NULL;
+		diff->numkeys++;
+
+		reg_generate_diff_key(diff, t1, t2);
+	}
+
+	if(!W_ERROR_EQUAL(error1, WERR_NO_MORE_ITEMS)) {
+		DEBUG(0, ("Error occured while getting subkey by index: %d\n", W_ERROR_V(error1)));
+		talloc_free(mem_ctx);
+		return error1;
+	}
+
+	/* Values that were changed */
+	for(i = 0; W_ERROR_IS_OK(error1 = reg_key_get_value_by_index(mem_ctx, newkey, i, &v1)); i++) {
+		struct reg_diff_key *thiskey = NULL;
+		error2 = reg_key_get_value_by_name(mem_ctx, oldkey, v1->name, &v2);
+	
+		if(!W_ERROR_IS_OK(error2) && 
+		   !W_ERROR_EQUAL(error2, WERR_DEST_NOT_FOUND)) {
+			DEBUG(0, ("Error occured while getting value by name: %d\n", W_ERROR_V(error2)));
+			return error2;
+		}
+
+		if (W_ERROR_IS_OK(error2) && data_blob_equal(&v1->data, &v2->data))
+			continue;
+
+		thiskey = diff_find_add_key(diff, oldkey->path);
+		thiskey->values = talloc_realloc(diff, thiskey->values, struct reg_diff_value, thiskey->numvalues+2);
+		thiskey->values[thiskey->numvalues].name = talloc_strdup(thiskey->values, v1->name);
+		thiskey->values[thiskey->numvalues].type = v2->data_type;
+		thiskey->values[thiskey->numvalues].changetype = REG_DIFF_SET_VAL;
+		thiskey->values[thiskey->numvalues].data = data_blob_dup_talloc(thiskey->values, &v2->data);
+		thiskey->numvalues++;
+	}
+
+	if(!W_ERROR_EQUAL(error1, WERR_NO_MORE_ITEMS)) {
+		DEBUG(0, ("Error occured while getting value by index: %d\n", W_ERROR_V(error1)));
+		talloc_free(mem_ctx);
+		return error1;
+	}
+
+	/* Values that were deleted */
+	for(i = 0; W_ERROR_IS_OK(error1 = reg_key_get_value_by_index(mem_ctx, oldkey, i, &v1)); i++) {
+		struct reg_diff_key *thiskey = NULL;
+		error2 = reg_key_get_value_by_name(mem_ctx, newkey, v1->name, &v2);
+
+		if (W_ERROR_IS_OK(error2))
+			continue;
+
+		if (!W_ERROR_EQUAL(error2, WERR_DEST_NOT_FOUND)) {
+			DEBUG(0, ("Error occured while getting value by name: %d\n", W_ERROR_V(error2)));
+			return error2;
+		}
+
+		thiskey = diff_find_add_key(diff, oldkey->path);
+		thiskey->values = talloc_realloc(diff, thiskey->values, struct reg_diff_value, thiskey->numvalues+2);
+		thiskey->values[thiskey->numvalues].name = talloc_strdup(thiskey->values, v1->name);
+		thiskey->values[thiskey->numvalues].changetype = REG_DIFF_DEL_VAL;
+		thiskey->numvalues++;
+	}
+
+	if(!W_ERROR_EQUAL(error1, WERR_NO_MORE_ITEMS)) {
+		DEBUG(0, ("Error occured while getting value by index: %d\n", W_ERROR_V(error1)));
+		talloc_free(mem_ctx);
+		return error1;
+	}
+
+	talloc_free(mem_ctx);
+	return WERR_OK;
+}
+
+/* 
+ * Generate diff between two registry contexts 
+ */
+struct reg_diff *reg_generate_diff(TALLOC_CTX *mem_ctx, struct registry_context *ctx1, struct registry_context *ctx2)
+{
+	struct reg_diff *diff = talloc_zero(mem_ctx, struct reg_diff);
+	int i;
+	WERROR error;
+
+	for(i = HKEY_CLASSES_ROOT; i <= HKEY_PERFORMANCE_NLSTEXT; i++) {
+		struct registry_key *r1, *r2;
+		error = reg_get_predefined_key(ctx1, i, &r1);
+		if (!W_ERROR_IS_OK(error)) {
+			DEBUG(0, ("Unable to open hive %s for backend 1\n", reg_get_predef_name(i)));
+			continue;
+		}
+		
+		error = reg_get_predefined_key(ctx2, i, &r2);
+		if (!W_ERROR_IS_OK(error)) {
+			DEBUG(0, ("Unable to open hive %s for backend 2\n", reg_get_predef_name(i)));
+			continue;
+		}
+
+		reg_generate_diff_key(diff, r1, r2);
+	}
+
+	return diff;
+}
+
+/*
+ * Save registry diff
+ */
+WERROR reg_diff_save(const struct reg_diff *diff, const char *filename)
+{
+	int xf, i, j;
+
+	if (filename) {
+		xf = open(filename, O_CREAT, 0755);
+		if (xf == -1) {
+			DEBUG(0, ("Unable to open %s\n", filename));
+			return WERR_BADFILE;
+		}
+	} else 
+		xf = STDIN_FILENO;
+
+	fdprintf(xf, "%s\n\n", diff->format?diff->format:DEFAULT_IDENT_STRING);
+
+	for (i = 0; i < diff->numkeys; i++) {
+		if (diff->keys[i].changetype == REG_DIFF_DEL_KEY) {
+			fdprintf(xf, "-%s\n\n",  diff->keys[i].name);
+			continue;
+		}
+
+		fdprintf(xf, "[%s]\n", diff->keys[i].name);
+
+		for (j = 0; j < diff->keys[i].numvalues; j++) {
+			fdprintf(xf, "\"%s\"=", diff->keys[i].values[j].name);
+			switch (diff->keys[i].values[j].changetype) {
+				case REG_DIFF_DEL_VAL:
+					fdprintf(xf, "-\n");
+					break;
+				case REG_DIFF_SET_VAL:
+					fdprintf(xf, "%s:%s\n", 
+							 str_regtype(diff->keys[i].values[j].type), 
+							 reg_val_data_string(NULL, 
+								diff->keys[i].values[j].type, 
+								&diff->keys[i].values[j].data));
+					break;
+			}
+		}
+
+		fdprintf(xf, "\n");
+	}
+
+	close(xf);
+
+	return WERR_OK;
+}
+
+/*
+ * Load diff file
+ */
+struct reg_diff *reg_diff_load(TALLOC_CTX *ctx, const char *fn)
+{
+	struct reg_diff *diff;
+	int fd;
+	char *line, *p, *q;
+	struct reg_diff_key *curkey;
+	struct reg_diff_value *curval;
+
+	fd = open(fn, O_RDONLY, 0);
+	if (fd == -1) {
+		DEBUG(0, ("Error opening registry patch file `%s'\n", fn));
+		return NULL;
+	}
+
+	diff = talloc_zero(ctx, struct reg_diff);
+	if (diff == NULL) {
+		close(fd);
+		return NULL;
+	}
+	
+	diff->format = afdgets(fd, diff, 0);
+	if (!diff->format) {
+		talloc_free(diff);
+		close(fd);
+		return NULL;
+	}
+
+	while ((line = afdgets(fd, diff, 0))) {
+		/* Ignore comments and empty lines */
+		if (strlen(line) == 0 || line[0] == ';') {
+			curkey = NULL;
+			talloc_free(line);
+			continue;
+		}
+
+		/* Start of key */
+		if (line[0] == '[') {
+			p = strchr_m(line, ']');
+			if (p[strlen(p)-2] != ']') {
+				DEBUG(0, ("Malformed line\n"));
+				return NULL;
+			}
+			diff->keys = talloc_realloc(diff, diff->keys, struct reg_diff_key, diff->numkeys+2);
+			diff->keys[diff->numkeys].name = talloc_strndup(diff->keys, line+1, strlen(line)-2);
+			diff->keys[diff->numkeys].changetype = REG_DIFF_CHANGE_KEY;
+			diff->keys[diff->numkeys].numvalues = 0;
+			diff->keys[diff->numkeys].values = NULL;
+			curkey = &diff->keys[diff->numkeys];
+			diff->numkeys++;
+			talloc_free(line);
+			continue;
+		}
+
+		/* Deleting key */
+		if (line[0] == '-') {
+			diff->keys = talloc_realloc(diff, diff->keys, struct reg_diff_key, diff->numkeys+2);
+			diff->keys[diff->numkeys].name = talloc_strdup(diff->keys, line+1);
+			diff->keys[diff->numkeys].changetype = REG_DIFF_DEL_KEY;
+			diff->numkeys++;
+			talloc_free(line);
+			continue;
+		}
+
+		/* Deleting/Changing value */
+		p = strchr_m(line, '=');
+		if (p == NULL) {
+			DEBUG(0, ("Malformed line\n"));
+			talloc_free(line);
+			continue;
+		}
+
+		*p = '\0'; p++;
+
+		if (curkey == NULL) {
+			DEBUG(0, ("Value change without key\n"));
+			talloc_free(line);
+			continue;
+		}
+
+		curkey->values = talloc_realloc(diff->keys, curkey->values, struct reg_diff_value, curkey->numvalues+2);
+		curval = &curkey->values[curkey->numvalues];
+		curkey->numvalues++;
+		curval->name = talloc_strdup(curkey->values, line);
+
+		/* Delete value */
+		if (strcmp(p, "-")) {
+			curval->changetype = REG_DIFF_DEL_VAL;
+			talloc_free(line);
+			continue;
+		}
+		
+		q = strchr_m(p, ':');
+		if (q) {
+			*q = '\0'; 
+			q++;
+		}
+
+		curval->changetype = REG_DIFF_SET_VAL;
+		reg_string_to_val(curkey->values, q?p:"REG_SZ", q?q:p, &curval->type, &curval->data);
+
+		talloc_free(line);
+	}
+
+	close(fd);
+
+	return diff;
+}
+
+/* 
+ * Apply diff to a registry context 
+ */
+BOOL reg_diff_apply (const struct reg_diff *diff, struct registry_context *ctx)
+{
+	TALLOC_CTX *mem_ctx = talloc_init("apply_cmd_file");
+	struct registry_key *tmp = NULL;
+	WERROR error;
+	int i, j;
+
+	for (i = 0; i < diff->numkeys; i++) {
+		if (diff->keys[i].changetype == REG_DIFF_DEL_KEY) {
+			error = reg_key_del_abs(ctx, diff->keys[i].name);
+
+			if(!W_ERROR_IS_OK(error)) {
+				DEBUG(0, ("Unable to delete key '%s'\n", diff->keys[i].name));
+				return False;
+		  	}
+
+			continue;
+		}
+
+		/* Add / change key */
+		error = reg_open_key_abs(mem_ctx, ctx, diff->keys[i].name, &tmp);
+
+		/* If we found it, apply the other bits, else create such a key */
+		if (W_ERROR_EQUAL(error, WERR_DEST_NOT_FOUND)) {
+			if(!W_ERROR_IS_OK(reg_key_add_abs(mem_ctx, ctx, diff->keys[i].name, 0, NULL, &tmp))) {
+				DEBUG(0, ("Error adding new key '%s'\n", diff->keys[i].name));
+				return False;
+			}
+		}
+
+		for (j = 0; j < diff->keys[i].numvalues; j++) {
+			if (diff->keys[i].values[j].changetype == REG_DIFF_DEL_VAL) {
+				error = reg_del_value(tmp, diff->keys[i].values[j].name);
+				if (!W_ERROR_IS_OK(error)) {
+					DEBUG(0, ("Error deleting value '%s'\n", diff->keys[i].values[j].name));
+					return False;
+				}
+			
+				error = reg_val_set(tmp, diff->keys[i].values[j].name, 
+							 diff->keys[i].values[j].type,
+							 diff->keys[i].values[j].data);
+				if (!W_ERROR_IS_OK(error)) {
+					DEBUG(0, ("Error setting value '%s'\n", diff->keys[i].values[j].name));
+					return False;
+				}	
+			}
+		}
+	}
+
+	return True;
+}
-- 
cgit 


From 51597d878049daa37fc107d4986b5c558ca381d0 Mon Sep 17 00:00:00 2001
From: Volker Lendecke <vlendec@samba.org>
Date: Sat, 5 Nov 2005 23:09:23 +0000
Subject: r11526: And another warning... (This used to be commit
 16467008c64d84f29bec0ea45767bb1050726b34)

---
 source4/lib/registry/patchfile.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/lib/registry/patchfile.c')

diff --git a/source4/lib/registry/patchfile.c b/source4/lib/registry/patchfile.c
index cdf35c7b70..dd118c780f 100644
--- a/source4/lib/registry/patchfile.c
+++ b/source4/lib/registry/patchfile.c
@@ -257,7 +257,7 @@ struct reg_diff *reg_diff_load(TALLOC_CTX *ctx, const char *fn)
 	struct reg_diff *diff;
 	int fd;
 	char *line, *p, *q;
-	struct reg_diff_key *curkey;
+	struct reg_diff_key *curkey = NULL;
 	struct reg_diff_value *curval;
 
 	fd = open(fn, O_RDONLY, 0);
-- 
cgit 


From 0a3c167f6bcf08b2204ca49831ca49eef73dcbf4 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Tue, 27 Dec 2005 22:51:30 +0000
Subject: r12528: Add seperate proto headers for ntvfs, tdr, smb_server and
 nbt_server. (This used to be commit 87f665a1d5ba74289974bf9d8f9441c162e6f1b1)

---
 source4/lib/registry/patchfile.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'source4/lib/registry/patchfile.c')

diff --git a/source4/lib/registry/patchfile.c b/source4/lib/registry/patchfile.c
index dd118c780f..21c9c26b21 100644
--- a/source4/lib/registry/patchfile.c
+++ b/source4/lib/registry/patchfile.c
@@ -173,7 +173,7 @@ static WERROR reg_generate_diff_key(struct reg_diff *diff, struct registry_key *
 /* 
  * Generate diff between two registry contexts 
  */
-struct reg_diff *reg_generate_diff(TALLOC_CTX *mem_ctx, struct registry_context *ctx1, struct registry_context *ctx2)
+_PUBLIC_ struct reg_diff *reg_generate_diff(TALLOC_CTX *mem_ctx, struct registry_context *ctx1, struct registry_context *ctx2)
 {
 	struct reg_diff *diff = talloc_zero(mem_ctx, struct reg_diff);
 	int i;
@@ -202,7 +202,7 @@ struct reg_diff *reg_generate_diff(TALLOC_CTX *mem_ctx, struct registry_context
 /*
  * Save registry diff
  */
-WERROR reg_diff_save(const struct reg_diff *diff, const char *filename)
+_PUBLIC_ WERROR reg_diff_save(const struct reg_diff *diff, const char *filename)
 {
 	int xf, i, j;
 
@@ -363,7 +363,7 @@ struct reg_diff *reg_diff_load(TALLOC_CTX *ctx, const char *fn)
 /* 
  * Apply diff to a registry context 
  */
-BOOL reg_diff_apply (const struct reg_diff *diff, struct registry_context *ctx)
+_PUBLIC_ BOOL reg_diff_apply (const struct reg_diff *diff, struct registry_context *ctx)
 {
 	TALLOC_CTX *mem_ctx = talloc_init("apply_cmd_file");
 	struct registry_key *tmp = NULL;
-- 
cgit 


From d4de4c2d210d2e8c9b5aedf70695594809ad6a0b Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Fri, 30 Dec 2005 13:16:54 +0000
Subject: r12608: Remove some unused #include lines. (This used to be commit
 70e7449318aa0e9d2639c76730a7d1683b2f4981)

---
 source4/lib/registry/patchfile.c | 2 --
 1 file changed, 2 deletions(-)

(limited to 'source4/lib/registry/patchfile.c')

diff --git a/source4/lib/registry/patchfile.c b/source4/lib/registry/patchfile.c
index 21c9c26b21..e498c296ae 100644
--- a/source4/lib/registry/patchfile.c
+++ b/source4/lib/registry/patchfile.c
@@ -20,9 +20,7 @@
 */
 
 #include "includes.h"
-#include "dynconfig.h"
 #include "lib/registry/registry.h"
-#include "lib/cmdline/popt_common.h"
 #include "system/filesys.h"
 
 #define DEFAULT_IDENT_STRING "SAMBA4 REGISTRY"
-- 
cgit 


From af30a32b6924b0f2b701186e435defbca2ebd1aa Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Sun, 5 Mar 2006 17:15:19 +0000
Subject: r13840: Mark some functions as public. (This used to be commit
 9a188eb1f48a50d92a67a4fc2b3899b90074059a)

---
 source4/lib/registry/patchfile.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/lib/registry/patchfile.c')

diff --git a/source4/lib/registry/patchfile.c b/source4/lib/registry/patchfile.c
index e498c296ae..9a7a8e586f 100644
--- a/source4/lib/registry/patchfile.c
+++ b/source4/lib/registry/patchfile.c
@@ -250,7 +250,7 @@ _PUBLIC_ WERROR reg_diff_save(const struct reg_diff *diff, const char *filename)
 /*
  * Load diff file
  */
-struct reg_diff *reg_diff_load(TALLOC_CTX *ctx, const char *fn)
+_PUBLIC_ struct reg_diff *reg_diff_load(TALLOC_CTX *ctx, const char *fn)
 {
 	struct reg_diff *diff;
 	int fd;
-- 
cgit 


From 1589791b95091ab387acc70ded8a067a836f9779 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Mon, 6 Mar 2006 10:09:53 +0000
Subject: r13855: Docs for the registry library as well (This used to be commit
 ad43464cc1d1fdb59a26e612e0b4ec85ef4a43d2)

---
 source4/lib/registry/patchfile.c | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

(limited to 'source4/lib/registry/patchfile.c')

diff --git a/source4/lib/registry/patchfile.c b/source4/lib/registry/patchfile.c
index 9a7a8e586f..bb37e4bb6a 100644
--- a/source4/lib/registry/patchfile.c
+++ b/source4/lib/registry/patchfile.c
@@ -23,6 +23,11 @@
 #include "lib/registry/registry.h"
 #include "system/filesys.h"
 
+/**
+ * @file
+ * @brief Registry patch files
+ */
+
 #define DEFAULT_IDENT_STRING "SAMBA4 REGISTRY"
 
 static struct reg_diff_key *diff_find_add_key(struct reg_diff *diff, const char *path)
@@ -168,7 +173,7 @@ static WERROR reg_generate_diff_key(struct reg_diff *diff, struct registry_key *
 	return WERR_OK;
 }
 
-/* 
+/**
  * Generate diff between two registry contexts 
  */
 _PUBLIC_ struct reg_diff *reg_generate_diff(TALLOC_CTX *mem_ctx, struct registry_context *ctx1, struct registry_context *ctx2)
@@ -197,7 +202,7 @@ _PUBLIC_ struct reg_diff *reg_generate_diff(TALLOC_CTX *mem_ctx, struct registry
 	return diff;
 }
 
-/*
+/**
  * Save registry diff
  */
 _PUBLIC_ WERROR reg_diff_save(const struct reg_diff *diff, const char *filename)
@@ -247,7 +252,7 @@ _PUBLIC_ WERROR reg_diff_save(const struct reg_diff *diff, const char *filename)
 	return WERR_OK;
 }
 
-/*
+/**
  * Load diff file
  */
 _PUBLIC_ struct reg_diff *reg_diff_load(TALLOC_CTX *ctx, const char *fn)
@@ -358,7 +363,7 @@ _PUBLIC_ struct reg_diff *reg_diff_load(TALLOC_CTX *ctx, const char *fn)
 	return diff;
 }
 
-/* 
+/**
  * Apply diff to a registry context 
  */
 _PUBLIC_ BOOL reg_diff_apply (const struct reg_diff *diff, struct registry_context *ctx)
-- 
cgit 


From d291b8bf933e7595ac2967602d90918c286e3429 Mon Sep 17 00:00:00 2001
From: Andrew Bartlett <abartlet@samba.org>
Date: Wed, 20 Jun 2007 04:15:39 +0000
Subject: r23551: Change data_blob_equal to data_blob_cmp, suitable for sorting
 with qsort().

Andrew Bartlett
(This used to be commit 96ef5259c63ad6245c94c40d6059d736b1534183)
---
 source4/lib/registry/patchfile.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source4/lib/registry/patchfile.c')

diff --git a/source4/lib/registry/patchfile.c b/source4/lib/registry/patchfile.c
index bb37e4bb6a..8bbca07962 100644
--- a/source4/lib/registry/patchfile.c
+++ b/source4/lib/registry/patchfile.c
@@ -125,7 +125,7 @@ static WERROR reg_generate_diff_key(struct reg_diff *diff, struct registry_key *
 			return error2;
 		}
 
-		if (W_ERROR_IS_OK(error2) && data_blob_equal(&v1->data, &v2->data))
+		if (W_ERROR_IS_OK(error2) && data_blob_cmp(&v1->data, &v2->data) == 0)
 			continue;
 
 		thiskey = diff_find_add_key(diff, oldkey->path);
-- 
cgit 


From 0479a2f1cbae51fcd8dbdc3c148c808421fb4d25 Mon Sep 17 00:00:00 2001
From: Andrew Tridgell <tridge@samba.org>
Date: Tue, 10 Jul 2007 02:07:03 +0000
Subject: r23792: convert Samba4 to GPLv3

There are still a few tidyups of old FSF addresses to come (in both s3
and s4). More commits soon.
(This used to be commit fcf38a38ac691abd0fa51b89dc951a08e89fdafa)
---
 source4/lib/registry/patchfile.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

(limited to 'source4/lib/registry/patchfile.c')

diff --git a/source4/lib/registry/patchfile.c b/source4/lib/registry/patchfile.c
index 8bbca07962..12847eedd8 100644
--- a/source4/lib/registry/patchfile.c
+++ b/source4/lib/registry/patchfile.c
@@ -6,7 +6,7 @@
 
    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 2 of the License, or
+   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,
@@ -15,8 +15,7 @@
    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.
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "includes.h"
-- 
cgit 


From b409d4120f9ae451f93a2322267c0f346531d9f3 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Sun, 26 Aug 2007 15:16:40 +0000
Subject: r24667: Finally merge the registry improvements that Wilco Baan
 Hofman and I have been working on for at least half a year now. Contains the
 following improvements:

 * proper layering (finally!) for the registry library. Distinction is
   now made between 'real' backends (local, remote, wine, etc) and
   the low-level hive backends (regf, creg, ldb, ...) that are only used
   by the local registry backend
 * tests for all important hive and registry operations
 * re-enable RPC-WINREG tests (still needs more work though, as
							   some return values aren't checked yet)
 * write support for REGF files
 * dir backend now supports setting/reading values, creating keys
 * support for storing security descriptors
 * remove CREG backend as it was incomplete, didn't match the data model
   and wasn't used at all anyway
 * support for parsing ADM files as used by the policy editor (see lib/policy)
 * support for parsing PREG files (format used by .POL files)
 * new streaming interface for registry diffs (improves speed and memory usage
	for regdiff/regpatch significantly)

   ... and fixes a large number of bugs in the registry code
(This used to be commit 7a1eec6358bc863dfc671c542b7185d3e39d7b5a)
---
 source4/lib/registry/patchfile.c | 561 ++++++++++++++++++++-------------------
 1 file changed, 281 insertions(+), 280 deletions(-)

(limited to 'source4/lib/registry/patchfile.c')

diff --git a/source4/lib/registry/patchfile.c b/source4/lib/registry/patchfile.c
index 12847eedd8..50c8f54397 100644
--- a/source4/lib/registry/patchfile.c
+++ b/source4/lib/registry/patchfile.c
@@ -1,8 +1,9 @@
 /* 
    Unix SMB/CIFS implementation.
-   Reading .REG files
+   Reading registry patch files
    
-   Copyright (C) Jelmer Vernooij 2004
+   Copyright (C) Jelmer Vernooij 2004-2007
+   Copyright (C) Wilco Baan Hofman 2006
 
    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
@@ -19,153 +20,191 @@
 */
 
 #include "includes.h"
+#include "lib/registry/patchfile.h"
 #include "lib/registry/registry.h"
 #include "system/filesys.h"
 
-/**
- * @file
- * @brief Registry patch files
- */
-
-#define DEFAULT_IDENT_STRING "SAMBA4 REGISTRY"
-
-static struct reg_diff_key *diff_find_add_key(struct reg_diff *diff, const char *path)
-{
-	int i;
-	
-	for (i = 0; diff->numkeys; i++) {
-		if (!strcasecmp(diff->keys[i].name, path))
-			return &diff->keys[i];
-	}
 
-	diff->keys = talloc_realloc(diff, diff->keys, struct reg_diff_key, diff->numkeys+2);
-	diff->keys[diff->numkeys].name = talloc_strdup(diff->keys, path);
-	diff->keys[diff->numkeys].changetype = REG_DIFF_CHANGE_KEY;
-	diff->keys[diff->numkeys].numvalues = 0;
-	diff->keys[diff->numkeys].values = NULL;
+_PUBLIC_ WERROR reg_preg_diff_load(int fd, const struct reg_diff_callbacks *callbacks, void *callback_data);
 
-	diff->numkeys++;
-	return NULL;
-}
+_PUBLIC_ WERROR reg_dotreg_diff_load(int fd, const struct reg_diff_callbacks *callbacks, void *callback_data);
 
 /*
  * Generate difference between two keys
  */
-static WERROR reg_generate_diff_key(struct reg_diff *diff, struct registry_key *oldkey, struct registry_key *newkey)
+WERROR reg_generate_diff_key(struct registry_key *oldkey, 
+							 struct registry_key *newkey,
+							 const char *path,
+							 const struct reg_diff_callbacks *callbacks,
+							 void *callback_data)
 {
 	int i;
 	struct registry_key *t1, *t2;
-	struct registry_value *v1, *v2;
-	WERROR error1, error2;
+	char *tmppath;
+	const char *keyname1;
+	WERROR error, error1, error2;
 	TALLOC_CTX *mem_ctx = talloc_init("writediff");
+	uint32_t old_num_subkeys, old_num_values,
+			 new_num_subkeys, new_num_values;
 
-	/* Subkeys that were deleted */
-	for(i = 0; W_ERROR_IS_OK(error1 = reg_key_get_subkey_by_index(mem_ctx, oldkey, i, &t1)); i++) {
-		error2 = reg_key_get_subkey_by_name(mem_ctx, newkey, t1->name, &t2);
+	if (oldkey != NULL) {
+		error = reg_key_get_info(mem_ctx, oldkey, NULL, &old_num_subkeys, &old_num_values,
+								 NULL);
+		if (!W_ERROR_IS_OK(error)) {
+			DEBUG(0, ("Error occured while getting key info: %s\n", 
+					  win_errstr(error)));
+			return error;
+		}
+	} else {
+		old_num_subkeys = 0;
+		old_num_values = 0;
+	}
 
-		if (W_ERROR_IS_OK(error2))
+	/* Subkeys that were deleted */
+	for (i = 0; i < old_num_subkeys; i++) {
+		error1 = reg_key_get_subkey_by_index(mem_ctx, oldkey, i, &keyname1,
+											 NULL, NULL);
+		if (!W_ERROR_IS_OK(error1)) {
+			DEBUG(0, ("Error occured while getting subkey by index: %s\n", 
+					  win_errstr(error2)));
 			continue;
+		}
+
+		if (newkey != NULL) {
+			error2 = reg_open_key(mem_ctx, newkey, keyname1, &t2);
+
+			if (W_ERROR_IS_OK(error2))
+				continue;
+		} else {
+			error2 = WERR_DEST_NOT_FOUND;
+			t2 = NULL;
+		}
 
 		if (!W_ERROR_EQUAL(error2, WERR_DEST_NOT_FOUND)) {
-			DEBUG(0, ("Error occured while getting subkey by name: %d\n", W_ERROR_V(error2)));
+			DEBUG(0, ("Error occured while getting subkey by name: %s\n", 
+					  win_errstr(error2)));
+			talloc_free(mem_ctx);
 			return error2;
 		}
 
 		/* newkey didn't have such a subkey, add del diff */
-		diff->keys = talloc_realloc(diff, diff->keys, struct reg_diff_key, diff->numkeys+2);
-		diff->keys[diff->numkeys].name = talloc_strdup(diff->keys, t1->path);
-		diff->keys[diff->numkeys].changetype = REG_DIFF_DEL_KEY;
-		diff->numkeys++;
+		tmppath = talloc_asprintf(mem_ctx, "%s\\%s", path, keyname1);
+		callbacks->del_key(callback_data, tmppath);
+		talloc_free(tmppath);	
 	}
 
-	if(!W_ERROR_EQUAL(error1, WERR_NO_MORE_ITEMS)) {
-		DEBUG(0, ("Error occured while getting subkey by index: %d\n", W_ERROR_V(error1)));
-		talloc_free(mem_ctx);
-		return error1;
+	if (newkey != NULL) {
+		error = reg_key_get_info(mem_ctx, newkey, NULL, &new_num_subkeys, &new_num_values,
+								 NULL);
+		if (!W_ERROR_IS_OK(error)) {
+			DEBUG(0, ("Error occured while getting key info: %s\n", 
+					  win_errstr(error)));
+			return error;
+		}
+	} else {
+		new_num_subkeys = 0;
+		new_num_values = 0;
 	}
 
 	/* Subkeys that were added */
-	for(i = 0; W_ERROR_IS_OK(error1 = reg_key_get_subkey_by_index(mem_ctx, newkey, i, &t1)); i++) {
-		error2 = reg_key_get_subkey_by_name(mem_ctx, oldkey, t1->name, &t2);
+	for(i = 0; i < new_num_subkeys; i++) {
+		error1 = reg_key_get_subkey_by_index(mem_ctx, newkey, i, &keyname1, 
+											 NULL, NULL);
+		if (!W_ERROR_IS_OK(error1)) {
+			DEBUG(0, ("Error occured while getting subkey by index: %s\n", 
+					  win_errstr(error1)));
+			talloc_free(mem_ctx);
+			return error1;
+		}
+
+		if (oldkey != NULL) {
+			error2 = reg_open_key(mem_ctx, oldkey, keyname1, &t1);
+				
+			if (W_ERROR_IS_OK(error2))
+				continue;
+		} else {
+			t1 = NULL;
+			error2 = WERR_DEST_NOT_FOUND;
+		}
 			
-		if (W_ERROR_IS_OK(error2))
-			continue;
-		
 		if (!W_ERROR_EQUAL(error2, WERR_DEST_NOT_FOUND)) {
-			DEBUG(0, ("Error occured while getting subkey by name: %d\n", W_ERROR_V(error2)));
+			DEBUG(0, ("Error occured while getting subkey by name: %s\n", 
+					  win_errstr(error2)));
+			talloc_free(mem_ctx);
 			return error2;
 		}
 
 		/* oldkey didn't have such a subkey, add add diff */
-		diff->keys = talloc_realloc(diff, diff->keys, struct reg_diff_key, diff->numkeys+2);
-		diff->keys[diff->numkeys].name = talloc_strdup(diff->keys, t1->path);
-		diff->keys[diff->numkeys].changetype = REG_DIFF_CHANGE_KEY;
-		diff->keys[diff->numkeys].numvalues = 0;
-		diff->keys[diff->numkeys].values = NULL;
-		diff->numkeys++;
-
-		reg_generate_diff_key(diff, t1, t2);
-	}
+		tmppath = talloc_asprintf(mem_ctx, "%s\\%s", path, keyname1);
+		callbacks->add_key(callback_data, tmppath);
 
-	if(!W_ERROR_EQUAL(error1, WERR_NO_MORE_ITEMS)) {
-		DEBUG(0, ("Error occured while getting subkey by index: %d\n", W_ERROR_V(error1)));
-		talloc_free(mem_ctx);
-		return error1;
+		W_ERROR_NOT_OK_RETURN(
+				reg_open_key(mem_ctx, newkey, keyname1, &t2));
+
+		reg_generate_diff_key(t1, t2, tmppath, callbacks, callback_data);
+		talloc_free(tmppath);
 	}
 
 	/* Values that were changed */
-	for(i = 0; W_ERROR_IS_OK(error1 = reg_key_get_value_by_index(mem_ctx, newkey, i, &v1)); i++) {
-		struct reg_diff_key *thiskey = NULL;
-		error2 = reg_key_get_value_by_name(mem_ctx, oldkey, v1->name, &v2);
+	for(i = 0; i < new_num_values; i++) {
+		const char *name;
+		uint32_t type1, type2;
+		DATA_BLOB contents1, contents2;
+
+		error1 = reg_key_get_value_by_index(mem_ctx, newkey, i, 
+											&name, &type1, &contents1);
+		if (!W_ERROR_IS_OK(error1)) {
+			DEBUG(0, ("Unable to get key by index: %s\n", 
+					  win_errstr(error1)));
+			talloc_free(mem_ctx);
+			return error1;
+		}
+
+		if (oldkey != NULL) {
+			error2 = reg_key_get_value_by_name(mem_ctx, oldkey, name, 
+										   &type2, &contents2);
+		} else 
+			error2 = WERR_DEST_NOT_FOUND;
 	
 		if(!W_ERROR_IS_OK(error2) && 
 		   !W_ERROR_EQUAL(error2, WERR_DEST_NOT_FOUND)) {
-			DEBUG(0, ("Error occured while getting value by name: %d\n", W_ERROR_V(error2)));
+			DEBUG(0, ("Error occured while getting value by name: %s\n", 
+					  win_errstr(error2)));
+			talloc_free(mem_ctx);
 			return error2;
 		}
 
-		if (W_ERROR_IS_OK(error2) && data_blob_cmp(&v1->data, &v2->data) == 0)
+		if (W_ERROR_IS_OK(error2) && data_blob_cmp(&contents1, &contents2) == 0)
 			continue;
 
-		thiskey = diff_find_add_key(diff, oldkey->path);
-		thiskey->values = talloc_realloc(diff, thiskey->values, struct reg_diff_value, thiskey->numvalues+2);
-		thiskey->values[thiskey->numvalues].name = talloc_strdup(thiskey->values, v1->name);
-		thiskey->values[thiskey->numvalues].type = v2->data_type;
-		thiskey->values[thiskey->numvalues].changetype = REG_DIFF_SET_VAL;
-		thiskey->values[thiskey->numvalues].data = data_blob_dup_talloc(thiskey->values, &v2->data);
-		thiskey->numvalues++;
-	}
-
-	if(!W_ERROR_EQUAL(error1, WERR_NO_MORE_ITEMS)) {
-		DEBUG(0, ("Error occured while getting value by index: %d\n", W_ERROR_V(error1)));
-		talloc_free(mem_ctx);
-		return error1;
+		callbacks->set_value(callback_data, path, name, type1, contents1);
 	}
 
 	/* Values that were deleted */
-	for(i = 0; W_ERROR_IS_OK(error1 = reg_key_get_value_by_index(mem_ctx, oldkey, i, &v1)); i++) {
-		struct reg_diff_key *thiskey = NULL;
-		error2 = reg_key_get_value_by_name(mem_ctx, newkey, v1->name, &v2);
+	for (i = 0; i < old_num_values; i++) {
+		const char *name;
+		error1 = reg_key_get_value_by_index(mem_ctx, oldkey, i, &name, 
+											NULL, NULL);
+		if (!W_ERROR_IS_OK(error1)) {
+			DEBUG(0, ("Error ocurred getting value by index: %s\n", 
+					  win_errstr(error1)));
+			talloc_free(mem_ctx);
+			return error1;
+		}
+
+		error2 = reg_key_get_value_by_name(mem_ctx, newkey, name, NULL, 
+										   NULL);
 
 		if (W_ERROR_IS_OK(error2))
 			continue;
 
 		if (!W_ERROR_EQUAL(error2, WERR_DEST_NOT_FOUND)) {
-			DEBUG(0, ("Error occured while getting value by name: %d\n", W_ERROR_V(error2)));
+			DEBUG(0, ("Error occured while getting value by name: %s\n", 
+					  win_errstr(error2)));
 			return error2;
 		}
 
-		thiskey = diff_find_add_key(diff, oldkey->path);
-		thiskey->values = talloc_realloc(diff, thiskey->values, struct reg_diff_value, thiskey->numvalues+2);
-		thiskey->values[thiskey->numvalues].name = talloc_strdup(thiskey->values, v1->name);
-		thiskey->values[thiskey->numvalues].changetype = REG_DIFF_DEL_VAL;
-		thiskey->numvalues++;
-	}
-
-	if(!W_ERROR_EQUAL(error1, WERR_NO_MORE_ITEMS)) {
-		DEBUG(0, ("Error occured while getting value by index: %d\n", W_ERROR_V(error1)));
-		talloc_free(mem_ctx);
-		return error1;
+		callbacks->del_value(callback_data, path, name);
 	}
 
 	talloc_free(mem_ctx);
@@ -175,244 +214,206 @@ static WERROR reg_generate_diff_key(struct reg_diff *diff, struct registry_key *
 /**
  * Generate diff between two registry contexts 
  */
-_PUBLIC_ struct reg_diff *reg_generate_diff(TALLOC_CTX *mem_ctx, struct registry_context *ctx1, struct registry_context *ctx2)
+_PUBLIC_ WERROR reg_generate_diff(struct registry_context *ctx1, 
+				  struct registry_context *ctx2, 
+				  const struct reg_diff_callbacks *callbacks,
+				  void *callback_data)
 {
-	struct reg_diff *diff = talloc_zero(mem_ctx, struct reg_diff);
 	int i;
 	WERROR error;
 
-	for(i = HKEY_CLASSES_ROOT; i <= HKEY_PERFORMANCE_NLSTEXT; i++) {
-		struct registry_key *r1, *r2;
+	for(i = HKEY_FIRST; i <= HKEY_LAST; i++) {
+		struct registry_key *r1 = NULL, *r2 = NULL;
 		error = reg_get_predefined_key(ctx1, i, &r1);
-		if (!W_ERROR_IS_OK(error)) {
+		if (!W_ERROR_IS_OK(error) && !W_ERROR_EQUAL(error, WERR_NOT_FOUND)) {
 			DEBUG(0, ("Unable to open hive %s for backend 1\n", reg_get_predef_name(i)));
-			continue;
 		}
 		
 		error = reg_get_predefined_key(ctx2, i, &r2);
-		if (!W_ERROR_IS_OK(error)) {
+		if (!W_ERROR_IS_OK(error) && !W_ERROR_EQUAL(error, WERR_NOT_FOUND)) {
 			DEBUG(0, ("Unable to open hive %s for backend 2\n", reg_get_predef_name(i)));
-			continue;
 		}
 
-		reg_generate_diff_key(diff, r1, r2);
-	}
-
-	return diff;
-}
-
-/**
- * Save registry diff
- */
-_PUBLIC_ WERROR reg_diff_save(const struct reg_diff *diff, const char *filename)
-{
-	int xf, i, j;
-
-	if (filename) {
-		xf = open(filename, O_CREAT, 0755);
-		if (xf == -1) {
-			DEBUG(0, ("Unable to open %s\n", filename));
-			return WERR_BADFILE;
-		}
-	} else 
-		xf = STDIN_FILENO;
-
-	fdprintf(xf, "%s\n\n", diff->format?diff->format:DEFAULT_IDENT_STRING);
-
-	for (i = 0; i < diff->numkeys; i++) {
-		if (diff->keys[i].changetype == REG_DIFF_DEL_KEY) {
-			fdprintf(xf, "-%s\n\n",  diff->keys[i].name);
+		if (r1 == NULL && r2 == NULL)
 			continue;
-		}
 
-		fdprintf(xf, "[%s]\n", diff->keys[i].name);
-
-		for (j = 0; j < diff->keys[i].numvalues; j++) {
-			fdprintf(xf, "\"%s\"=", diff->keys[i].values[j].name);
-			switch (diff->keys[i].values[j].changetype) {
-				case REG_DIFF_DEL_VAL:
-					fdprintf(xf, "-\n");
-					break;
-				case REG_DIFF_SET_VAL:
-					fdprintf(xf, "%s:%s\n", 
-							 str_regtype(diff->keys[i].values[j].type), 
-							 reg_val_data_string(NULL, 
-								diff->keys[i].values[j].type, 
-								&diff->keys[i].values[j].data));
-					break;
-			}
+		error = reg_generate_diff_key(r1, r2, reg_get_predef_name(i), callbacks, callback_data);
+		if (!W_ERROR_IS_OK(error)) {
+			DEBUG(0, ("Unable to determine diff: %s\n", win_errstr(error)));
+			return error;
 		}
-
-		fdprintf(xf, "\n");
 	}
-
-	close(xf);
-
+	if (callbacks->done != NULL) {
+		callbacks->done(callback_data);
+	}
 	return WERR_OK;
 }
 
 /**
  * Load diff file
  */
-_PUBLIC_ struct reg_diff *reg_diff_load(TALLOC_CTX *ctx, const char *fn)
+_PUBLIC_ WERROR reg_diff_load(const char *filename, const struct reg_diff_callbacks *callbacks, void *callback_data)
 {
-	struct reg_diff *diff;
 	int fd;
-	char *line, *p, *q;
-	struct reg_diff_key *curkey = NULL;
-	struct reg_diff_value *curval;
-
-	fd = open(fn, O_RDONLY, 0);
+	char hdr[4];
+	
+	fd = open(filename, O_RDONLY, 0);
 	if (fd == -1) {
-		DEBUG(0, ("Error opening registry patch file `%s'\n", fn));
-		return NULL;
+		DEBUG(0, ("Error opening registry patch file `%s'\n", filename));
+		return WERR_GENERAL_FAILURE;
 	}
 
-	diff = talloc_zero(ctx, struct reg_diff);
-	if (diff == NULL) {
-		close(fd);
-		return NULL;
+	if (read(fd, &hdr, 4) != 4) {
+		DEBUG(0, ("Error reading registry patch file `%s'\n", filename));
+		return WERR_GENERAL_FAILURE;
 	}
-	
-	diff->format = afdgets(fd, diff, 0);
-	if (!diff->format) {
-		talloc_free(diff);
-		close(fd);
-		return NULL;
+
+	/* Reset position in file */
+	lseek(fd, 0, SEEK_SET);
+#if 0
+	if (strncmp(hdr, "CREG", 4) == 0) {
+		/* Must be a W9x CREG Config.pol file */
+		return reg_creg_diff_load(diff, fd);
+	} else if (strncmp(hdr, "regf", 4) == 0) {
+		/* Must be a REGF NTConfig.pol file */
+		return reg_regf_diff_load(diff, fd);
+	} else 
+#endif 
+	if (strncmp(hdr, "PReg", 4) == 0) {
+		/* Must be a GPO Registry.pol file */
+		return reg_preg_diff_load(fd, callbacks, callback_data);
+	} else {
+		/* Must be a normal .REG file */
+		return reg_dotreg_diff_load(fd, callbacks, callback_data);
 	}
+}
 
-	while ((line = afdgets(fd, diff, 0))) {
-		/* Ignore comments and empty lines */
-		if (strlen(line) == 0 || line[0] == ';') {
-			curkey = NULL;
-			talloc_free(line);
-			continue;
-		}
+/**
+ * The reg_diff_apply functions
+ */
+static WERROR reg_diff_apply_add_key(void *_ctx, const char *key_name) 
+{
+	struct registry_context *ctx = _ctx;
+	struct registry_key *tmp;
+	WERROR error;
 
-		/* Start of key */
-		if (line[0] == '[') {
-			p = strchr_m(line, ']');
-			if (p[strlen(p)-2] != ']') {
-				DEBUG(0, ("Malformed line\n"));
-				return NULL;
-			}
-			diff->keys = talloc_realloc(diff, diff->keys, struct reg_diff_key, diff->numkeys+2);
-			diff->keys[diff->numkeys].name = talloc_strndup(diff->keys, line+1, strlen(line)-2);
-			diff->keys[diff->numkeys].changetype = REG_DIFF_CHANGE_KEY;
-			diff->keys[diff->numkeys].numvalues = 0;
-			diff->keys[diff->numkeys].values = NULL;
-			curkey = &diff->keys[diff->numkeys];
-			diff->numkeys++;
-			talloc_free(line);
-			continue;
-		}
+	error = reg_key_add_abs(ctx, ctx, key_name, 0, NULL, &tmp);
 
-		/* Deleting key */
-		if (line[0] == '-') {
-			diff->keys = talloc_realloc(diff, diff->keys, struct reg_diff_key, diff->numkeys+2);
-			diff->keys[diff->numkeys].name = talloc_strdup(diff->keys, line+1);
-			diff->keys[diff->numkeys].changetype = REG_DIFF_DEL_KEY;
-			diff->numkeys++;
-			talloc_free(line);
-			continue;
-		}
+	if (!W_ERROR_EQUAL(error, WERR_ALREADY_EXISTS) && !W_ERROR_IS_OK(error)) {
+		DEBUG(0, ("Error adding new key '%s': %s\n", key_name, win_errstr(error)));
+		return error;
+	}
+	return WERR_OK;
+}
 
-		/* Deleting/Changing value */
-		p = strchr_m(line, '=');
-		if (p == NULL) {
-			DEBUG(0, ("Malformed line\n"));
-			talloc_free(line);
-			continue;
-		}
+static WERROR reg_diff_apply_del_key(void *_ctx, const char *key_name) 
+{
+	struct registry_context *ctx = _ctx;
+	WERROR error;
 
-		*p = '\0'; p++;
+	error = reg_key_del_abs(ctx, key_name);
 
-		if (curkey == NULL) {
-			DEBUG(0, ("Value change without key\n"));
-			talloc_free(line);
-			continue;
-		}
+	if(!W_ERROR_IS_OK(error)) {
+		DEBUG(0, ("Unable to delete key '%s'\n", key_name));
+		return error;
+	}
+	
+	return WERR_OK;
+}
 
-		curkey->values = talloc_realloc(diff->keys, curkey->values, struct reg_diff_value, curkey->numvalues+2);
-		curval = &curkey->values[curkey->numvalues];
-		curkey->numvalues++;
-		curval->name = talloc_strdup(curkey->values, line);
+static WERROR reg_diff_apply_set_value(void *_ctx, const char *path, const char *value_name, uint32_t value_type, DATA_BLOB value)
+{
+	struct registry_context *ctx = _ctx;
+	struct registry_key *tmp;
+	WERROR error;
+	
+	/* Open key */
+	error = reg_open_key_abs(ctx, ctx, path, &tmp);
 
-		/* Delete value */
-		if (strcmp(p, "-")) {
-			curval->changetype = REG_DIFF_DEL_VAL;
-			talloc_free(line);
-			continue;
-		}
-		
-		q = strchr_m(p, ':');
-		if (q) {
-			*q = '\0'; 
-			q++;
-		}
+	if (W_ERROR_EQUAL(error, WERR_DEST_NOT_FOUND)) {
+		DEBUG(0, ("Error opening key '%s'\n", path));
+		return error;
+	}
 
-		curval->changetype = REG_DIFF_SET_VAL;
-		reg_string_to_val(curkey->values, q?p:"REG_SZ", q?q:p, &curval->type, &curval->data);
+	/* Set value */
+	error = reg_val_set(tmp, value_name, 
+				 value_type, value);
+	if (!W_ERROR_IS_OK(error)) {
+		DEBUG(0, ("Error setting value '%s'\n", value_name));
+		return error;
+	}	
+	
+	return WERR_OK;
+}
 
-		talloc_free(line);
+static WERROR reg_diff_apply_del_value (void *_ctx, const char *key_name, const char *value_name)
+{
+	struct registry_context *ctx = _ctx;
+	struct registry_key *tmp;
+	WERROR error;
+	
+	/* Open key */
+	error = reg_open_key_abs(ctx, ctx, key_name, &tmp);
+
+	if (!W_ERROR_IS_OK(error)) {
+		DEBUG(0, ("Error opening key '%s'\n", key_name));
+		return error;
 	}
 
-	close(fd);
+	error = reg_del_value(tmp, value_name);
+	if (!W_ERROR_IS_OK(error)) {
+		DEBUG(0, ("Error deleting value '%s'\n", value_name));
+		return error;
+	}
+	
 
-	return diff;
+	return WERR_OK;
 }
 
-/**
- * Apply diff to a registry context 
- */
-_PUBLIC_ BOOL reg_diff_apply (const struct reg_diff *diff, struct registry_context *ctx)
+static WERROR reg_diff_apply_del_all_values(void *_ctx, const char *key_name)
 {
-	TALLOC_CTX *mem_ctx = talloc_init("apply_cmd_file");
-	struct registry_key *tmp = NULL;
+	struct registry_context *ctx = _ctx;
+	struct registry_key *key;
 	WERROR error;
-	int i, j;
+	int i;
+	uint32_t num_values;
 
-	for (i = 0; i < diff->numkeys; i++) {
-		if (diff->keys[i].changetype == REG_DIFF_DEL_KEY) {
-			error = reg_key_del_abs(ctx, diff->keys[i].name);
+	error = reg_open_key_abs(ctx, ctx, key_name, &key);
 
-			if(!W_ERROR_IS_OK(error)) {
-				DEBUG(0, ("Unable to delete key '%s'\n", diff->keys[i].name));
-				return False;
-		  	}
+	if (!W_ERROR_IS_OK(error)) {
+		DEBUG(0, ("Error opening key '%s'\n", key_name));
+		return error;
+	}
 
-			continue;
-		}
+	W_ERROR_NOT_OK_RETURN(reg_key_get_info(ctx, key, 
+										   NULL, 
+										   NULL,
+										   &num_values, 
+										   NULL));
+
+	for (i = 0; i < num_values; i++) {
+		const char *name;
+		W_ERROR_NOT_OK_RETURN(reg_key_get_value_by_index(ctx, key, i, &name, 
+														 NULL, NULL));
+		W_ERROR_NOT_OK_RETURN(reg_del_value(key, name));
+	}
 
-		/* Add / change key */
-		error = reg_open_key_abs(mem_ctx, ctx, diff->keys[i].name, &tmp);
+	return WERR_OK;
+}
 
-		/* If we found it, apply the other bits, else create such a key */
-		if (W_ERROR_EQUAL(error, WERR_DEST_NOT_FOUND)) {
-			if(!W_ERROR_IS_OK(reg_key_add_abs(mem_ctx, ctx, diff->keys[i].name, 0, NULL, &tmp))) {
-				DEBUG(0, ("Error adding new key '%s'\n", diff->keys[i].name));
-				return False;
-			}
-		}
+/** 
+ * Apply diff to a registry context 
+ */
+_PUBLIC_ WERROR reg_diff_apply (const char *filename, struct registry_context *ctx)
+{
+	struct reg_diff_callbacks callbacks;
 
-		for (j = 0; j < diff->keys[i].numvalues; j++) {
-			if (diff->keys[i].values[j].changetype == REG_DIFF_DEL_VAL) {
-				error = reg_del_value(tmp, diff->keys[i].values[j].name);
-				if (!W_ERROR_IS_OK(error)) {
-					DEBUG(0, ("Error deleting value '%s'\n", diff->keys[i].values[j].name));
-					return False;
-				}
-			
-				error = reg_val_set(tmp, diff->keys[i].values[j].name, 
-							 diff->keys[i].values[j].type,
-							 diff->keys[i].values[j].data);
-				if (!W_ERROR_IS_OK(error)) {
-					DEBUG(0, ("Error setting value '%s'\n", diff->keys[i].values[j].name));
-					return False;
-				}	
-			}
-		}
-	}
+	callbacks.add_key = reg_diff_apply_add_key;
+	callbacks.del_key = reg_diff_apply_del_key;
+	callbacks.set_value = reg_diff_apply_set_value;
+	callbacks.del_value = reg_diff_apply_del_value;
+	callbacks.del_all_values = reg_diff_apply_del_all_values;
+	callbacks.done = NULL;
 
-	return True;
+	return reg_diff_load(filename, &callbacks, ctx);
 }
-- 
cgit 


From 2edf63b6d647eba131e213bd9dbc543100396930 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Mon, 27 Aug 2007 13:13:08 +0000
Subject: r24703: Use standard registry diff files when provisioning rather
 than LDIF files for the registry files. (This used to be commit
 67ad556b7388e5d82756e0a3cfc596e44136329c)

---
 source4/lib/registry/patchfile.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'source4/lib/registry/patchfile.c')

diff --git a/source4/lib/registry/patchfile.c b/source4/lib/registry/patchfile.c
index 50c8f54397..8df873d56b 100644
--- a/source4/lib/registry/patchfile.c
+++ b/source4/lib/registry/patchfile.c
@@ -252,7 +252,9 @@ _PUBLIC_ WERROR reg_generate_diff(struct registry_context *ctx1,
 /**
  * Load diff file
  */
-_PUBLIC_ WERROR reg_diff_load(const char *filename, const struct reg_diff_callbacks *callbacks, void *callback_data)
+_PUBLIC_ WERROR reg_diff_load(const char *filename, 
+							  const struct reg_diff_callbacks *callbacks, 
+							  void *callback_data)
 {
 	int fd;
 	char hdr[4];
-- 
cgit 


From 6cf69fee189857ae6f85cd3f81a6a58364839942 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Fri, 7 Sep 2007 13:31:15 +0000
Subject: r24994: Fix some C++ warnings. (This used to be commit
 925abf74fa1ed5ae726bae8781ec549302786b39)

---
 source4/lib/registry/patchfile.c | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

(limited to 'source4/lib/registry/patchfile.c')

diff --git a/source4/lib/registry/patchfile.c b/source4/lib/registry/patchfile.c
index 8df873d56b..99887c67bf 100644
--- a/source4/lib/registry/patchfile.c
+++ b/source4/lib/registry/patchfile.c
@@ -253,8 +253,8 @@ _PUBLIC_ WERROR reg_generate_diff(struct registry_context *ctx1,
  * Load diff file
  */
 _PUBLIC_ WERROR reg_diff_load(const char *filename, 
-							  const struct reg_diff_callbacks *callbacks, 
-							  void *callback_data)
+			      const struct reg_diff_callbacks *callbacks, 
+			      void *callback_data)
 {
 	int fd;
 	char hdr[4];
@@ -295,7 +295,7 @@ _PUBLIC_ WERROR reg_diff_load(const char *filename,
  */
 static WERROR reg_diff_apply_add_key(void *_ctx, const char *key_name) 
 {
-	struct registry_context *ctx = _ctx;
+	struct registry_context *ctx = (struct registry_context *)_ctx;
 	struct registry_key *tmp;
 	WERROR error;
 
@@ -310,7 +310,7 @@ static WERROR reg_diff_apply_add_key(void *_ctx, const char *key_name)
 
 static WERROR reg_diff_apply_del_key(void *_ctx, const char *key_name) 
 {
-	struct registry_context *ctx = _ctx;
+	struct registry_context *ctx = (struct registry_context *)_ctx;
 	WERROR error;
 
 	error = reg_key_del_abs(ctx, key_name);
@@ -325,7 +325,7 @@ static WERROR reg_diff_apply_del_key(void *_ctx, const char *key_name)
 
 static WERROR reg_diff_apply_set_value(void *_ctx, const char *path, const char *value_name, uint32_t value_type, DATA_BLOB value)
 {
-	struct registry_context *ctx = _ctx;
+	struct registry_context *ctx = (struct registry_context *)_ctx;
 	struct registry_key *tmp;
 	WERROR error;
 	
@@ -350,7 +350,7 @@ static WERROR reg_diff_apply_set_value(void *_ctx, const char *path, const char
 
 static WERROR reg_diff_apply_del_value (void *_ctx, const char *key_name, const char *value_name)
 {
-	struct registry_context *ctx = _ctx;
+	struct registry_context *ctx = (struct registry_context *)_ctx;
 	struct registry_key *tmp;
 	WERROR error;
 	
@@ -374,7 +374,7 @@ static WERROR reg_diff_apply_del_value (void *_ctx, const char *key_name, const
 
 static WERROR reg_diff_apply_del_all_values(void *_ctx, const char *key_name)
 {
-	struct registry_context *ctx = _ctx;
+	struct registry_context *ctx = (struct registry_context *)_ctx;
 	struct registry_key *key;
 	WERROR error;
 	int i;
-- 
cgit 


From cc8f4eb3cd9b3bc4e3f3d61bfad240147e8a4e5e Mon Sep 17 00:00:00 2001
From: Günther Deschner <gd@samba.org>
Date: Sat, 6 Oct 2007 00:17:44 +0000
Subject: r25544: Cleanup some more indents in lib/registry.

Guenther
(This used to be commit 0d9826dc54057db2cfebcb806e5442c4dcf60daa)
---
 source4/lib/registry/patchfile.c | 219 ++++++++++++++++++++++-----------------
 1 file changed, 123 insertions(+), 96 deletions(-)

(limited to 'source4/lib/registry/patchfile.c')

diff --git a/source4/lib/registry/patchfile.c b/source4/lib/registry/patchfile.c
index 99887c67bf..e5d9a26618 100644
--- a/source4/lib/registry/patchfile.c
+++ b/source4/lib/registry/patchfile.c
@@ -1,7 +1,7 @@
-/* 
+/*
    Unix SMB/CIFS implementation.
    Reading registry patch files
-   
+
    Copyright (C) Jelmer Vernooij 2004-2007
    Copyright (C) Wilco Baan Hofman 2006
 
@@ -9,12 +9,12 @@
    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, see <http://www.gnu.org/licenses/>.
 */
@@ -25,18 +25,22 @@
 #include "system/filesys.h"
 
 
-_PUBLIC_ WERROR reg_preg_diff_load(int fd, const struct reg_diff_callbacks *callbacks, void *callback_data);
+_PUBLIC_ WERROR reg_preg_diff_load(int fd,
+				   const struct reg_diff_callbacks *callbacks,
+				   void *callback_data);
 
-_PUBLIC_ WERROR reg_dotreg_diff_load(int fd, const struct reg_diff_callbacks *callbacks, void *callback_data);
+_PUBLIC_ WERROR reg_dotreg_diff_load(int fd,
+				     const struct reg_diff_callbacks *callbacks,
+				     void *callback_data);
 
 /*
  * Generate difference between two keys
  */
-WERROR reg_generate_diff_key(struct registry_key *oldkey, 
-							 struct registry_key *newkey,
-							 const char *path,
-							 const struct reg_diff_callbacks *callbacks,
-							 void *callback_data)
+WERROR reg_generate_diff_key(struct registry_key *oldkey,
+			     struct registry_key *newkey,
+			     const char *path,
+			     const struct reg_diff_callbacks *callbacks,
+			     void *callback_data)
 {
 	int i;
 	struct registry_key *t1, *t2;
@@ -48,11 +52,12 @@ WERROR reg_generate_diff_key(struct registry_key *oldkey,
 			 new_num_subkeys, new_num_values;
 
 	if (oldkey != NULL) {
-		error = reg_key_get_info(mem_ctx, oldkey, NULL, &old_num_subkeys, &old_num_values,
-								 NULL);
+		error = reg_key_get_info(mem_ctx, oldkey, NULL,
+					 &old_num_subkeys, &old_num_values,
+					 NULL);
 		if (!W_ERROR_IS_OK(error)) {
-			DEBUG(0, ("Error occured while getting key info: %s\n", 
-					  win_errstr(error)));
+			DEBUG(0, ("Error occured while getting key info: %s\n",
+				win_errstr(error)));
 			return error;
 		}
 	} else {
@@ -62,11 +67,12 @@ WERROR reg_generate_diff_key(struct registry_key *oldkey,
 
 	/* Subkeys that were deleted */
 	for (i = 0; i < old_num_subkeys; i++) {
-		error1 = reg_key_get_subkey_by_index(mem_ctx, oldkey, i, &keyname1,
-											 NULL, NULL);
+		error1 = reg_key_get_subkey_by_index(mem_ctx, oldkey, i,
+						     &keyname1,
+						     NULL, NULL);
 		if (!W_ERROR_IS_OK(error1)) {
-			DEBUG(0, ("Error occured while getting subkey by index: %s\n", 
-					  win_errstr(error2)));
+			DEBUG(0, ("Error occured while getting subkey by index: %s\n",
+				win_errstr(error2)));
 			continue;
 		}
 
@@ -81,8 +87,8 @@ WERROR reg_generate_diff_key(struct registry_key *oldkey,
 		}
 
 		if (!W_ERROR_EQUAL(error2, WERR_DEST_NOT_FOUND)) {
-			DEBUG(0, ("Error occured while getting subkey by name: %s\n", 
-					  win_errstr(error2)));
+			DEBUG(0, ("Error occured while getting subkey by name: %s\n",
+				win_errstr(error2)));
 			talloc_free(mem_ctx);
 			return error2;
 		}
@@ -90,15 +96,16 @@ WERROR reg_generate_diff_key(struct registry_key *oldkey,
 		/* newkey didn't have such a subkey, add del diff */
 		tmppath = talloc_asprintf(mem_ctx, "%s\\%s", path, keyname1);
 		callbacks->del_key(callback_data, tmppath);
-		talloc_free(tmppath);	
+		talloc_free(tmppath);
 	}
 
 	if (newkey != NULL) {
-		error = reg_key_get_info(mem_ctx, newkey, NULL, &new_num_subkeys, &new_num_values,
-								 NULL);
+		error = reg_key_get_info(mem_ctx, newkey, NULL,
+					 &new_num_subkeys, &new_num_values,
+					 NULL);
 		if (!W_ERROR_IS_OK(error)) {
-			DEBUG(0, ("Error occured while getting key info: %s\n", 
-					  win_errstr(error)));
+			DEBUG(0, ("Error occured while getting key info: %s\n",
+				win_errstr(error)));
 			return error;
 		}
 	} else {
@@ -108,28 +115,29 @@ WERROR reg_generate_diff_key(struct registry_key *oldkey,
 
 	/* Subkeys that were added */
 	for(i = 0; i < new_num_subkeys; i++) {
-		error1 = reg_key_get_subkey_by_index(mem_ctx, newkey, i, &keyname1, 
-											 NULL, NULL);
+		error1 = reg_key_get_subkey_by_index(mem_ctx, newkey,
+						     i, &keyname1,
+						     NULL, NULL);
 		if (!W_ERROR_IS_OK(error1)) {
-			DEBUG(0, ("Error occured while getting subkey by index: %s\n", 
-					  win_errstr(error1)));
+			DEBUG(0, ("Error occured while getting subkey by index: %s\n",
+				win_errstr(error1)));
 			talloc_free(mem_ctx);
 			return error1;
 		}
 
 		if (oldkey != NULL) {
 			error2 = reg_open_key(mem_ctx, oldkey, keyname1, &t1);
-				
+
 			if (W_ERROR_IS_OK(error2))
 				continue;
 		} else {
 			t1 = NULL;
 			error2 = WERR_DEST_NOT_FOUND;
 		}
-			
+
 		if (!W_ERROR_EQUAL(error2, WERR_DEST_NOT_FOUND)) {
-			DEBUG(0, ("Error occured while getting subkey by name: %s\n", 
-					  win_errstr(error2)));
+			DEBUG(0, ("Error occured while getting subkey by name: %s\n",
+				win_errstr(error2)));
 			talloc_free(mem_ctx);
 			return error2;
 		}
@@ -141,7 +149,8 @@ WERROR reg_generate_diff_key(struct registry_key *oldkey,
 		W_ERROR_NOT_OK_RETURN(
 				reg_open_key(mem_ctx, newkey, keyname1, &t2));
 
-		reg_generate_diff_key(t1, t2, tmppath, callbacks, callback_data);
+		reg_generate_diff_key(t1, t2, tmppath,
+				      callbacks, callback_data);
 		talloc_free(tmppath);
 	}
 
@@ -151,56 +160,59 @@ WERROR reg_generate_diff_key(struct registry_key *oldkey,
 		uint32_t type1, type2;
 		DATA_BLOB contents1, contents2;
 
-		error1 = reg_key_get_value_by_index(mem_ctx, newkey, i, 
-											&name, &type1, &contents1);
+		error1 = reg_key_get_value_by_index(mem_ctx, newkey, i,
+						    &name, &type1, &contents1);
 		if (!W_ERROR_IS_OK(error1)) {
-			DEBUG(0, ("Unable to get key by index: %s\n", 
-					  win_errstr(error1)));
+			DEBUG(0, ("Unable to get key by index: %s\n",
+				win_errstr(error1)));
 			talloc_free(mem_ctx);
 			return error1;
 		}
 
 		if (oldkey != NULL) {
-			error2 = reg_key_get_value_by_name(mem_ctx, oldkey, name, 
-										   &type2, &contents2);
-		} else 
+			error2 = reg_key_get_value_by_name(mem_ctx, oldkey,
+							   name, &type2,
+							   &contents2);
+		} else
 			error2 = WERR_DEST_NOT_FOUND;
-	
-		if(!W_ERROR_IS_OK(error2) && 
+
+		if(!W_ERROR_IS_OK(error2) &&
 		   !W_ERROR_EQUAL(error2, WERR_DEST_NOT_FOUND)) {
-			DEBUG(0, ("Error occured while getting value by name: %s\n", 
-					  win_errstr(error2)));
+			DEBUG(0, ("Error occured while getting value by name: %s\n",
+				win_errstr(error2)));
 			talloc_free(mem_ctx);
 			return error2;
 		}
 
-		if (W_ERROR_IS_OK(error2) && data_blob_cmp(&contents1, &contents2) == 0)
+		if (W_ERROR_IS_OK(error2) &&
+		    data_blob_cmp(&contents1, &contents2) == 0)
 			continue;
 
-		callbacks->set_value(callback_data, path, name, type1, contents1);
+		callbacks->set_value(callback_data, path, name,
+				     type1, contents1);
 	}
 
 	/* Values that were deleted */
 	for (i = 0; i < old_num_values; i++) {
 		const char *name;
-		error1 = reg_key_get_value_by_index(mem_ctx, oldkey, i, &name, 
-											NULL, NULL);
+		error1 = reg_key_get_value_by_index(mem_ctx, oldkey, i, &name,
+						    NULL, NULL);
 		if (!W_ERROR_IS_OK(error1)) {
-			DEBUG(0, ("Error ocurred getting value by index: %s\n", 
-					  win_errstr(error1)));
+			DEBUG(0, ("Error ocurred getting value by index: %s\n",
+				win_errstr(error1)));
 			talloc_free(mem_ctx);
 			return error1;
 		}
 
-		error2 = reg_key_get_value_by_name(mem_ctx, newkey, name, NULL, 
-										   NULL);
+		error2 = reg_key_get_value_by_name(mem_ctx, newkey, name, NULL,
+						   NULL);
 
 		if (W_ERROR_IS_OK(error2))
 			continue;
 
 		if (!W_ERROR_EQUAL(error2, WERR_DEST_NOT_FOUND)) {
-			DEBUG(0, ("Error occured while getting value by name: %s\n", 
-					  win_errstr(error2)));
+			DEBUG(0, ("Error occured while getting value by name: %s\n",
+				win_errstr(error2)));
 			return error2;
 		}
 
@@ -212,10 +224,10 @@ WERROR reg_generate_diff_key(struct registry_key *oldkey,
 }
 
 /**
- * Generate diff between two registry contexts 
+ * Generate diff between two registry contexts
  */
-_PUBLIC_ WERROR reg_generate_diff(struct registry_context *ctx1, 
-				  struct registry_context *ctx2, 
+_PUBLIC_ WERROR reg_generate_diff(struct registry_context *ctx1,
+				  struct registry_context *ctx2,
 				  const struct reg_diff_callbacks *callbacks,
 				  void *callback_data)
 {
@@ -225,21 +237,27 @@ _PUBLIC_ WERROR reg_generate_diff(struct registry_context *ctx1,
 	for(i = HKEY_FIRST; i <= HKEY_LAST; i++) {
 		struct registry_key *r1 = NULL, *r2 = NULL;
 		error = reg_get_predefined_key(ctx1, i, &r1);
-		if (!W_ERROR_IS_OK(error) && !W_ERROR_EQUAL(error, WERR_NOT_FOUND)) {
-			DEBUG(0, ("Unable to open hive %s for backend 1\n", reg_get_predef_name(i)));
+		if (!W_ERROR_IS_OK(error) &&
+		    !W_ERROR_EQUAL(error, WERR_NOT_FOUND)) {
+			DEBUG(0, ("Unable to open hive %s for backend 1\n",
+				reg_get_predef_name(i)));
 		}
-		
+
 		error = reg_get_predefined_key(ctx2, i, &r2);
-		if (!W_ERROR_IS_OK(error) && !W_ERROR_EQUAL(error, WERR_NOT_FOUND)) {
-			DEBUG(0, ("Unable to open hive %s for backend 2\n", reg_get_predef_name(i)));
+		if (!W_ERROR_IS_OK(error) &&
+		    !W_ERROR_EQUAL(error, WERR_NOT_FOUND)) {
+			DEBUG(0, ("Unable to open hive %s for backend 2\n",
+				reg_get_predef_name(i)));
 		}
 
 		if (r1 == NULL && r2 == NULL)
 			continue;
 
-		error = reg_generate_diff_key(r1, r2, reg_get_predef_name(i), callbacks, callback_data);
+		error = reg_generate_diff_key(r1, r2, reg_get_predef_name(i),
+					      callbacks, callback_data);
 		if (!W_ERROR_IS_OK(error)) {
-			DEBUG(0, ("Unable to determine diff: %s\n", win_errstr(error)));
+			DEBUG(0, ("Unable to determine diff: %s\n",
+				win_errstr(error)));
 			return error;
 		}
 	}
@@ -252,21 +270,23 @@ _PUBLIC_ WERROR reg_generate_diff(struct registry_context *ctx1,
 /**
  * Load diff file
  */
-_PUBLIC_ WERROR reg_diff_load(const char *filename, 
-			      const struct reg_diff_callbacks *callbacks, 
+_PUBLIC_ WERROR reg_diff_load(const char *filename,
+			      const struct reg_diff_callbacks *callbacks,
 			      void *callback_data)
 {
 	int fd;
 	char hdr[4];
-	
+
 	fd = open(filename, O_RDONLY, 0);
 	if (fd == -1) {
-		DEBUG(0, ("Error opening registry patch file `%s'\n", filename));
+		DEBUG(0, ("Error opening registry patch file `%s'\n",
+			filename));
 		return WERR_GENERAL_FAILURE;
 	}
 
 	if (read(fd, &hdr, 4) != 4) {
-		DEBUG(0, ("Error reading registry patch file `%s'\n", filename));
+		DEBUG(0, ("Error reading registry patch file `%s'\n",
+			filename));
 		return WERR_GENERAL_FAILURE;
 	}
 
@@ -279,8 +299,8 @@ _PUBLIC_ WERROR reg_diff_load(const char *filename,
 	} else if (strncmp(hdr, "regf", 4) == 0) {
 		/* Must be a REGF NTConfig.pol file */
 		return reg_regf_diff_load(diff, fd);
-	} else 
-#endif 
+	} else
+#endif
 	if (strncmp(hdr, "PReg", 4) == 0) {
 		/* Must be a GPO Registry.pol file */
 		return reg_preg_diff_load(fd, callbacks, callback_data);
@@ -293,7 +313,7 @@ _PUBLIC_ WERROR reg_diff_load(const char *filename,
 /**
  * The reg_diff_apply functions
  */
-static WERROR reg_diff_apply_add_key(void *_ctx, const char *key_name) 
+static WERROR reg_diff_apply_add_key(void *_ctx, const char *key_name)
 {
 	struct registry_context *ctx = (struct registry_context *)_ctx;
 	struct registry_key *tmp;
@@ -301,14 +321,16 @@ static WERROR reg_diff_apply_add_key(void *_ctx, const char *key_name)
 
 	error = reg_key_add_abs(ctx, ctx, key_name, 0, NULL, &tmp);
 
-	if (!W_ERROR_EQUAL(error, WERR_ALREADY_EXISTS) && !W_ERROR_IS_OK(error)) {
-		DEBUG(0, ("Error adding new key '%s': %s\n", key_name, win_errstr(error)));
+	if (!W_ERROR_EQUAL(error, WERR_ALREADY_EXISTS) &&
+	    !W_ERROR_IS_OK(error)) {
+		DEBUG(0, ("Error adding new key '%s': %s\n",
+			key_name, win_errstr(error)));
 		return error;
 	}
 	return WERR_OK;
 }
 
-static WERROR reg_diff_apply_del_key(void *_ctx, const char *key_name) 
+static WERROR reg_diff_apply_del_key(void *_ctx, const char *key_name)
 {
 	struct registry_context *ctx = (struct registry_context *)_ctx;
 	WERROR error;
@@ -319,16 +341,18 @@ static WERROR reg_diff_apply_del_key(void *_ctx, const char *key_name)
 		DEBUG(0, ("Unable to delete key '%s'\n", key_name));
 		return error;
 	}
-	
+
 	return WERR_OK;
 }
 
-static WERROR reg_diff_apply_set_value(void *_ctx, const char *path, const char *value_name, uint32_t value_type, DATA_BLOB value)
+static WERROR reg_diff_apply_set_value(void *_ctx, const char *path,
+				       const char *value_name,
+				       uint32_t value_type, DATA_BLOB value)
 {
 	struct registry_context *ctx = (struct registry_context *)_ctx;
 	struct registry_key *tmp;
 	WERROR error;
-	
+
 	/* Open key */
 	error = reg_open_key_abs(ctx, ctx, path, &tmp);
 
@@ -338,22 +362,23 @@ static WERROR reg_diff_apply_set_value(void *_ctx, const char *path, const char
 	}
 
 	/* Set value */
-	error = reg_val_set(tmp, value_name, 
+	error = reg_val_set(tmp, value_name,
 				 value_type, value);
 	if (!W_ERROR_IS_OK(error)) {
 		DEBUG(0, ("Error setting value '%s'\n", value_name));
 		return error;
-	}	
-	
+	}
+
 	return WERR_OK;
 }
 
-static WERROR reg_diff_apply_del_value (void *_ctx, const char *key_name, const char *value_name)
+static WERROR reg_diff_apply_del_value(void *_ctx, const char *key_name,
+				       const char *value_name)
 {
 	struct registry_context *ctx = (struct registry_context *)_ctx;
 	struct registry_key *tmp;
 	WERROR error;
-	
+
 	/* Open key */
 	error = reg_open_key_abs(ctx, ctx, key_name, &tmp);
 
@@ -367,7 +392,7 @@ static WERROR reg_diff_apply_del_value (void *_ctx, const char *key_name, const
 		DEBUG(0, ("Error deleting value '%s'\n", value_name));
 		return error;
 	}
-	
+
 
 	return WERR_OK;
 }
@@ -387,26 +412,28 @@ static WERROR reg_diff_apply_del_all_values(void *_ctx, const char *key_name)
 		return error;
 	}
 
-	W_ERROR_NOT_OK_RETURN(reg_key_get_info(ctx, key, 
-										   NULL, 
-										   NULL,
-										   &num_values, 
-										   NULL));
+	W_ERROR_NOT_OK_RETURN(reg_key_get_info(ctx, key,
+					       NULL,
+					       NULL,
+					       &num_values,
+					       NULL));
 
 	for (i = 0; i < num_values; i++) {
 		const char *name;
-		W_ERROR_NOT_OK_RETURN(reg_key_get_value_by_index(ctx, key, i, &name, 
-														 NULL, NULL));
+		W_ERROR_NOT_OK_RETURN(reg_key_get_value_by_index(ctx, key, i,
+								 &name,
+								 NULL, NULL));
 		W_ERROR_NOT_OK_RETURN(reg_del_value(key, name));
 	}
 
 	return WERR_OK;
 }
 
-/** 
- * Apply diff to a registry context 
+/**
+ * Apply diff to a registry context
  */
-_PUBLIC_ WERROR reg_diff_apply (const char *filename, struct registry_context *ctx)
+_PUBLIC_ WERROR reg_diff_apply(const char *filename,
+			       struct registry_context *ctx)
 {
 	struct reg_diff_callbacks callbacks;
 
-- 
cgit 


From 670918f916cb881d4cc591516c70bafe4e39ba45 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Sat, 22 Dec 2007 05:02:48 -0600
Subject: r26563: Fix reg_diff_apply argument order. (This used to be commit
 cfffd0357ee4c4bb3f3c9adb051eeee1bbac526a)

---
 source4/lib/registry/patchfile.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'source4/lib/registry/patchfile.c')

diff --git a/source4/lib/registry/patchfile.c b/source4/lib/registry/patchfile.c
index e5d9a26618..8a417d5935 100644
--- a/source4/lib/registry/patchfile.c
+++ b/source4/lib/registry/patchfile.c
@@ -432,8 +432,7 @@ static WERROR reg_diff_apply_del_all_values(void *_ctx, const char *key_name)
 /**
  * Apply diff to a registry context
  */
-_PUBLIC_ WERROR reg_diff_apply(const char *filename,
-			       struct registry_context *ctx)
+_PUBLIC_ WERROR reg_diff_apply(struct registry_context *ctx, const char *filename)
 {
 	struct reg_diff_callbacks callbacks;
 
-- 
cgit 


From 47f6bbf8cf5bdd03c72c59d00e3e1eab8895590e Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Mon, 7 Jan 2008 14:11:29 -0600
Subject: r26689: registry: Return max_subkeynamelen, max_valnamelen and
 max_valbufsize in getkeyinfo(). (This used to be commit
 b06896d2378e536f5044dbe500a5232a89d6d0b5)

---
 source4/lib/registry/patchfile.c | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

(limited to 'source4/lib/registry/patchfile.c')

diff --git a/source4/lib/registry/patchfile.c b/source4/lib/registry/patchfile.c
index 8a417d5935..b6ad7dfb10 100644
--- a/source4/lib/registry/patchfile.c
+++ b/source4/lib/registry/patchfile.c
@@ -54,7 +54,7 @@ WERROR reg_generate_diff_key(struct registry_key *oldkey,
 	if (oldkey != NULL) {
 		error = reg_key_get_info(mem_ctx, oldkey, NULL,
 					 &old_num_subkeys, &old_num_values,
-					 NULL);
+					 NULL, NULL, NULL, NULL);
 		if (!W_ERROR_IS_OK(error)) {
 			DEBUG(0, ("Error occured while getting key info: %s\n",
 				win_errstr(error)));
@@ -102,7 +102,7 @@ WERROR reg_generate_diff_key(struct registry_key *oldkey,
 	if (newkey != NULL) {
 		error = reg_key_get_info(mem_ctx, newkey, NULL,
 					 &new_num_subkeys, &new_num_values,
-					 NULL);
+					 NULL, NULL, NULL, NULL);
 		if (!W_ERROR_IS_OK(error)) {
 			DEBUG(0, ("Error occured while getting key info: %s\n",
 				win_errstr(error)));
@@ -412,11 +412,8 @@ static WERROR reg_diff_apply_del_all_values(void *_ctx, const char *key_name)
 		return error;
 	}
 
-	W_ERROR_NOT_OK_RETURN(reg_key_get_info(ctx, key,
-					       NULL,
-					       NULL,
-					       &num_values,
-					       NULL));
+	W_ERROR_NOT_OK_RETURN(reg_key_get_info(ctx, key, NULL,
+			       NULL, &num_values, NULL, NULL, NULL, NULL));
 
 	for (i = 0; i < num_values; i++) {
 		const char *name;
-- 
cgit 


From 85d60d2d091a2eb6bd4c73c87c94b10ee93167ee Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Fri, 18 Jan 2008 02:45:00 +0100
Subject: registry: Improve error codes and update tests.

Rather than map the error returned by the registry to the correct error,
return the correct error in the first place.

Also deal with the fact that the right error code is now returned in a
couple of places.
(This used to be commit 1e31fcb8a097810a97e2d4bb1f243f1b34cc2415)
---
 source4/lib/registry/patchfile.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'source4/lib/registry/patchfile.c')

diff --git a/source4/lib/registry/patchfile.c b/source4/lib/registry/patchfile.c
index b6ad7dfb10..d859bc3134 100644
--- a/source4/lib/registry/patchfile.c
+++ b/source4/lib/registry/patchfile.c
@@ -132,10 +132,10 @@ WERROR reg_generate_diff_key(struct registry_key *oldkey,
 				continue;
 		} else {
 			t1 = NULL;
-			error2 = WERR_DEST_NOT_FOUND;
+			error2 = WERR_NOT_FOUND;
 		}
 
-		if (!W_ERROR_EQUAL(error2, WERR_DEST_NOT_FOUND)) {
+		if (!W_ERROR_EQUAL(error2, WERR_NOT_FOUND)) {
 			DEBUG(0, ("Error occured while getting subkey by name: %s\n",
 				win_errstr(error2)));
 			talloc_free(mem_ctx);
@@ -174,10 +174,10 @@ WERROR reg_generate_diff_key(struct registry_key *oldkey,
 							   name, &type2,
 							   &contents2);
 		} else
-			error2 = WERR_DEST_NOT_FOUND;
+			error2 = WERR_BADFILE;
 
 		if(!W_ERROR_IS_OK(error2) &&
-		   !W_ERROR_EQUAL(error2, WERR_DEST_NOT_FOUND)) {
+		   !W_ERROR_EQUAL(error2, WERR_BADFILE)) {
 			DEBUG(0, ("Error occured while getting value by name: %s\n",
 				win_errstr(error2)));
 			talloc_free(mem_ctx);
@@ -210,7 +210,7 @@ WERROR reg_generate_diff_key(struct registry_key *oldkey,
 		if (W_ERROR_IS_OK(error2))
 			continue;
 
-		if (!W_ERROR_EQUAL(error2, WERR_DEST_NOT_FOUND)) {
+		if (!W_ERROR_EQUAL(error2, WERR_BADFILE)) {
 			DEBUG(0, ("Error occured while getting value by name: %s\n",
 				win_errstr(error2)));
 			return error2;
-- 
cgit 


From 55ad09a01b31f2d2c9503f744b519e089f9f936b Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Fri, 18 Jan 2008 03:37:06 +0100
Subject: registry: Use correct return values. (This used to be commit
 98ebdbe52fd615ea62a3caa17acfe8bb31b8f85d)

---
 source4/lib/registry/patchfile.c | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

(limited to 'source4/lib/registry/patchfile.c')

diff --git a/source4/lib/registry/patchfile.c b/source4/lib/registry/patchfile.c
index d859bc3134..fa1367bbd2 100644
--- a/source4/lib/registry/patchfile.c
+++ b/source4/lib/registry/patchfile.c
@@ -82,11 +82,11 @@ WERROR reg_generate_diff_key(struct registry_key *oldkey,
 			if (W_ERROR_IS_OK(error2))
 				continue;
 		} else {
-			error2 = WERR_DEST_NOT_FOUND;
+			error2 = WERR_BADFILE;
 			t2 = NULL;
 		}
 
-		if (!W_ERROR_EQUAL(error2, WERR_DEST_NOT_FOUND)) {
+		if (!W_ERROR_EQUAL(error2, WERR_BADFILE)) {
 			DEBUG(0, ("Error occured while getting subkey by name: %s\n",
 				win_errstr(error2)));
 			talloc_free(mem_ctx);
@@ -132,10 +132,10 @@ WERROR reg_generate_diff_key(struct registry_key *oldkey,
 				continue;
 		} else {
 			t1 = NULL;
-			error2 = WERR_NOT_FOUND;
+			error2 = WERR_BADFILE;
 		}
 
-		if (!W_ERROR_EQUAL(error2, WERR_NOT_FOUND)) {
+		if (!W_ERROR_EQUAL(error2, WERR_BADFILE)) {
 			DEBUG(0, ("Error occured while getting subkey by name: %s\n",
 				win_errstr(error2)));
 			talloc_free(mem_ctx);
@@ -238,14 +238,14 @@ _PUBLIC_ WERROR reg_generate_diff(struct registry_context *ctx1,
 		struct registry_key *r1 = NULL, *r2 = NULL;
 		error = reg_get_predefined_key(ctx1, i, &r1);
 		if (!W_ERROR_IS_OK(error) &&
-		    !W_ERROR_EQUAL(error, WERR_NOT_FOUND)) {
+		    !W_ERROR_EQUAL(error, WERR_BADFILE)) {
 			DEBUG(0, ("Unable to open hive %s for backend 1\n",
 				reg_get_predef_name(i)));
 		}
 
 		error = reg_get_predefined_key(ctx2, i, &r2);
 		if (!W_ERROR_IS_OK(error) &&
-		    !W_ERROR_EQUAL(error, WERR_NOT_FOUND)) {
+		    !W_ERROR_EQUAL(error, WERR_BADFILE)) {
 			DEBUG(0, ("Unable to open hive %s for backend 2\n",
 				reg_get_predef_name(i)));
 		}
@@ -356,7 +356,7 @@ static WERROR reg_diff_apply_set_value(void *_ctx, const char *path,
 	/* Open key */
 	error = reg_open_key_abs(ctx, ctx, path, &tmp);
 
-	if (W_ERROR_EQUAL(error, WERR_DEST_NOT_FOUND)) {
+	if (W_ERROR_EQUAL(error, WERR_BADFILE)) {
 		DEBUG(0, ("Error opening key '%s'\n", path));
 		return error;
 	}
-- 
cgit 


From 48307b54f95395fbd201d92d738b482f80cd15ef Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Thu, 21 Feb 2008 16:01:19 +0100
Subject: Remove more uses of global_loadparm. (This used to be commit
 3430cc60972b94d0d238bc39f473feed96949c5d)

---
 source4/lib/registry/patchfile.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'source4/lib/registry/patchfile.c')

diff --git a/source4/lib/registry/patchfile.c b/source4/lib/registry/patchfile.c
index fa1367bbd2..a4579010cd 100644
--- a/source4/lib/registry/patchfile.c
+++ b/source4/lib/registry/patchfile.c
@@ -23,6 +23,7 @@
 #include "lib/registry/patchfile.h"
 #include "lib/registry/registry.h"
 #include "system/filesys.h"
+#include "param/param.h"
 
 
 _PUBLIC_ WERROR reg_preg_diff_load(int fd,
@@ -30,6 +31,7 @@ _PUBLIC_ WERROR reg_preg_diff_load(int fd,
 				   void *callback_data);
 
 _PUBLIC_ WERROR reg_dotreg_diff_load(int fd,
+				     struct smb_iconv_convenience *iconv_convenience,
 				     const struct reg_diff_callbacks *callbacks,
 				     void *callback_data);
 
@@ -306,7 +308,7 @@ _PUBLIC_ WERROR reg_diff_load(const char *filename,
 		return reg_preg_diff_load(fd, callbacks, callback_data);
 	} else {
 		/* Must be a normal .REG file */
-		return reg_dotreg_diff_load(fd, callbacks, callback_data);
+		return reg_dotreg_diff_load(fd, lp_iconv_convenience(global_loadparm), callbacks, callback_data);
 	}
 }
 
-- 
cgit 


From 299265d47b5b2faac39fbf908c738f336ea21e67 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Thu, 21 Feb 2008 18:09:47 +0100
Subject: Remove yet more global_loadparm instances. (This used to be commit
 5de88728ac5c567d3711d1ac6862bbdaced84b75)

---
 source4/lib/registry/patchfile.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

(limited to 'source4/lib/registry/patchfile.c')

diff --git a/source4/lib/registry/patchfile.c b/source4/lib/registry/patchfile.c
index a4579010cd..7903bea246 100644
--- a/source4/lib/registry/patchfile.c
+++ b/source4/lib/registry/patchfile.c
@@ -273,6 +273,7 @@ _PUBLIC_ WERROR reg_generate_diff(struct registry_context *ctx1,
  * Load diff file
  */
 _PUBLIC_ WERROR reg_diff_load(const char *filename,
+			      struct smb_iconv_convenience *iconv_convenience,
 			      const struct reg_diff_callbacks *callbacks,
 			      void *callback_data)
 {
@@ -308,7 +309,7 @@ _PUBLIC_ WERROR reg_diff_load(const char *filename,
 		return reg_preg_diff_load(fd, callbacks, callback_data);
 	} else {
 		/* Must be a normal .REG file */
-		return reg_dotreg_diff_load(fd, lp_iconv_convenience(global_loadparm), callbacks, callback_data);
+		return reg_dotreg_diff_load(fd, iconv_convenience, callbacks, callback_data);
 	}
 }
 
@@ -442,5 +443,6 @@ _PUBLIC_ WERROR reg_diff_apply(struct registry_context *ctx, const char *filenam
 	callbacks.del_all_values = reg_diff_apply_del_all_values;
 	callbacks.done = NULL;
 
-	return reg_diff_load(filename, &callbacks, ctx);
+	return reg_diff_load(filename, lp_iconv_convenience(global_loadparm), 
+			     &callbacks, ctx);
 }
-- 
cgit 


From 3101cb888d5cbad785050b8491b138d683d444fb Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Mon, 25 Feb 2008 12:51:55 +0100
Subject: Remove uses of global_loadparm. (This used to be commit
 a16c9a2129ce92e7e1a613b2badd168e42ead436)

---
 source4/lib/registry/patchfile.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'source4/lib/registry/patchfile.c')

diff --git a/source4/lib/registry/patchfile.c b/source4/lib/registry/patchfile.c
index 7903bea246..687fd4b91b 100644
--- a/source4/lib/registry/patchfile.c
+++ b/source4/lib/registry/patchfile.c
@@ -27,6 +27,7 @@
 
 
 _PUBLIC_ WERROR reg_preg_diff_load(int fd,
+				   struct smb_iconv_convenience *iconv_convenience, 
 				   const struct reg_diff_callbacks *callbacks,
 				   void *callback_data);
 
@@ -306,7 +307,7 @@ _PUBLIC_ WERROR reg_diff_load(const char *filename,
 #endif
 	if (strncmp(hdr, "PReg", 4) == 0) {
 		/* Must be a GPO Registry.pol file */
-		return reg_preg_diff_load(fd, callbacks, callback_data);
+		return reg_preg_diff_load(fd, iconv_convenience, callbacks, callback_data);
 	} else {
 		/* Must be a normal .REG file */
 		return reg_dotreg_diff_load(fd, iconv_convenience, callbacks, callback_data);
-- 
cgit 


From 5be50a222facee943edae868e39ff11f7dd68965 Mon Sep 17 00:00:00 2001
From: Jelmer Vernooij <jelmer@samba.org>
Date: Wed, 2 Apr 2008 13:58:05 +0200
Subject: Merge patchfile.h into registry.h (This used to be commit
 7b434df67aefc667993f0ebd955af9c1c258f153)

---
 source4/lib/registry/patchfile.c | 1 -
 1 file changed, 1 deletion(-)

(limited to 'source4/lib/registry/patchfile.c')

diff --git a/source4/lib/registry/patchfile.c b/source4/lib/registry/patchfile.c
index 687fd4b91b..15e3a158f2 100644
--- a/source4/lib/registry/patchfile.c
+++ b/source4/lib/registry/patchfile.c
@@ -20,7 +20,6 @@
 */
 
 #include "includes.h"
-#include "lib/registry/patchfile.h"
 #include "lib/registry/registry.h"
 #include "system/filesys.h"
 #include "param/param.h"
-- 
cgit 


From 0b8d2b3cb779463a1e24039300ac2669862f9b64 Mon Sep 17 00:00:00 2001
From: Wilco Baan Hofman <wilco@synlap.(none)>
Date: Tue, 15 Apr 2008 11:52:33 +0200
Subject: Fixed the patchfile tests and tidy up the patchfile backends. (This
 used to be commit 6e9b1e35a269af2eda79356c1525f5413656d648)

---
 source4/lib/registry/patchfile.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'source4/lib/registry/patchfile.c')

diff --git a/source4/lib/registry/patchfile.c b/source4/lib/registry/patchfile.c
index 15e3a158f2..eaeef341bb 100644
--- a/source4/lib/registry/patchfile.c
+++ b/source4/lib/registry/patchfile.c
@@ -45,7 +45,7 @@ WERROR reg_generate_diff_key(struct registry_key *oldkey,
 			     void *callback_data)
 {
 	int i;
-	struct registry_key *t1, *t2;
+	struct registry_key *t1 = NULL, *t2 = NULL;
 	char *tmppath;
 	const char *keyname1;
 	WERROR error, error1, error2;
@@ -295,7 +295,7 @@ _PUBLIC_ WERROR reg_diff_load(const char *filename,
 
 	/* Reset position in file */
 	lseek(fd, 0, SEEK_SET);
-#if 0
+#if 0 /* These backends are not supported yet. */
 	if (strncmp(hdr, "CREG", 4) == 0) {
 		/* Must be a W9x CREG Config.pol file */
 		return reg_creg_diff_load(diff, fd);
-- 
cgit 


From 5e687d79533684949deb9bd9bc86f88eab4ae310 Mon Sep 17 00:00:00 2001
From: Wilco Baan Hofman <wilco@synlap.(none)>
Date: Tue, 15 Apr 2008 19:57:29 +0200
Subject: Fix PReg write support. Add tests for patch files (.REG and PReg).
 (This used to be commit 497977c36c621a4820be51cbcb7b78eac1e292b7)

---
 source4/lib/registry/patchfile.c | 23 ++++++++++++++++++++++-
 1 file changed, 22 insertions(+), 1 deletion(-)

(limited to 'source4/lib/registry/patchfile.c')

diff --git a/source4/lib/registry/patchfile.c b/source4/lib/registry/patchfile.c
index eaeef341bb..0ede3106f0 100644
--- a/source4/lib/registry/patchfile.c
+++ b/source4/lib/registry/patchfile.c
@@ -320,12 +320,33 @@ static WERROR reg_diff_apply_add_key(void *_ctx, const char *key_name)
 {
 	struct registry_context *ctx = (struct registry_context *)_ctx;
 	struct registry_key *tmp;
+	char *buf, *buf_ptr;
 	WERROR error;
 
+	/* Recursively create the path */
+	buf = talloc_strdup(ctx, key_name);
+	buf_ptr = buf;
+
+	while (*buf_ptr++ != '\0' ) {
+		if (*buf_ptr == '\\') {
+			*buf_ptr = '\0';
+			error = reg_key_add_abs(ctx, ctx, buf, 0, NULL, &tmp);
+
+			if (!W_ERROR_EQUAL(error, WERR_ALREADY_EXISTS) &&
+				    !W_ERROR_IS_OK(error)) {
+				DEBUG(0, ("Error adding new key '%s': %s\n",
+					key_name, win_errstr(error)));
+				return error;
+			}
+			*buf_ptr++ = '\\';
+		}
+	}
+
+	/* Add the key */
 	error = reg_key_add_abs(ctx, ctx, key_name, 0, NULL, &tmp);
 
 	if (!W_ERROR_EQUAL(error, WERR_ALREADY_EXISTS) &&
-	    !W_ERROR_IS_OK(error)) {
+		    !W_ERROR_IS_OK(error)) {
 		DEBUG(0, ("Error adding new key '%s': %s\n",
 			key_name, win_errstr(error)));
 		return error;
-- 
cgit