Changeset 740 for vendor/current/source4/lib/registry

Timestamp:

Nov 14, 2012, 12:59:34 PM (13 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: update vendor to 3.6.0

Location:

vendor/current/source4/lib/registry

Files:

• config.mk (deleted)
• dir.c (modified) (17 diffs)
• hive.c (modified) (3 diffs)
• interface.c (modified) (9 diffs)
• ldb.c (modified) (39 diffs)
• local.c (modified) (10 diffs)
• man/regdiff.1.xml (modified) (1 diff)
• man/regpatch.1.xml (modified) (1 diff)
• man/regshell.1.xml (modified) (1 diff)
• man/regtree.1.xml (modified) (1 diff)
• patchfile.c (modified) (28 diffs)
• patchfile_dotreg.c (modified) (13 diffs)
• patchfile_preg.c (modified) (12 diffs)
• pyregistry.c (modified) (16 diffs)
• regf.c (modified) (71 diffs)
• regf.idl (modified) (2 diffs)
• registry.h (modified) (17 diffs)
• registry.pc.in (modified) (1 diff)
• rpc.c (modified) (24 diffs)
• samba.c (modified) (2 diffs)
• tests/bindings.py (deleted)
• tests/diff.c (modified) (8 diffs)
• tests/generic.c (modified) (8 diffs)
• tests/hive.c (modified) (17 diffs)
• tests/registry.c (modified) (5 diffs)
• tools/regdiff.c (modified) (1 diff)
• tools/regpatch.c (modified) (1 diff)
• tools/regshell.c (modified) (16 diffs)
• tools/regtree.c (modified) (5 diffs)
• util.c (modified) (12 diffs)
• wscript_build (added)

vendor/current/source4/lib/registry/dir.c

@@ -41 +41 @@
 
         path = talloc_asprintf(mem_ctx, "%s/%s", dk->path, name);
+        W_ERROR_HAVE_NO_MEMORY(path);
         ret = mkdir(path, 0700);
         if (ret == 0) {
                 struct dir_key *key = talloc(mem_ctx, struct dir_key);
+                W_ERROR_HAVE_NO_MEMORY(key);
                 key->key.ops = &reg_backend_dir;
                 key->path = talloc_steal(key, path);
@@ -77 +79 @@
 
                 path = talloc_asprintf(name, "%s/%s", name, e->d_name);
-                if (!path)
-                        return WERR_NOMEM;
+                W_ERROR_HAVE_NO_MEMORY(path);
 
                 stat(path, &stbuf);
@@ -109 +110 @@
 }
 
-static WERROR reg_dir_del_key(const struct hive_key *k, const char *name)
+static WERROR reg_dir_del_key(TALLOC_CTX *mem_ctx, const struct hive_key *k,
+                              const char *name)
 {
         struct dir_key *dk = talloc_get_type(k, struct dir_key);
-        char *child = talloc_asprintf(NULL, "%s/%s", dk->path, name);
+        char *child;
         WERROR ret;
+
+        child = talloc_asprintf(mem_ctx, "%s/%s", dk->path, name);
+        W_ERROR_HAVE_NO_MEMORY(child);
 
         ret = reg_dir_delete_recursive(child);
@@ -137 +142 @@
 
         fullpath = talloc_asprintf(mem_ctx, "%s/%s", p->path, name);
+        W_ERROR_HAVE_NO_MEMORY(fullpath);
 
         d = opendir(fullpath);
@@ -142 +148 @@
                 DEBUG(3,("Unable to open '%s': %s\n", fullpath,
                         strerror(errno)));
+                talloc_free(fullpath);
                 return WERR_BADFILE;
         }
@@ -160 +167 @@
         struct dirent *e;
         const struct dir_key *dk = talloc_get_type(k, struct dir_key);
-        int i = 0;
+        unsigned int i = 0;
         DIR *d;
 
@@ -174 +181 @@
 
                         /* Check if file is a directory */
-                        asprintf(&thispath, "%s/%s", dk->path, e->d_name);
+                        thispath = talloc_asprintf(mem_ctx, "%s/%s", dk->path,
+                                                   e->d_name);
+                        W_ERROR_HAVE_NO_MEMORY(thispath);
                         stat(thispath, &stbuf);
 
                         if (!S_ISDIR(stbuf.st_mode)) {
-                                SAFE_FREE(thispath);
+                                talloc_free(thispath);
                                 continue;
                         }
@@ -185 +194 @@
                                 struct stat st;
                                 *name = talloc_strdup(mem_ctx, e->d_name);
+                                W_ERROR_HAVE_NO_MEMORY(*name);
                                 *classname = NULL;
                                 stat(thispath, &st);
                                 unix_to_nt_time(last_mod_time, st.st_mtime);
-                                SAFE_FREE(thispath);
+                                talloc_free(thispath);
                                 closedir(d);
                                 return WERR_OK;
@@ -194 +204 @@
                         i++;
 
-                        SAFE_FREE(thispath);
+                        talloc_free(thispath);
                 }
         }
@@ -212 +222 @@
 
         dk = talloc(parent_ctx, struct dir_key);
+        W_ERROR_HAVE_NO_MEMORY(dk);
         dk->key.ops = &reg_backend_dir;
         dk->path = talloc_strdup(dk, location);
@@ -271 +282 @@
                         char *path = talloc_asprintf(ctx, "%s/%s",
                                                      dk->path, e->d_name);
+                        W_ERROR_HAVE_NO_MEMORY(path);
 
                         if (stat(path, &st) < 0) {
                                 DEBUG(0, ("Error statting %s: %s\n", path,
                                         strerror(errno)));
+                                talloc_free(path);
                                 continue;
                         }
@@ -309 +322 @@
 {
         const struct dir_key *dk = talloc_get_type(key, struct dir_key);
-        char *path = talloc_asprintf(dk, "%s/%s", dk->path, name);
-
-        if (!file_save(path, data.data, data.length))
+        char *path;
+        bool ret;
+
+        path = talloc_asprintf(dk, "%s/%s", dk->path, name);
+        W_ERROR_HAVE_NO_MEMORY(path);
+
+        ret = file_save(path, data.data, data.length);
+
+        talloc_free(path);
+
+        if (!ret) {
                 return WERR_GENERAL_FAILURE;
+        }
 
         /* FIXME: Type */
@@ -324 +346 @@
 {
         const struct dir_key *dk = talloc_get_type(key, struct dir_key);
-        char *path = talloc_asprintf(mem_ctx, "%s/%s", dk->path, name);
+        char *path;
         size_t size;
         char *contents;
 
+        path = talloc_asprintf(mem_ctx, "%s/%s", dk->path, name);
+        W_ERROR_HAVE_NO_MEMORY(path);
+
         contents = file_load(path, &size, 0, mem_ctx);
+
         talloc_free(path);
+
         if (contents == NULL)
                 return WERR_BADFILE;
@@ -343 +370 @@
 
 static WERROR reg_dir_enum_value(TALLOC_CTX *mem_ctx,
-                                 struct hive_key *key, int idx,
+                                 struct hive_key *key, uint32_t idx,
                                  const char **name,
                                  uint32_t *type, DATA_BLOB *data)
@@ -350 +377 @@
         DIR *d;
         struct dirent *e;
-        int i;
+        unsigned int i;
 
         d = opendir(dk->path);
@@ -365 +392 @@
 
                 if (i == idx) {
-                        if (name != NULL)
+                        if (name != NULL) {
                                 *name = talloc_strdup(mem_ctx, e->d_name);
+                                W_ERROR_HAVE_NO_MEMORY(*name);
+                        }
                         W_ERROR_NOT_OK_RETURN(reg_dir_get_value(mem_ctx, key,
                                                                 *name, type,
@@ -381 +410 @@
 
 
-static WERROR reg_dir_del_value (struct hive_key *key, const char *name)
+static WERROR reg_dir_del_value(TALLOC_CTX *mem_ctx,
+                                struct hive_key *key, const char *name)
 {
         const struct dir_key *dk = talloc_get_type(key, struct dir_key);
-        char *path = talloc_asprintf(key, "%s/%s", dk->path, name);
-        if (unlink(path) < 0) {
-                talloc_free(path);
+        char *path;
+        int ret;
+
+        path = talloc_asprintf(mem_ctx, "%s/%s", dk->path, name);
+        W_ERROR_HAVE_NO_MEMORY(path);
+
+        ret = unlink(path);
+
+        talloc_free(path);
+
+        if (ret < 0) {
                 if (errno == ENOENT)
                         return WERR_BADFILE;
                 return WERR_GENERAL_FAILURE;
         }
-        talloc_free(path);
 
         return WERR_OK;

vendor/current/source4/lib/registry/hive.c

@@ -55 +55 @@
         if (!strncmp(peek, "regf", 4)) {
                 close(fd);
-                return reg_open_regf_file(parent_ctx, location, lp_iconv_convenience(lp_ctx), root);
+                return reg_open_regf_file(parent_ctx, location, root);
         } else if (!strncmp(peek, "TDB file", 8)) {
                 close(fd);
@@ -92 +92 @@
 }
 
-_PUBLIC_ WERROR hive_key_del(const struct hive_key *key, const char *name)
+_PUBLIC_ WERROR hive_key_del(TALLOC_CTX *mem_ctx, const struct hive_key *key,
+                             const char *name)
 {
-        return key->ops->del_key(key, name);
+        return key->ops->del_key(mem_ctx, key, name);
 }
 
@@ -164 +165 @@
 }
 
-WERROR hive_key_del_value(struct hive_key *key, const char *name)
+WERROR hive_key_del_value(TALLOC_CTX *mem_ctx, struct hive_key *key,
+                          const char *name)
 {
         if (key->ops->delete_value == NULL)
                 return WERR_NOT_SUPPORTED;
 
-        return key->ops->delete_value(key, name);
+        return key->ops->delete_value(mem_ctx, key, name);
 }
 

vendor/current/source4/lib/registry/interface.c

@@ -45 +45 @@
 _PUBLIC_ const char *reg_get_predef_name(uint32_t hkey)
 {
-        int i;
+        unsigned int i;
         for (i = 0; reg_predefined_keys[i].name; i++) {
                 if (reg_predefined_keys[i].handle == hkey)
@@ -59 +59 @@
                                                struct registry_key **key)
 {
-        int i;
+        unsigned int i;
 
         for (i = 0; reg_predefined_keys[i].name; i++) {
@@ -151 +151 @@
 _PUBLIC_ WERROR reg_key_get_subkey_by_index(TALLOC_CTX *mem_ctx,
                                             const struct registry_key *key,
-                                            int idx, const char **name,
+                                            uint32_t idx, const char **name,
                                             const char **keyclass,
                                             NTTIME *last_changed_time)
@@ -186 +186 @@
  * Delete a key.
  */
-_PUBLIC_ WERROR reg_key_del(struct registry_key *parent, const char *name)
+_PUBLIC_ WERROR reg_key_del(TALLOC_CTX *mem_ctx, struct registry_key *parent,
+                            const char *name)
 {
         if (parent == NULL)
@@ -194 +195 @@
                 return WERR_NOT_SUPPORTED;
 
-        return parent->context->ops->delete_key(parent, name);
+        return parent->context->ops->delete_key(mem_ctx, parent, name);
 }
 
@@ -202 +203 @@
 _PUBLIC_ WERROR reg_key_add_name(TALLOC_CTX *mem_ctx,
                                  struct registry_key *parent,
-                                 const char *name, const char *key_class,
+                                 const char *path, const char *key_class,
                                  struct security_descriptor *desc,
                                  struct registry_key **newkey)
@@ -215 +216 @@
         }
 
-        return parent->context->ops->create_key(mem_ctx, parent, name,
+        return parent->context->ops->create_key(mem_ctx, parent, path,
                                                 key_class, desc, newkey);
 }
@@ -258 +259 @@
  * Delete a value.
  */
-_PUBLIC_ WERROR reg_del_value(struct registry_key *key, const char *valname)
+_PUBLIC_ WERROR reg_del_value(TALLOC_CTX *mem_ctx, struct registry_key *key,
+                              const char *valname)
 {
         if (key == NULL)
@@ -266 +268 @@
                 return WERR_NOT_SUPPORTED;
 
-        return key->context->ops->delete_value(key, valname);
+        return key->context->ops->delete_value(mem_ctx, key, valname);
 }
 

vendor/current/source4/lib/registry/ldb.c

@@ -3 +3 @@
    Registry interface
    Copyright (C) 2004-2007, Jelmer Vernooij, jelmer@samba.org
-   Copyright (C) 2008 Matthias Dieter Wallnöfer, mwallnoefer@yahoo.de
+   Copyright (C) 2008-2010, Matthias Dieter Wallnöfer, mdw@samba.org
 
    This program is free software; you can redistribute it and/or modify
@@ -21 +21 @@
 #include "includes.h"
 #include "registry.h"
-#include "lib/ldb/include/ldb.h"
-#include "lib/ldb/include/ldb_errors.h"
+#include <ldb.h>
+#include <ldb_errors.h>
 #include "ldb_wrap.h"
 #include "librpc/gen_ndr/winreg.h"
@@ -35 +35 @@
         struct ldb_dn *dn;
         struct ldb_message **subkeys, **values;
-        int subkey_count, value_count;
+        unsigned int subkey_count, value_count;
+        const char *classname;
 };
 
-static void reg_ldb_unpack_value(TALLOC_CTX *mem_ctx, 
+static void reg_ldb_unpack_value(TALLOC_CTX *mem_ctx,
                                  struct ldb_message *msg,
                                  const char **name, uint32_t *type,
@@ -46 +47 @@
         uint32_t value_type;
 
-        if (name != NULL)
+        if (name != NULL) {
                 *name = talloc_strdup(mem_ctx,
                                       ldb_msg_find_attr_as_string(msg, "value",
-                                      NULL));
+                                      ""));
+        }
 
         value_type = ldb_msg_find_attr_as_uint(msg, "type", 0);
-        *type = value_type; 
+        *type = value_type;
 
         val = ldb_msg_find_ldb_val(msg, "data");
@@ -60 +62 @@
         case REG_SZ:
         case REG_EXPAND_SZ:
-                if (val != NULL)
+                if (val != NULL) {
+                        /* The data should be provided as UTF16 string */
                         convert_string_talloc(mem_ctx, CH_UTF8, CH_UTF16,
-                                                     val->data, val->length,
-                                                     (void **)&data->data, &data->length, false);
-                else {
+                                              val->data, val->length,
+                                              (void **)&data->data, &data->length, false);
+                } else {
                         data->data = NULL;
                         data->length = 0;
@@ -70 +73 @@
                 break;
 
-        case REG_BINARY:
-                if (val != NULL)
-                        *data = data_blob_talloc(mem_ctx, val->data, val->length);
-                else {
+        case REG_DWORD:
+        case REG_DWORD_BIG_ENDIAN:
+                if (val != NULL) {
+                        /* The data is a plain DWORD */
+                        uint32_t tmp = strtoul((char *)val->data, NULL, 0);
+                        data->data = talloc_size(mem_ctx, sizeof(uint32_t));
+                        if (data->data != NULL) {
+                                SIVAL(data->data, 0, tmp);
+                        }
+                        data->length = sizeof(uint32_t);
+                } else {
                         data->data = NULL;
                         data->length = 0;
@@ -79 +89 @@
                 break;
 
-        case REG_DWORD: {
-                uint32_t tmp = strtoul((char *)val->data, NULL, 0);
-                *data = data_blob_talloc(mem_ctx, &tmp, 4);
+        case REG_QWORD:
+                if (val != NULL) {
+                        /* The data is a plain QWORD */
+                        uint64_t tmp = strtoull((char *)val->data, NULL, 0);
+                        data->data = talloc_size(mem_ctx, sizeof(uint64_t));
+                        if (data->data != NULL) {
+                                SBVAL(data->data, 0, tmp);
+                        }
+                        data->length = sizeof(uint64_t);
+                } else {
+                        data->data = NULL;
+                        data->length = 0;
                 }
                 break;
 
+        case REG_BINARY:
         default:
-                *data = data_blob_talloc(mem_ctx, val->data, val->length);
+                if (val != NULL) {
+                        data->data = talloc_memdup(mem_ctx, val->data,
+                                                   val->length);
+                        data->length = val->length;
+                } else {
+                        data->data = NULL;
+                        data->length = 0;
+                }
                 break;
         }
@@ -96 +123 @@
                                               uint32_t type, DATA_BLOB data)
 {
-        struct ldb_val val;
-        struct ldb_message *msg = talloc_zero(mem_ctx, struct ldb_message);
-        char *type_s;
-
-        ldb_msg_add_string(msg, "value", talloc_strdup(mem_ctx, name));
+        struct ldb_message *msg;
+        char *name_dup, *type_str;
+        int ret;
+
+        msg = talloc_zero(mem_ctx, struct ldb_message);
+        if (msg == NULL) {
+                return NULL;
+        }
+
+        name_dup = talloc_strdup(msg, name);
+        if (name_dup == NULL) {
+                talloc_free(msg);
+                return NULL;
+        }
+
+        ret = ldb_msg_add_string(msg, "value", name_dup);
+        if (ret != LDB_SUCCESS) {
+                talloc_free(msg);
+                return NULL;
+        }
 
         switch (type) {
         case REG_SZ:
         case REG_EXPAND_SZ:
-                if (data.data[0] != '\0') {
-                        convert_string_talloc(mem_ctx, CH_UTF16, CH_UTF8,
-                                                   (void *)data.data,
-                                                   data.length,
-                                                   (void **)&val.data, &val.length, false);
-                        ldb_msg_add_value(msg, "data", &val, NULL);
+                if ((data.length > 0) && (data.data != NULL)) {
+                        struct ldb_val *val;
+                        bool ret2 = false;
+
+                        val = talloc_zero(msg, struct ldb_val);
+                        if (val == NULL) {
+                                talloc_free(msg);
+                                return NULL;
+                        }
+
+                        /* The data is provided as UTF16 string */
+                        ret2 = convert_string_talloc(mem_ctx, CH_UTF16, CH_UTF8,
+                                                     (void *)data.data, data.length,
+                                                     (void **)&val->data, &val->length,
+                                                     false);
+                        if (ret2) {
+                                ret = ldb_msg_add_value(msg, "data", val, NULL);
+                        } else {
+                                /* workaround for non-standard data */
+                                ret = ldb_msg_add_empty(msg, "data", LDB_FLAG_MOD_DELETE, NULL);
+                        }
                 } else {
-                        ldb_msg_add_empty(msg, "data", LDB_FLAG_MOD_DELETE, NULL);
+                        ret = ldb_msg_add_empty(msg, "data", LDB_FLAG_MOD_DELETE, NULL);
                 }
                 break;
 
+        case REG_DWORD:
+        case REG_DWORD_BIG_ENDIAN:
+                if ((data.length > 0) && (data.data != NULL)) {
+                        if (data.length == sizeof(uint32_t)) {
+                                char *conv_str;
+
+                                conv_str = talloc_asprintf(msg, "0x%8.8x",
+                                                           IVAL(data.data, 0));
+                                if (conv_str == NULL) {
+                                        talloc_free(msg);
+                                        return NULL;
+                                }
+                                ret = ldb_msg_add_string(msg, "data", conv_str);
+                        } else {
+                                /* workaround for non-standard data */
+                                talloc_free(msg);
+                                return NULL;
+                        }
+                } else {
+                        ret = ldb_msg_add_empty(msg, "data", LDB_FLAG_MOD_DELETE, NULL);
+                }
+                break;
+
+        case REG_QWORD:
+                if ((data.length > 0) && (data.data != NULL)) {
+                        if (data.length == sizeof(uint64_t)) {
+                                char *conv_str;
+
+                                conv_str = talloc_asprintf(msg, "0x%16.16llx",
+                                                           (unsigned long long)BVAL(data.data, 0));
+                                if (conv_str == NULL) {
+                                        talloc_free(msg);
+                                        return NULL;
+                                }
+                                ret = ldb_msg_add_string(msg, "data", conv_str);
+                        } else {
+                                /* workaround for non-standard data */
+                                talloc_free(msg);
+                                return NULL;
+
+                        }
+                } else {
+                        ret = ldb_msg_add_empty(msg, "data", LDB_FLAG_MOD_DELETE, NULL);
+                }
+                break;
+
         case REG_BINARY:
-                if (data.length > 0)
-                        ldb_msg_add_value(msg, "data", &data, NULL);
-                else
-                        ldb_msg_add_empty(msg, "data", LDB_FLAG_MOD_DELETE, NULL);
+        default:
+                if ((data.length > 0) && (data.data != NULL)) {
+                        ret = ldb_msg_add_value(msg, "data", &data, NULL);
+                } else {
+                        ret = ldb_msg_add_empty(msg, "data", LDB_FLAG_MOD_DELETE, NULL);
+                }
                 break;
-
-        case REG_DWORD:
-                ldb_msg_add_string(msg, "data",
-                                   talloc_asprintf(mem_ctx, "0x%x",
-                                                   IVAL(data.data, 0)));
-                break;
-        default:
-                ldb_msg_add_value(msg, "data", &data, NULL);
-        }
-
-
-        type_s = talloc_asprintf(mem_ctx, "%u", type);
-        ldb_msg_add_string(msg, "type", type_s);
+        }
+
+        if (ret != LDB_SUCCESS) {
+                talloc_free(msg);
+                return NULL;
+        }
+
+        type_str = talloc_asprintf(mem_ctx, "%u", type);
+        if (type_str == NULL) {
+                talloc_free(msg);
+                return NULL;
+        }
+
+        ret = ldb_msg_add_string(msg, "type", type_str);
+        if (ret != LDB_SUCCESS) {
+                talloc_free(msg);
+                return NULL;
+        }
 
         return msg;
@@ -167 +277 @@
                                       const char *path, const char *add)
 {
-        TALLOC_CTX *local_ctx;
         struct ldb_dn *ret;
-        char *mypath = talloc_strdup(mem_ctx, path);
+        char *mypath;
         char *begin;
         struct ldb_key_data *kd = talloc_get_type(from, struct ldb_key_data);
         struct ldb_context *ldb = kd->ldb;
 
-        local_ctx = talloc_new(mem_ctx);
-
-        if (add) {
-                ret = ldb_dn_new(mem_ctx, ldb, add);
-        } else {
-                ret = ldb_dn_new(mem_ctx, ldb, NULL);
-        }
+        mypath = talloc_strdup(mem_ctx, path);
+        if (mypath == NULL) {
+                return NULL;
+        }
+
+        ret = ldb_dn_new(mem_ctx, ldb, add);
         if (!ldb_dn_validate(ret)) {
                 talloc_free(ret);
-                talloc_free(local_ctx);
                 return NULL;
         }
 
-        while (mypath) {
-                char *keyname;
-
-                begin = strrchr(mypath, '\\');
-
-                if (begin) keyname = begin + 1;
-                else keyname = mypath;
-
-                if(strlen(keyname)) {
-                        if (!ldb_dn_add_base_fmt(ret, "key=%s",
-                                                 reg_ldb_escape(local_ctx,
-                                                                keyname)))
-                        {
-                                talloc_free(local_ctx);
-                                return NULL;
-                        }
-                }
-
-                if(begin) {
+        if (!ldb_dn_add_base(ret, kd->dn)) {
+                talloc_free(ret);
+                return NULL;
+        }
+
+        while (mypath[0] != '\0') {
+                begin = strchr(mypath, '\\');
+                if (begin != NULL) {
                         *begin = '\0';
+                }
+
+                if (!ldb_dn_add_child_fmt(ret, "key=%s",
+                                          reg_ldb_escape(mem_ctx, mypath))) {
+                        talloc_free(ret);
+                        return NULL;
+                }
+
+                if (begin != NULL) {
+                        mypath = begin + 1;
                 } else {
                         break;
                 }
         }
-
-        ldb_dn_add_base(ret, kd->dn);
-
-        talloc_free(local_ctx);
 
         return ret;
@@ -225 +327 @@
         int ret;
 
-        ret = ldb_search(c, c, &res, kd->dn, LDB_SCOPE_ONELEVEL, NULL, "(key=*)");
-
+        ret = ldb_search(c, c, &res, kd->dn, LDB_SCOPE_ONELEVEL,
+                         NULL, "(key=*)");
         if (ret != LDB_SUCCESS) {
                 DEBUG(0, ("Error getting subkeys for '%s': %s\n",
@@ -248 +350 @@
         ret = ldb_search(c, c, &res, kd->dn, LDB_SCOPE_ONELEVEL,
                          NULL, "(value=*)");
-
         if (ret != LDB_SUCCESS) {
                 DEBUG(0, ("Error getting values for '%s': %s\n",
@@ -269 +370 @@
                                    NTTIME *last_mod_time)
 {
-        struct ldb_message_element *el;
         struct ldb_key_data *kd = talloc_get_type(k, struct ldb_key_data);
-        
+
         /* Initialization */
         if (name != NULL)
                 *name = NULL;
         if (classname != NULL)
-                *classname = NULL; /* TODO: Store properly */
+                *classname = NULL;
         if (last_mod_time != NULL)
                 *last_mod_time = 0; /* TODO: we need to add this to the
@@ -289 +389 @@
                 return WERR_NO_MORE_ITEMS;
 
-        el = ldb_msg_find_element(kd->subkeys[idx], "key");
-        SMB_ASSERT(el != NULL);
-        SMB_ASSERT(el->num_values != 0);
-
         if (name != NULL)
-                *name = talloc_strdup(mem_ctx, (char *)el->values[0].data);
-
-        return WERR_OK;
-}
-
-static WERROR ldb_get_default_value(TALLOC_CTX *mem_ctx, struct hive_key *k,
-                                  const char **name, uint32_t *data_type,
-                                   DATA_BLOB *data)
+                *name = talloc_strdup(mem_ctx,
+                                      ldb_msg_find_attr_as_string(kd->subkeys[idx], "key", NULL));
+        if (classname != NULL)
+                *classname = talloc_strdup(mem_ctx,
+                                           ldb_msg_find_attr_as_string(kd->subkeys[idx], "classname", NULL));
+
+        return WERR_OK;
+}
+
+static WERROR ldb_get_default_value(TALLOC_CTX *mem_ctx,
+                                    const struct hive_key *k,
+                                    const char **name, uint32_t *data_type,
+                                    DATA_BLOB *data)
 {
         struct ldb_key_data *kd = talloc_get_type(k, struct ldb_key_data);
@@ -309 +410 @@
         int ret;
 
-        ret = ldb_search(c, mem_ctx, &res, kd->dn, LDB_SCOPE_BASE, attrs, "%s", "");
+        ret = ldb_search(c, mem_ctx, &res, kd->dn, LDB_SCOPE_BASE, attrs, "(dn=*)");
 
         if (ret != LDB_SUCCESS) {
@@ -317 +418 @@
         }
 
-        if (res->count == 0 || res->msgs[0]->num_elements == 0)
+        if (res->count == 0 || res->msgs[0]->num_elements == 0) {
+                talloc_free(res);
                 return WERR_BADFILE;
-
-        reg_ldb_unpack_value(mem_ctx, 
-                 res->msgs[0], name, data_type, data);
+        }
+
+        if ((data_type != NULL) && (data != NULL)) {
+                reg_ldb_unpack_value(mem_ctx, res->msgs[0], name, data_type,
+                                     data);
+        }
 
         talloc_free(res);
@@ -329 +434 @@
 
 static WERROR ldb_get_value_by_id(TALLOC_CTX *mem_ctx, struct hive_key *k,
-                                  int idx, const char **name,
+                                  uint32_t idx, const char **name,
                                   uint32_t *data_type, DATA_BLOB *data)
 {
         struct ldb_key_data *kd = talloc_get_type(k, struct ldb_key_data);
 
-        /* if default value exists, give it back */
+        /* if the default value exists, give it back */
         if (W_ERROR_IS_OK(ldb_get_default_value(mem_ctx, k, name, data_type,
                 data))) {
@@ -361 +466 @@
 {
         struct ldb_key_data *kd = talloc_get_type(k, struct ldb_key_data);
-        struct ldb_context *c = kd->ldb;
-        struct ldb_result *res;
-        int ret;
-        char *query;
-
-        if (strlen(name) == 0) {
-                /* default value */
+        const char *res_name;
+        uint32_t idx;
+
+        /* the default value was requested, give it back */
+        if (name[0] == '\0') {
                 return ldb_get_default_value(mem_ctx, k, NULL, data_type, data);
-        } else {
-                /* normal value */
-                query = talloc_asprintf(mem_ctx, "(value=%s)", name);
-                ret = ldb_search(c, mem_ctx, &res, kd->dn, LDB_SCOPE_ONELEVEL, NULL, "%s", query);
-                talloc_free(query);
-
-                if (ret != LDB_SUCCESS) {
-                        DEBUG(0, ("Error getting values for '%s': %s\n",
-                                ldb_dn_get_linearized(kd->dn), ldb_errstring(c)));
-                        return WERR_FOOBAR;
-                }
-
-                if (res->count == 0)
-                        return WERR_BADFILE;
-
-                reg_ldb_unpack_value(mem_ctx, res->msgs[0], NULL, data_type, data);
-
-                talloc_free(res);
-        }
-
-        return WERR_OK;
+        }
+
+        /* Do the search if necessary */
+        if (kd->values == NULL) {
+                W_ERROR_NOT_OK_RETURN(cache_values(kd));
+        }
+
+        for (idx = 0; idx < kd->value_count; idx++) {
+                res_name = ldb_msg_find_attr_as_string(kd->values[idx], "value",
+                                                       "");
+                if (ldb_attr_cmp(name, res_name) == 0) {
+                        reg_ldb_unpack_value(mem_ctx, kd->values[idx], NULL,
+                                             data_type, data);
+                        return WERR_OK;
+                }
+        }
+
+        return WERR_BADFILE;
 }
 
@@ -396 +496 @@
 {
         struct ldb_result *res;
-        struct ldb_dn *ldap_path;
+        struct ldb_dn *ldb_path;
         int ret;
         struct ldb_key_data *newkd;
@@ -402 +502 @@
         struct ldb_context *c = kd->ldb;
 
-        ldap_path = reg_path_to_ldb(mem_ctx, h, name, NULL);
-
-        ret = ldb_search(c, mem_ctx, &res, ldap_path, LDB_SCOPE_BASE, NULL, "(key=*)");
+        ldb_path = reg_path_to_ldb(mem_ctx, h, name, NULL);
+        W_ERROR_HAVE_NO_MEMORY(ldb_path);
+
+        ret = ldb_search(c, mem_ctx, &res, ldb_path, LDB_SCOPE_BASE, NULL, "(key=*)");
 
         if (ret != LDB_SUCCESS) {
                 DEBUG(3, ("Error opening key '%s': %s\n",
-                        ldb_dn_get_linearized(ldap_path), ldb_errstring(c)));
+                        ldb_dn_get_linearized(ldb_path), ldb_errstring(c)));
                 return WERR_FOOBAR;
         } else if (res->count == 0) {
                 DEBUG(3, ("Key '%s' not found\n",
-                        ldb_dn_get_linearized(ldap_path)));
+                        ldb_dn_get_linearized(ldb_path)));
                 talloc_free(res);
                 return WERR_BADFILE;
@@ -418 +519 @@
 
         newkd = talloc_zero(mem_ctx, struct ldb_key_data);
+        W_ERROR_HAVE_NO_MEMORY(newkd);
         newkd->key.ops = &reg_backend_ldb;
         newkd->ldb = talloc_reference(newkd, kd->ldb);
-        newkd->dn = ldb_dn_copy(mem_ctx, res->msgs[0]->dn);
+        newkd->dn = ldb_dn_copy(newkd, res->msgs[0]->dn);
+        newkd->classname = talloc_steal(newkd,
+                                        ldb_msg_find_attr_as_string(res->msgs[0], "classname", NULL));
+
+        talloc_free(res);
 
         *key = (struct hive_key *)newkd;
@@ -442 +548 @@
 
         wrap = ldb_wrap_connect(parent_ctx, ev_ctx, lp_ctx,
-                                location, session_info, credentials, 0, NULL);
+                                location, session_info, credentials, 0);
 
         if (wrap == NULL) {
@@ -477 +583 @@
 {
         struct ldb_key_data *parentkd = discard_const_p(struct ldb_key_data, parent);
+        struct ldb_dn *ldb_path;
         struct ldb_message *msg;
         struct ldb_key_data *newkd;
         int ret;
 
+        ldb_path = reg_path_to_ldb(mem_ctx, parent, name, NULL);
+        W_ERROR_HAVE_NO_MEMORY(ldb_path);
+
         msg = ldb_msg_new(mem_ctx);
-
-        msg->dn = reg_path_to_ldb(msg, parent, name, NULL);
-
-        ldb_msg_add_string(msg, "key", talloc_strdup(mem_ctx, name));
-        if (classname != NULL)
-                ldb_msg_add_string(msg, "classname",
-                                   talloc_strdup(mem_ctx, classname));
+        W_ERROR_HAVE_NO_MEMORY(msg);
+
+        msg->dn = ldb_path;
+
+        ldb_msg_add_string(msg, "key", name);
+        if (classname != NULL) {
+                ldb_msg_add_string(msg, "classname", classname);
+        }
 
         ret = ldb_add(parentkd->ldb, msg);
+
+        talloc_free(msg);
+
         if (ret == LDB_ERR_ENTRY_ALREADY_EXISTS) {
                 return WERR_ALREADY_EXISTS;
@@ -500 +614 @@
         }
 
-        DEBUG(2, ("key added: %s\n", ldb_dn_get_linearized(msg->dn)));
+        DEBUG(2, ("key added: %s\n", ldb_dn_get_linearized(ldb_path)));
 
         newkd = talloc_zero(mem_ctx, struct ldb_key_data);
+        W_ERROR_HAVE_NO_MEMORY(newkd);
         newkd->ldb = talloc_reference(newkd, parentkd->ldb);
         newkd->key.ops = &reg_backend_ldb;
-        newkd->dn = talloc_steal(newkd, msg->dn);
+        newkd->dn = talloc_steal(newkd, ldb_path);
+        newkd->classname = talloc_steal(newkd, classname);
 
         *newkey = (struct hive_key *)newkd;
@@ -516 +632 @@
 }
 
-static WERROR ldb_del_value (struct hive_key *key, const char *child)
+static WERROR ldb_del_value(TALLOC_CTX *mem_ctx, struct hive_key *key,
+                            const char *child)
 {
         int ret;
         struct ldb_key_data *kd = talloc_get_type(key, struct ldb_key_data);
-        TALLOC_CTX *mem_ctx;
         struct ldb_message *msg;
         struct ldb_dn *childdn;
 
-        if (strlen(child) == 0) {
+        if (child[0] == '\0') {
                 /* default value */
-                mem_ctx = talloc_init("ldb_del_value");
-
                 msg = talloc_zero(mem_ctx, struct ldb_message);
+                W_ERROR_HAVE_NO_MEMORY(msg);
                 msg->dn = ldb_dn_copy(msg, kd->dn);
+                W_ERROR_HAVE_NO_MEMORY(msg->dn);
                 ldb_msg_add_empty(msg, "data", LDB_FLAG_MOD_DELETE, NULL);
                 ldb_msg_add_empty(msg, "type", LDB_FLAG_MOD_DELETE, NULL);
 
                 ret = ldb_modify(kd->ldb, msg);
+
+                talloc_free(msg);
+
                 if (ret != LDB_SUCCESS) {
                         DEBUG(1, ("ldb_del_value: %s\n", ldb_errstring(kd->ldb)));
-                        talloc_free(mem_ctx);
                         return WERR_FOOBAR;
                 }
-
-                talloc_free(mem_ctx);
         } else {
                 /* normal value */
@@ -570 +686 @@
 }
 
-static WERROR ldb_del_key(const struct hive_key *key, const char *name)
-{
-        int i, ret;
+static WERROR ldb_del_key(TALLOC_CTX *mem_ctx, const struct hive_key *key,
+                          const char *name)
+{
+        unsigned int i;
+        int ret;
         struct ldb_key_data *parentkd = talloc_get_type(key, struct ldb_key_data);
-        struct ldb_dn *ldap_path;
-        TALLOC_CTX *mem_ctx = talloc_init("ldb_del_key");
+        struct ldb_dn *ldb_path;
         struct ldb_context *c = parentkd->ldb;
         struct ldb_result *res_keys;
@@ -585 +702 @@
         werr = ldb_open_key(mem_ctx, key, name, &hk);
         if (!W_ERROR_IS_OK(werr)) {
-                talloc_free(mem_ctx);
                 return werr;
         }
 
-        ldap_path = reg_path_to_ldb(mem_ctx, key, name, NULL);
-        if (!ldap_path) {
-                talloc_free(mem_ctx);
-                return WERR_FOOBAR;
-        }
+        ldb_path = reg_path_to_ldb(mem_ctx, key, name, NULL);
+        W_ERROR_HAVE_NO_MEMORY(ldb_path);
 
         /* Search for subkeys */
-        ret = ldb_search(c, mem_ctx, &res_keys, ldap_path, LDB_SCOPE_ONELEVEL,
+        ret = ldb_search(c, mem_ctx, &res_keys, ldb_path, LDB_SCOPE_ONELEVEL,
                          NULL, "(key=*)");
 
         if (ret != LDB_SUCCESS) {
                 DEBUG(0, ("Error getting subkeys for '%s': %s\n",
-                      ldb_dn_get_linearized(ldap_path), ldb_errstring(c)));
-                talloc_free(mem_ctx);
+                      ldb_dn_get_linearized(ldb_path), ldb_errstring(c)));
                 return WERR_FOOBAR;
         }
 
         /* Search for values */
-        ret = ldb_search(c, mem_ctx, &res_vals, ldap_path, LDB_SCOPE_ONELEVEL,
+        ret = ldb_search(c, mem_ctx, &res_vals, ldb_path, LDB_SCOPE_ONELEVEL,
                          NULL, "(value=*)");
 
         if (ret != LDB_SUCCESS) {
                 DEBUG(0, ("Error getting values for '%s': %s\n",
-                      ldb_dn_get_linearized(ldap_path), ldb_errstring(c)));
-                talloc_free(mem_ctx);
+                      ldb_dn_get_linearized(ldb_path), ldb_errstring(c)));
                 return WERR_FOOBAR;
         }
@@ -622 +733 @@
         if (ret != LDB_SUCCESS) {
                 DEBUG(0, ("ldb_transaction_start: %s\n", ldb_errstring(c)));
-                talloc_free(mem_ctx);
                 return WERR_FOOBAR;
         }
@@ -631 +741 @@
                 for (i = 0; i < res_keys->count; i++)
                 {
-                        werr = ldb_del_key(hk, ldb_msg_find_attr_as_string(
+                        werr = ldb_del_key(mem_ctx, hk,
+                                           ldb_msg_find_attr_as_string(
                                                         res_keys->msgs[i],
                                                         "key", NULL));
                         if (!W_ERROR_IS_OK(werr)) {
                                 ret = ldb_transaction_cancel(c);
-                                talloc_free(mem_ctx);
                                 return werr;
                         }
@@ -644 +754 @@
                 for (i = 0; i < res_vals->count; i++)
                 {
-                        werr = ldb_del_value(hk, ldb_msg_find_attr_as_string(
+                        werr = ldb_del_value(mem_ctx, hk,
+                                             ldb_msg_find_attr_as_string(
                                                         res_vals->msgs[i],
                                                         "value", NULL));
                         if (!W_ERROR_IS_OK(werr)) {
                                 ret = ldb_transaction_cancel(c);
-                                talloc_free(mem_ctx);
                                 return werr;
                         }
                 }
         }
+        talloc_free(res_keys);
+        talloc_free(res_vals);
 
         /* Delete the key itself */
-        ret = ldb_delete(c, ldap_path);
+        ret = ldb_delete(c, ldb_path);
 
         if (ret != LDB_SUCCESS)
@@ -662 +774 @@
                 DEBUG(1, ("ldb_del_key: %s\n", ldb_errstring(c)));
                 ret = ldb_transaction_cancel(c);
-                talloc_free(mem_ctx);
                 return WERR_FOOBAR;
         }
@@ -673 +784 @@
                 DEBUG(0, ("ldb_transaction_commit: %s\n", ldb_errstring(c)));
                 ret = ldb_transaction_cancel(c);
-                talloc_free(mem_ctx);
-                return WERR_FOOBAR;
-        }
-
-        talloc_free(mem_ctx);
+                return WERR_FOOBAR;
+        }
 
         /* reset cache */
@@ -692 +800 @@
         struct ldb_message *msg;
         struct ldb_key_data *kd = talloc_get_type(parent, struct ldb_key_data);
+        unsigned int i;
         int ret;
         TALLOC_CTX *mem_ctx = talloc_init("ldb_set_value");
 
         msg = reg_ldb_pack_value(kd->ldb, mem_ctx, name, type, data);
+        W_ERROR_HAVE_NO_MEMORY(msg);
+
         msg->dn = ldb_dn_copy(msg, kd->dn);
-        
-        if (strlen(name) > 0) {
+        W_ERROR_HAVE_NO_MEMORY(msg->dn);
+
+        if (name[0] != '\0') {
                 /* For a default value, we add/overwrite the attributes to/of the hive.
-                   For a normal value, we create new childs. */
+                   For a normal value, we create a new child. */
                 if (!ldb_dn_add_child_fmt(msg->dn, "value=%s",
                                   reg_ldb_escape(mem_ctx, name)))
@@ -709 +821 @@
         }
 
-        ret = ldb_add(kd->ldb, msg);
-        if (ret == LDB_ERR_ENTRY_ALREADY_EXISTS) {
-                int i;
-                for (i = 0; i < msg->num_elements; i++) {
-                        if (msg->elements[i].flags != LDB_FLAG_MOD_DELETE)
-                                msg->elements[i].flags = LDB_FLAG_MOD_REPLACE;
-                }
-                ret = ldb_modify(kd->ldb, msg);
-        }
+        /* Try first a "modify" and if this doesn't work do try an "add" */
+        for (i = 0; i < msg->num_elements; i++) {
+                if (msg->elements[i].flags != LDB_FLAG_MOD_DELETE) {
+                        msg->elements[i].flags = LDB_FLAG_MOD_REPLACE;
+                }
+        }
+        ret = ldb_modify(kd->ldb, msg);
+        if (ret == LDB_ERR_NO_SUCH_OBJECT) {
+                i = 0;
+                while (i < msg->num_elements) {
+                        if (LDB_FLAG_MOD_TYPE(msg->elements[i].flags) == LDB_FLAG_MOD_DELETE) {
+                                ldb_msg_remove_element(msg, &msg->elements[i]);
+                        } else {
+                                ++i;
+                        }
+                }
+                ret = ldb_add(kd->ldb, msg);
+        }
+        if (ret == LDB_ERR_NO_SUCH_ATTRIBUTE) {
+                /* ignore this -> the value didn't exist and also now doesn't */
+                ret = LDB_SUCCESS;
+        }
+
+        talloc_free(msg);
 
         if (ret != LDB_SUCCESS) {
@@ -744 +871 @@
 {
         struct ldb_key_data *kd = talloc_get_type(key, struct ldb_key_data);
+        uint32_t default_value_type = REG_NONE;
+        DATA_BLOB default_value = { NULL, 0 };
+        WERROR werr;
 
         /* Initialization */
@@ -761 +891 @@
                 *max_valbufsize = 0;
 
+        /* We need this to get the default value (if it exists) for counting
+         * the values under the key and for finding out the longest value buffer
+         * size. If no default value exists the DATA_BLOB "default_value" will
+         * remain { NULL, 0 }. */
+        werr = ldb_get_default_value(mem_ctx, key, NULL, &default_value_type,
+                                     &default_value);
+        if ((!W_ERROR_IS_OK(werr)) && (!W_ERROR_EQUAL(werr, WERR_BADFILE))) {
+                return werr;
+        }
+
         if (kd->subkeys == NULL) {
                 W_ERROR_NOT_OK_RETURN(cache_subkeys(kd));
         }
-
         if (kd->values == NULL) {
                 W_ERROR_NOT_OK_RETURN(cache_values(kd));
         }
 
+        if (classname != NULL) {
+                *classname = kd->classname;
+        }
+
         if (num_subkeys != NULL) {
                 *num_subkeys = kd->subkey_count;
@@ -774 +917 @@
         if (num_values != NULL) {
                 *num_values = kd->value_count;
+                /* also consider the default value if it exists */
+                if (default_value.data != NULL) {
+                        ++(*num_values);
+                }
         }
 
 
         if (max_subkeynamelen != NULL) {
-                int i;
+                unsigned int i;
                 struct ldb_message_element *el;
-
-                *max_subkeynamelen = 0;
 
                 for (i = 0; i < kd->subkey_count; i++) {
@@ -790 +935 @@
 
         if (max_valnamelen != NULL || max_valbufsize != NULL) {
-                int i;
+                unsigned int i;
                 struct ldb_message_element *el;
                 W_ERROR_NOT_OK_RETURN(cache_values(kd));
 
-                if (max_valbufsize != NULL)
-                        *max_valbufsize = 0;
-
-                if (max_valnamelen != NULL)
-                        *max_valnamelen = 0;
+                /* also consider the default value if it exists */
+                if ((max_valbufsize != NULL) && (default_value.data != NULL)) {
+                                *max_valbufsize = MAX(*max_valbufsize,
+                                                      default_value.length);
+                }
 
                 for (i = 0; i < kd->value_count; i++) {
@@ -809 +954 @@
                                 uint32_t data_type;
                                 DATA_BLOB data;
-                                reg_ldb_unpack_value(mem_ctx, 
-                                                     kd->values[i], NULL, 
+                                reg_ldb_unpack_value(mem_ctx,
+                                                     kd->values[i], NULL,
                                                      &data_type, &data);
                                 *max_valbufsize = MAX(*max_valbufsize, data.length);
@@ -817 +962 @@
                 }
         }
+
+        talloc_free(default_value.data);
 
         return WERR_OK;

vendor/current/source4/lib/registry/local.c

@@ -58 +58 @@
 
         local_key = talloc(ctx, struct local_key);
-        local_key->hive_key = talloc_steal(local_key, hive);
-        local_key->global.context = talloc_reference(local_key, ctx);
-        local_key->path = parent_path;
+        if (local_key != NULL) {
+                local_key->hive_key = talloc_reference(local_key, hive);
+                local_key->global.context = talloc_reference(local_key, ctx);
+                local_key->path = parent_path;
+        }
 
         return (struct registry_key *)local_key;
@@ -71 +73 @@
                              struct registry_key **result)
 {
-        char *orig = talloc_strdup(mem_ctx, path),
-                 *curbegin = orig,
-                 *curend = strchr(orig, '\\');
+        char *orig, *curbegin, *curend;
         struct local_key *local_parent = talloc_get_type(parent,
                                                          struct local_key);
@@ -81 +81 @@
         int el;
 
+        if (path == NULL) {
+                return WERR_INVALID_PARAM;
+        }
+
+        orig = talloc_strdup(mem_ctx, path);
+        W_ERROR_HAVE_NO_MEMORY(orig);
+        curbegin = orig;
+        curend = strchr(orig, '\\');
+
         if (local_parent->path.elements != NULL) {
                 elements = talloc_array(mem_ctx, const char *,
                                         str_list_length(local_parent->path.elements) + 1);
+                W_ERROR_HAVE_NO_MEMORY(elements);
                 for (el = 0; local_parent->path.elements[el] != NULL; el++) {
                         elements[el] = talloc_reference(elements,
@@ -98 +108 @@
                         *curend = '\0';
                 elements = talloc_realloc(mem_ctx, elements, const char *, el+2);
+                W_ERROR_HAVE_NO_MEMORY(elements);
                 elements[el] = talloc_strdup(elements, curbegin);
+                W_ERROR_HAVE_NO_MEMORY(elements[el]);
                 el++;
                 elements[el] = NULL;
@@ -159 +171 @@
 
 static WERROR local_create_key(TALLOC_CTX *mem_ctx,
-                               struct registry_key *parent_key,
-                               const char *name,
+                               struct registry_key *parent,
+                               const char *path,
                                const char *key_class,
                                struct security_descriptor *security,
-                               struct registry_key **key)
-{
-        struct local_key *local_parent;
-        struct hive_key *hivekey;
-        const char **elements;
-        int i;
-        const char *last_part;
-
-        last_part = strrchr(name, '\\');
-        if (last_part == NULL) {
-                last_part = name;
-                local_parent = (struct local_key *)parent_key;
+                               struct registry_key **result)
+{
+        char *orig, *curbegin, *curend;
+        struct local_key *local_parent = talloc_get_type(parent,
+                                                         struct local_key);
+        struct hive_key *curkey = local_parent->hive_key;
+        WERROR error;
+        const char **elements = NULL;
+        int el;
+
+        if (path == NULL) {
+                return WERR_INVALID_PARAM;
+        }
+
+        orig = talloc_strdup(mem_ctx, path);
+        W_ERROR_HAVE_NO_MEMORY(orig);
+        curbegin = orig;
+        curend = strchr(orig, '\\');
+
+        if (local_parent->path.elements != NULL) {
+                elements = talloc_array(mem_ctx, const char *,
+                                        str_list_length(local_parent->path.elements) + 1);
+                W_ERROR_HAVE_NO_MEMORY(elements);
+                for (el = 0; local_parent->path.elements[el] != NULL; el++) {
+                        elements[el] = talloc_reference(elements,
+                                                        local_parent->path.elements[el]);
+                }
+                elements[el] = NULL;
         } else {
-                W_ERROR_NOT_OK_RETURN(reg_open_key(mem_ctx, parent_key,
-                                                   talloc_strndup(mem_ctx, name, last_part-name),
-                                                   (struct registry_key **)&local_parent));
-                last_part++;
-        }
-
-        W_ERROR_NOT_OK_RETURN(hive_key_add_name(mem_ctx, local_parent->hive_key,
-                                                last_part, key_class, security,
-                                                &hivekey));
-
-        if (local_parent->path.elements != NULL) {
-                elements = talloc_array(hivekey, const char *,
-                                        str_list_length(local_parent->path.elements)+2);
-                for (i = 0; local_parent->path.elements[i] != NULL; i++) {
-                        elements[i] = talloc_reference(elements,
-                                                       local_parent->path.elements[i]);
-                }
-        } else {
-                elements = talloc_array(hivekey, const char *, 2);
-                i = 0;
-        }
-
-        elements[i] = talloc_strdup(elements, name);
-        elements[i+1] = NULL;
-
-        *key = reg_import_hive_key(local_parent->global.context, hivekey,
-                                   local_parent->path.predefined_key,
-                                   elements);
+                elements = NULL;
+                el = 0;
+        }
+
+        while (curbegin != NULL && *curbegin) {
+                if (curend != NULL)
+                        *curend = '\0';
+                elements = talloc_realloc(mem_ctx, elements, const char *, el+2);
+                W_ERROR_HAVE_NO_MEMORY(elements);
+                elements[el] = talloc_strdup(elements, curbegin);
+                W_ERROR_HAVE_NO_MEMORY(elements[el]);
+                el++;
+                elements[el] = NULL;
+                error = hive_get_key_by_name(mem_ctx, curkey,
+                                             curbegin, &curkey);
+                if (W_ERROR_EQUAL(error, WERR_BADFILE)) {
+                        error = hive_key_add_name(mem_ctx, curkey, curbegin,
+                                                  key_class, security,
+                                                  &curkey);
+                }
+                if (!W_ERROR_IS_OK(error)) {
+                        DEBUG(2, ("Open/Creation of key %s failed: %s\n",
+                                curbegin, win_errstr(error)));
+                        talloc_free(orig);
+                        return error;
+                }
+                if (curend == NULL)
+                        break;
+                curbegin = curend + 1;
+                curend = strchr(curbegin, '\\');
+        }
+        talloc_free(orig);
+
+        *result = reg_import_hive_key(local_parent->global.context, curkey,
+                                      local_parent->path.predefined_key,
+                                      talloc_steal(curkey, elements));
 
         return WERR_OK;
@@ -212 +248 @@
 {
         struct local_key *local = (struct local_key *)key;
+
+        if (name == NULL) {
+                return WERR_INVALID_PARAM;
+        }
 
         return hive_key_set_value(local->hive_key, name, type, data);
@@ -221 +261 @@
 {
         const struct local_key *local = (const struct local_key *)key;
+
+        if (name == NULL) {
+                return WERR_INVALID_PARAM;
+        }
 
         return hive_get_value(mem_ctx, local->hive_key, name, type, data);
@@ -237 +281 @@
 }
 
-static WERROR local_delete_key(struct registry_key *key, const char *name)
-{
-        const struct local_key *local = (const struct local_key *)key;
-
-        return hive_key_del(local->hive_key, name);
-}
-
-static WERROR local_delete_value(struct registry_key *key, const char *name)
-{
-        const struct local_key *local = (const struct local_key *)key;
-
-        return hive_key_del_value(local->hive_key, name);
+static WERROR local_delete_key(TALLOC_CTX *mem_ctx, struct registry_key *key,
+                               const char *name)
+{
+        const struct local_key *local = (const struct local_key *)key;
+
+        if (name == NULL) {
+                return WERR_INVALID_PARAM;
+        }
+
+        return hive_key_del(mem_ctx, local->hive_key, name);
+}
+
+static WERROR local_delete_value(TALLOC_CTX *mem_ctx, struct registry_key *key,
+                                 const char *name)
+{
+        const struct local_key *local = (const struct local_key *)key;
+
+        if (name == NULL) {
+                return WERR_INVALID_PARAM;
+        }
+
+        return hive_key_del_value(mem_ctx, local->hive_key, name);
 }
 
@@ -328 +382 @@
         struct registry_local *reg_local = talloc_get_type(rctx,
                                                            struct registry_local);
-        struct mountpoint *mp = talloc(rctx, struct mountpoint);
-        int i = 0;
-
+        struct mountpoint *mp;
+        unsigned int i = 0;
+
+        mp = talloc(rctx, struct mountpoint);
+        W_ERROR_HAVE_NO_MEMORY(mp);
         mp->path.predefined_key = key_id;
         mp->prev = mp->next = NULL;
@@ -337 +393 @@
                 mp->path.elements = talloc_array(mp, const char *,
                                                  str_list_length(elements));
+                W_ERROR_HAVE_NO_MEMORY(mp->path.elements);
                 for (i = 0; elements[i] != NULL; i++) {
                         mp->path.elements[i] = talloc_reference(mp->path.elements,

vendor/current/source4/lib/registry/man/regdiff.1.xml

@@ -1 +1 @@
 <?xml version="1.0" encoding="iso-8859-1"?>
-<!DOCTYPE refentry PUBLIC "-//Samba-Team//DTD DocBook V4.2-Based Variant V1.0//EN" "http://www.samba.org/samba/DTD/samba-doc">
+<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN" "http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd">
 <refentry id="regdiff.1">
 

vendor/current/source4/lib/registry/man/regpatch.1.xml

@@ -1 +1 @@
 <?xml version="1.0" encoding="iso-8859-1"?>
-<!DOCTYPE refentry PUBLIC "-//Samba-Team//DTD DocBook V4.2-Based Variant V1.0//EN" "http://www.samba.org/samba/DTD/samba-doc">
+<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN" "http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd">
 <refentry id="regpatch.1">
 

vendor/current/source4/lib/registry/man/regshell.1.xml

@@ -1 +1 @@
 <?xml version="1.0" encoding="iso-8859-1"?>
-<!DOCTYPE refentry PUBLIC "-//Samba-Team//DTD DocBook V4.2-Based Variant V1.0//EN" "http://www.samba.org/samba/DTD/samba-doc">
+<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN" "http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd">
 <refentry id="regshell.1">
 

vendor/current/source4/lib/registry/man/regtree.1.xml

@@ -1 +1 @@
 <?xml version="1.0" encoding="iso-8859-1"?>
-<!DOCTYPE refentry PUBLIC "-//Samba-Team//DTD DocBook V4.2-Based Variant V1.0//EN" "http://www.samba.org/samba/DTD/samba-doc">
+<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.2//EN" "http://www.oasis-open.org/docbook/xml/4.2/docbookx.dtd">
 <refentry id="regtree.1">
 

vendor/current/source4/lib/registry/patchfile.c

@@ -5 +5 @@
    Copyright (C) Jelmer Vernooij 2004-2007
    Copyright (C) Wilco Baan Hofman 2006
-   Copyright (C) Matthias Dieter Wallnöfer 2008
+   Copyright (C) Matthias Dieter Wallnöfer 2008-2010
 
    This program is free software; you can redistribute it and/or modify
@@ -27 +27 @@
 
 _PUBLIC_ WERROR reg_preg_diff_load(int fd,
-                                   struct smb_iconv_convenience *iconv_convenience, 
                                    const struct reg_diff_callbacks *callbacks,
                                    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);
@@ -45 +43 @@
                              void *callback_data)
 {
-        int i;
+        unsigned int i;
         struct registry_key *t1 = NULL, *t2 = NULL;
         char *tmppath;
@@ -87 +85 @@
 
                 if (!W_ERROR_IS_OK(error2) && !W_ERROR_EQUAL(error2, WERR_BADFILE)) {
-                        DEBUG(0, ("Error occured while getting subkey by name: %s\n",
+                        DEBUG(0, ("Error occurred while getting subkey by name: %s\n",
                                 win_errstr(error2)));
                         talloc_free(mem_ctx);
@@ -96 +94 @@
                 /* didn't have such a subkey and therefore add a del diff */
                 tmppath = talloc_asprintf(mem_ctx, "%s\\%s", path, keyname1);
+                if (tmppath == NULL) {
+                        DEBUG(0, ("Out of memory\n"));
+                        talloc_free(mem_ctx);
+                        return WERR_NOMEM;
+                }
                 if (!W_ERROR_IS_OK(error2))
                         callbacks->del_key(callback_data, tmppath);
@@ -102 +105 @@
                 error1 = reg_open_key(mem_ctx, oldkey, keyname1, &t1);
                 if (!W_ERROR_IS_OK(error1)) {
-                        DEBUG(0, ("Error occured while getting subkey by name: %s\n",
+                        DEBUG(0, ("Error occurred while getting subkey by name: %s\n",
                         win_errstr(error1)));
                         talloc_free(mem_ctx);
@@ -155 +158 @@
                 }
 
-                /* oldkey didn't have such a subkey, add add diff */
+                /* oldkey didn't have such a subkey, add a add diff */
                 tmppath = talloc_asprintf(mem_ctx, "%s\\%s", path, keyname1);
+                if (tmppath == NULL) {
+                        DEBUG(0, ("Out of memory\n"));
+                        talloc_free(mem_ctx);
+                        return WERR_NOMEM;
+                }
                 callbacks->add_key(callback_data, tmppath);
 
@@ -162 +170 @@
                 error1 = reg_open_key(mem_ctx, newkey, keyname1, &t2);
                 if (!W_ERROR_IS_OK(error1)) {
-                        DEBUG(0, ("Error occured while getting subkey by name: %s\n",
+                        DEBUG(0, ("Error occurred while getting subkey by name: %s\n",
                         win_errstr(error1)));
                         talloc_free(mem_ctx);
@@ -176 +184 @@
                 const char *name;
                 uint32_t type1, type2;
-                DATA_BLOB contents1, contents2;
+                DATA_BLOB contents1 = { NULL, 0 }, contents2 = { NULL, 0 };
 
                 error1 = reg_key_get_value_by_index(mem_ctx, newkey, i,
@@ -203 +211 @@
 
                 if (W_ERROR_IS_OK(error2)
-                        && (data_blob_cmp(&contents1, &contents2) == 0)
-                        && (type1 == type2))
+                    && (data_blob_cmp(&contents1, &contents2) == 0)
+                    && (type1 == type2)) {
+                        talloc_free(discard_const_p(char, name));
+                        talloc_free(contents1.data);
+                        talloc_free(contents2.data);
                         continue;
+                }
 
                 callbacks->set_value(callback_data, path, name,
                                      type1, contents1);
+
+                talloc_free(discard_const_p(char, name));
+                talloc_free(contents1.data);
+                talloc_free(contents2.data);
         }
 
@@ -215 +231 @@
                 const char *name;
                 uint32_t type;
-                DATA_BLOB contents;
+                DATA_BLOB contents = { NULL, 0 };
 
                 error1 = reg_key_get_value_by_index(mem_ctx, oldkey, i, &name,
@@ -232 +248 @@
                         error2 = WERR_BADFILE;
 
-                if (W_ERROR_IS_OK(error2))
+                if (W_ERROR_IS_OK(error2)) {
+                        talloc_free(discard_const_p(char, name));
+                        talloc_free(contents.data);
                         continue;
+                }
 
                 if (!W_ERROR_EQUAL(error2, WERR_BADFILE)) {
@@ -243 +262 @@
 
                 callbacks->del_value(callback_data, path, name);
+
+                talloc_free(discard_const_p(char, name));
+                talloc_free(contents.data);
         }
 
@@ -257 +279 @@
                                   void *callback_data)
 {
-        int i;
+        unsigned int i;
         WERROR error;
 
@@ -281 +303 @@
                 }
 
+                /* if "r1" is NULL (old hive) and "r2" isn't (new hive) then
+                 * the hive doesn't exist yet and we have to generate an add
+                 * diff */
+                if ((r1 == NULL) && (r2 != NULL)) {
+                        callbacks->add_key(callback_data,
+                                           reg_predefined_keys[i].name);
+                }
+                /* if "r1" isn't NULL (old hive) and "r2" is (new hive) then
+                 * the hive shouldn't exist anymore and we have to generate a
+                 * del diff */
+                if ((r1 != NULL) && (r2 == NULL)) {
+                        callbacks->del_key(callback_data,
+                                           reg_predefined_keys[i].name);
+                }
+
                 error = reg_generate_diff_key(r1, r2,
                         reg_predefined_keys[i].name, callbacks,
@@ -300 +337 @@
  */
 _PUBLIC_ WERROR reg_diff_load(const char *filename,
-                              struct smb_iconv_convenience *iconv_convenience,
                               const struct reg_diff_callbacks *callbacks,
                               void *callback_data)
@@ -334 +370 @@
         if (strncmp(hdr, "PReg", 4) == 0) {
                 /* Must be a GPO Registry.pol file */
-                return reg_preg_diff_load(fd, iconv_convenience, callbacks, callback_data);
+                return reg_preg_diff_load(fd, callbacks, callback_data);
         } else {
                 /* Must be a normal .REG file */
-                return reg_dotreg_diff_load(fd, iconv_convenience, callbacks, callback_data);
+                return reg_dotreg_diff_load(fd, callbacks, callback_data);
         }
 }
@@ -353 +389 @@
         /* Recursively create the path */
         buf = talloc_strdup(ctx, key_name);
+        W_ERROR_HAVE_NO_MEMORY(buf);
         buf_ptr = buf;
 
@@ -367 +404 @@
                         }
                         *buf_ptr++ = '\\';
-                }
-        }
+                        talloc_free(tmp);
+                }
+        }
+
+        talloc_free(buf);
 
         /* Add the key */
@@ -379 +419 @@
                 return error;
         }
+        talloc_free(tmp);
+
         return WERR_OK;
 }
@@ -388 +430 @@
         /* We can't proof here for success, because a common superkey could */
         /* have been deleted before the subkey's (diff order). This removed */
-        /* therefore all childs recursively and the "WERR_BADFILE" result is */
+        /* therefore all children recursively and the "WERR_BADFILE" result is */
         /* expected. */
 
@@ -420 +462 @@
         }
 
+        talloc_free(tmp);
+
         return WERR_OK;
 }
@@ -438 +482 @@
         }
 
-        error = reg_del_value(tmp, value_name);
+        error = reg_del_value(ctx, tmp, value_name);
         if (!W_ERROR_IS_OK(error)) {
                 DEBUG(0, ("Error deleting value '%s'\n", value_name));
@@ -444 +488 @@
         }
 
+        talloc_free(tmp);
 
         return WERR_OK;
@@ -453 +498 @@
         struct registry_key *key;
         WERROR error;
-        const char* value_name;
+        const char *value_name;
 
         error = reg_open_key_abs(ctx, ctx, key_name, &key);
@@ -467 +512 @@
         while (W_ERROR_IS_OK(reg_key_get_value_by_index(
                         ctx, key, 0, &value_name, NULL, NULL))) {
-                error = reg_del_value(key, value_name);
+                error = reg_del_value(ctx, key, value_name);
                 if (!W_ERROR_IS_OK(error)) {
                         DEBUG(0, ("Error deleting value '%s'\n", value_name));
                         return error;
                 }
-        }
+                talloc_free(discard_const_p(char, value_name));
+        }
+
+        talloc_free(key);
 
         return WERR_OK;
@@ -481 +529 @@
  */
 _PUBLIC_ WERROR reg_diff_apply(struct registry_context *ctx, 
-                                                           struct smb_iconv_convenience *iconv_convenience, 
                                                            const char *filename)
 {
@@ -493 +540 @@
         callbacks.done = NULL;
 
-        return reg_diff_load(filename, iconv_convenience,
-                             &callbacks, ctx);
-}
+        return reg_diff_load(filename, &callbacks, ctx);
+}

vendor/current/source4/lib/registry/patchfile_dotreg.c

@@ -4 +4 @@
 
    Copyright (C) Jelmer Vernooij 2004-2007
-   Copyright (C) Wilco Baan Hofman 2006-2008
+   Copyright (C) Wilco Baan Hofman 2006-2010
 
    This program is free software; you can redistribute it and/or modify
@@ -21 +21 @@
 */
 
-/* FIXME Newer .REG files, created by Windows XP and above use unicode UCS-2 */
+/* FIXME:
+ * - Newer .REG files, created by Windows XP and above use unicode UCS-2
+ * - @="" constructions should write value with empty name.
+*/
 
 #include "includes.h"
@@ -36 +39 @@
 struct dotreg_data {
         int fd;
-        struct smb_iconv_convenience *iconv_convenience;
 };
+
+/* 
+ * This is basically a copy of data_blob_hex_string_upper, but with comma's 
+ * between the bytes in hex.
+ */
+static char *dotreg_data_blob_hex_string(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob)
+{
+        size_t i;
+        char *hex_string;
+
+        hex_string = talloc_array(mem_ctx, char, (blob->length*3)+1);
+        if (!hex_string) {
+                return NULL;
+        }
+
+        for (i = 0; i < blob->length; i++)
+                slprintf(&hex_string[i*3], 4, "%02X,", blob->data[i]);
+
+        /* Remove last comma and NULL-terminate the string */
+        hex_string[(blob->length*3)-1] = '\0';
+        return hex_string;
+}
+
+/* 
+ * This is basically a copy of reg_val_data_string, except that this function
+ * has no 0x for dwords, everything else is regarded as binary, and binary 
+ * strings are represented with bytes comma-separated.
+ */
+static char *reg_val_dotreg_string(TALLOC_CTX *mem_ctx, uint32_t type,
+                                   const DATA_BLOB data)
+{
+        char *ret = NULL;
+
+        if (data.length == 0)
+                return talloc_strdup(mem_ctx, "");
+
+        switch (type) {
+                case REG_EXPAND_SZ:
+                case REG_SZ:
+                        convert_string_talloc(mem_ctx,
+                                                          CH_UTF16, CH_UNIX, data.data, data.length,
+                                                          (void **)&ret, NULL, false);
+                        break;
+                case REG_DWORD:
+                case REG_DWORD_BIG_ENDIAN:
+                        SMB_ASSERT(data.length == sizeof(uint32_t));
+                        ret = talloc_asprintf(mem_ctx, "%08x",
+                                              IVAL(data.data, 0));
+                        break;
+                default: /* default means treat as binary */
+                case REG_BINARY:
+                        ret = dotreg_data_blob_hex_string(mem_ctx, &data);
+                        break;
+        }
+
+        return ret;
+}
 
 static WERROR reg_dotreg_diff_add_key(void *_data, const char *key_name)
@@ -62 +121 @@
 {
         struct dotreg_data *data = (struct dotreg_data *)_data;
-
-        fdprintf(data->fd, "\"%s\"=%s:%s\n",
-                        value_name, str_regtype(value_type),
-                        reg_val_data_string(NULL, data->iconv_convenience, value_type, value));
+        char *data_string = reg_val_dotreg_string(NULL, 
+                                                value_type, value);
+        char *data_incl_type;
+
+        W_ERROR_HAVE_NO_MEMORY(data_string);
+
+        switch (value_type) {
+                case REG_SZ:
+                        data_incl_type = talloc_asprintf(data_string, "\"%s\"", 
+                                        data_string);
+                        break;
+                case REG_DWORD:
+                        data_incl_type = talloc_asprintf(data_string, 
+                                        "dword:%s", data_string);
+                        break;
+                case REG_BINARY:
+                        data_incl_type = talloc_asprintf(data_string, "hex:%s",
+                                        data_string);
+                        break;
+                default:
+                        data_incl_type = talloc_asprintf(data_string, "hex(%x):%s", 
+                                        value_type, data_string);
+                        break;
+        }
+
+        if (value_name[0] == '\0') {
+                fdprintf(data->fd, "@=%s\n", data_incl_type);
+        } else {
+                fdprintf(data->fd, "\"%s\"=%s\n",
+                         value_name, data_incl_type);
+        }
+
+        talloc_free(data_string);
 
         return WERR_OK;
@@ -100 +188 @@
  */
 _PUBLIC_ WERROR reg_dotreg_diff_save(TALLOC_CTX *ctx, const char *filename,
-                                     struct smb_iconv_convenience *iconv_convenience,
                                      struct reg_diff_callbacks **callbacks,
                                      void **callback_data)
@@ -108 +195 @@
         data = talloc_zero(ctx, struct dotreg_data);
         *callback_data = data;
-
-        data->iconv_convenience = iconv_convenience;
 
         if (filename) {
@@ -139 +224 @@
  */
 _PUBLIC_ WERROR reg_dotreg_diff_load(int fd,
-                                     struct smb_iconv_convenience *iconv_convenience,
                                      const struct reg_diff_callbacks *callbacks,
                                      void *callback_data)
@@ -148 +232 @@
         WERROR error;
         uint32_t value_type;
-        DATA_BLOB value;
+        DATA_BLOB data;
+        bool result;
+        char *type_str = NULL;
+        char *data_str;
+        char *value;
+        bool continue_next_line = 0;
 
         line = afdgets(fd, mem_ctx, 0);
@@ -159 +248 @@
 
         while ((line = afdgets(fd, mem_ctx, 0))) {
+                /* Remove '\r' if it's a Windows text file */
+                if (line[strlen(line)-1] == '\r') {
+                        line[strlen(line)-1] = '\0';
+                }
+
                 /* Ignore comments and empty lines */
                 if (strlen(line) == 0 || line[0] == ';') {
@@ -172 +266 @@
                 /* Start of key */
                 if (line[0] == '[') {
-                        p = strchr_m(line, ']');
-                        if (p[strlen(p)-1] != ']') {
-                                DEBUG(0, ("Missing ']'\n"));
-                                return WERR_GENERAL_FAILURE;
-                        }
+                        if (line[strlen(line)-1] != ']') {
+                                DEBUG(0, ("Missing ']' on line: %s\n", line));
+                                talloc_free(line);
+                                continue;
+                        }
+
                         /* Deleting key */
                         if (line[1] == '-') {
                                 curkey = talloc_strndup(line, line+2, strlen(line)-3);
+                                W_ERROR_HAVE_NO_MEMORY(curkey);
 
                                 error = callbacks->del_key(callback_data,
                                                            curkey);
+
                                 if (!W_ERROR_IS_OK(error)) {
                                         DEBUG(0,("Error deleting key %s\n",
@@ -195 +292 @@
                         }
                         curkey = talloc_strndup(mem_ctx, line+1, strlen(line)-2);
+                        W_ERROR_HAVE_NO_MEMORY(curkey);
 
                         error = callbacks->add_key(callback_data, curkey);
@@ -208 +306 @@
 
                 /* 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;
-                }
-
-                /* Delete value */
-                if (strcmp(p, "-") == 0) {
-                        error = callbacks->del_value(callback_data,
-                                                     curkey, line);
-                        if (!W_ERROR_IS_OK(error)) {
-                                DEBUG(0, ("Error deleting value %s in key %s\n",
-                                        line, curkey));
-                                talloc_free(mem_ctx);
-                                return error;
-                        }
-
-                        talloc_free(line);
-                        continue;
-                }
-
-                q = strchr_m(p, ':');
-                if (q) {
-                        *q = '\0';
-                        q++;
-                }
-
-                reg_string_to_val(line, iconv_convenience, 
-                                  q?p:"REG_SZ", q?q:p,
-                                  &value_type, &value);
-
-                error = callbacks->set_value(callback_data, curkey, line,
-                                             value_type, value);
+                if (continue_next_line) {
+                        continue_next_line = 0;
+
+                        /* Continued data start with two whitespaces */
+                        if (line[0] != ' ' || line[1] != ' ') {
+                                DEBUG(0, ("Malformed line: %s\n", line));
+                                talloc_free(line);
+                                continue;
+                        }
+                        p = line + 2;
+
+                        /* Continue again if line ends with a backslash */
+                        if (line[strlen(line)-1] == '\\') {
+                                line[strlen(line)-1] = '\0';
+                                continue_next_line = 1;
+                                data_str = talloc_strdup_append(data_str, p);
+                                talloc_free(line);
+                                continue;
+                        }
+                        data_str = talloc_strdup_append(data_str, p);
+                } else {
+                        p = strchr_m(line, '=');
+                        if (p == NULL) {
+                                DEBUG(0, ("Malformed line: %s\n", line));
+                                talloc_free(line);
+                                continue;
+                        }
+
+                        *p = '\0'; p++;
+
+
+                        if (curkey == NULL) {
+                                DEBUG(0, ("Value change without key\n"));
+                                talloc_free(line);
+                                continue;
+                        }
+
+                        /* Values should be double-quoted */
+                        if (line[0] != '"') {
+                                DEBUG(0, ("Malformed line\n"));
+                                talloc_free(line);
+                                continue;
+                        }
+
+                        /* Chop of the quotes and store as value */
+                        value = talloc_strndup(mem_ctx, line+1,strlen(line)-2);
+
+                        /* Delete value */
+                        if (p[0] == '-') {
+                                error = callbacks->del_value(callback_data,
+                                                     curkey, value);
+
+                                /* Ignore if key does not exist (WERR_BADFILE)
+                                 * Consistent with Windows behaviour */
+                                if (!W_ERROR_IS_OK(error) &&
+                                    !W_ERROR_EQUAL(error, WERR_BADFILE)) {
+                                        DEBUG(0, ("Error deleting value %s in key %s\n",
+                                                value, curkey));
+                                        talloc_free(mem_ctx);
+                                        return error;
+                                }
+
+                                talloc_free(line);
+                                talloc_free(value);
+                                continue;
+                        }
+
+                        /* Do not look for colons in strings */
+                        if (p[0] == '"') {
+                                q = NULL;
+                                data_str = talloc_strndup(mem_ctx, p+1,strlen(p)-2);
+                        } else {
+                                /* Split the value type from the data */
+                                q = strchr_m(p, ':');
+                                if (q) {
+                                        *q = '\0';
+                                        q++;
+                                        type_str = talloc_strdup(mem_ctx, p);
+                                        data_str = talloc_strdup(mem_ctx, q);
+                                } else {
+                                        data_str = talloc_strdup(mem_ctx, p);
+                                }
+                        }
+
+                        /* Backslash before the CRLF means continue on next line */
+                        if (data_str[strlen(data_str)-1] == '\\') {
+                                data_str[strlen(data_str)-1] = '\0';
+                                talloc_free(line);
+                                continue_next_line = 1;
+                                continue;
+                        }
+                }
+                DEBUG(9, ("About to write %s with type %s, length %ld: %s\n", value, type_str, (long) strlen(data_str), data_str));
+                result = reg_string_to_val(value,
+                                  type_str?type_str:"REG_SZ", data_str,
+                                  &value_type, &data);
+                if (!result) {
+                        DEBUG(0, ("Error converting string to value for line:\n%s\n",
+                                        line));
+                        return WERR_GENERAL_FAILURE;
+                }
+
+                error = callbacks->set_value(callback_data, curkey, value,
+                                             value_type, data);
                 if (!W_ERROR_IS_OK(error)) {
                         DEBUG(0, ("Error setting value for %s in %s\n",
-                                line, curkey));
+                                value, curkey));
                         talloc_free(mem_ctx);
                         return error;
                 }
 
+                /* Clean up buffers */
+                if (type_str != NULL) {
+                        talloc_free(type_str);
+                        type_str = NULL;
+                }
+                talloc_free(data_str);
+                talloc_free(value);
                 talloc_free(line);
         }
@@ -262 +429 @@
         close(fd);
 
-        return WERR_OK;
-}
+        talloc_free(mem_ctx);
+
+        return WERR_OK;
+}

vendor/current/source4/lib/registry/patchfile_preg.c

@@ -34 +34 @@
         uint16_t v;
 
-        if (read(fd, &v, 2) < 2) {
+        if (read(fd, &v, sizeof(uint16_t)) < sizeof(uint16_t)) {
                 return WERR_GENERAL_FAILURE;
         }
@@ -42 +42 @@
 static WERROR preg_write_utf16(int fd, const char *string)
 {
-        codepoint_t v;
-        uint16_t i;
-        size_t size;
+        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, 2) < 2) {
+                if (write(fd, &v, sizeof(uint16_t)) < sizeof(uint16_t)) {
                         return WERR_GENERAL_FAILURE;
                 }
@@ -89 +88 @@
         char *parent_name;
         DATA_BLOB blob;
-
-        parent_name = talloc_strndup(data->ctx, key_name, strrchr(key_name, '\\')-key_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));
+        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(). */
-        return reg_preg_diff_set_value(data, parent_name, "**DeleteKeys", REG_SZ, blob);
+        werr = reg_preg_diff_set_value(data, parent_name, "**DeleteKeys",
+                                       REG_SZ, blob);
+
+        talloc_free(parent_name);
+        talloc_free(blob.data);
+
+        return werr;
 }
 
@@ -106 +116 @@
         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);
-        *(uint32_t *)blob.data = 0;
-        blob.length = 4;
-        return reg_preg_diff_set_value(data, key_name, val, REG_DWORD, blob);
+        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;
 }
 
@@ -119 +137 @@
         struct preg_data *data = (struct preg_data *)_data;
         DATA_BLOB blob;
+        WERROR werr;
 
         blob.data = (uint8_t *)talloc(data->ctx, uint32_t);
-        *(uint32_t *)blob.data = 0;     
-        blob.length = 4;
-
-        return reg_preg_diff_set_value(data, key_name, "**DelVals.", REG_DWORD, blob);
+        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;
 }
 
@@ -140 +165 @@
  */
 _PUBLIC_ WERROR reg_preg_diff_save(TALLOC_CTX *ctx, const char *filename,
-                                   struct smb_iconv_convenience *ic,
                                    struct reg_diff_callbacks **callbacks,
                                    void **callback_data)
@@ -165 +189 @@
 
         strncpy(preg_header.hdr, "PReg", 4);
-        SIVAL(&preg_header, 4, 1);
-        write(data->fd, (uint8_t *)&preg_header,8);
+        SIVAL(&preg_header.version, 0, 1);
+        write(data->fd, (uint8_t *)&preg_header, sizeof(preg_header));
 
         data->ctx = ctx;
@@ -185 +209 @@
  */
 _PUBLIC_ WERROR reg_preg_diff_load(int fd,
-                                   struct smb_iconv_convenience *iconv_convenience, 
                                    const struct reg_diff_callbacks *callbacks,
                                    void *callback_data)
@@ -206 +229 @@
 
         /* Read first 8 bytes (the header) */
-        if (read(fd, &preg_header, 8) != 8) {
+        if (read(fd, &preg_header, sizeof(preg_header)) != sizeof(preg_header)) {
                 DEBUG(0, ("Could not read PReg file: %s\n",
                                 strerror(errno)));
@@ -255 +278 @@
 
                 /* Get the type */
-                if (read(fd, &value_type, 4) < 4) {
+                if (read(fd, &value_type, sizeof(uint32_t)) < sizeof(uint32_t)) {
                         DEBUG(0, ("Error while reading PReg\n"));
                         ret = WERR_GENERAL_FAILURE;
@@ -270 +293 @@
                         goto cleanup;
                 }
+
                 /* Get data length */
-                if (read(fd, &length, 4) < 4) {
+                if (read(fd, &length, sizeof(uint32_t)) < sizeof(uint32_t)) {
                         DEBUG(0, ("Error while reading PReg\n"));
                         ret = WERR_GENERAL_FAILURE;
                         goto cleanup;
                 }
+                length = IVAL(&length, 0);
+
                 /* Read past delimiter */
                 buf_ptr = buf;
@@ -284 +310 @@
                         goto cleanup;
                 }
+
                 /* Get the data */
                 buf_ptr = buf;

vendor/current/source4/lib/registry/pyregistry.c

@@ -3 +3 @@
    Samba utility functions
    Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2008
+   Copyright (C) Wilco Baan Hofman <wilco@baanhofman.nl> 2010
    
    This program is free software; you can redistribute it and/or modify
@@ -18 +19 @@
 */
 
+#include <Python.h>
 #include "includes.h"
-#include <tevent.h>
-#include <Python.h>
 #include "libcli/util/pyerrors.h"
 #include "lib/registry/registry.h"
-#include "scripting/python/modules.h" /* for py_iconv_convenience() */
-#include <pytalloc.h>
+#include "lib/talloc/pytalloc.h"
+#include "lib/events/events.h"
 #include "auth/credentials/pycredentials.h"
 #include "param/pyparam.h"
 
-#ifndef Py_RETURN_NONE
-#define Py_RETURN_NONE return Py_INCREF(Py_None), Py_None
-#endif
-
-PyAPI_DATA(PyTypeObject) PyRegistryKey;
-PyAPI_DATA(PyTypeObject) PyRegistry;
-PyAPI_DATA(PyTypeObject) PyHiveKey;
+extern PyTypeObject PyRegistryKey;
+extern PyTypeObject PyRegistry;
+extern PyTypeObject PyHiveKey;
 
 /*#define PyRegistryKey_AsRegistryKey(obj) py_talloc_get_type(obj, struct registry_key)*/
@@ -96 +92 @@
                 return NULL;
 
-        result = reg_diff_apply(ctx, py_iconv_convenience(NULL), filename);
+        result = reg_diff_apply(ctx, filename);
         PyErr_WERROR_IS_ERR_RAISE(result);
 
@@ -164 +160 @@
         .tp_new = registry_new,
         .tp_basicsize = sizeof(py_talloc_Object),
-        .tp_dealloc = py_talloc_dealloc,
         .tp_flags = Py_TPFLAGS_DEFAULT,
 };
@@ -177 +172 @@
                 return NULL;
 
-        result = hive_key_del(key, name);
+        result = hive_key_del(NULL, key, name);
 
         PyErr_WERROR_IS_ERR_RAISE(result);
@@ -204 +199 @@
                 return NULL;
 
-        result = hive_key_del_value(key, name);
+        result = hive_key_del_value(NULL, key, name);
 
         PyErr_WERROR_IS_ERR_RAISE(result);
@@ -225 +220 @@
                 result = hive_key_set_value(key, name, type, value);
         else
-                result = hive_key_del_value(key, name);
+                result = hive_key_del_value(NULL, key, name);
 
         PyErr_WERROR_IS_ERR_RAISE(result);
@@ -244 +239 @@
 };
 
-static PyObject *hive_open(PyTypeObject *type, PyObject *args, PyObject *kwargs)
-{
-        /* reg_open_hive */
+static PyObject *hive_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) {
         Py_RETURN_NONE;
+}
+
+static PyObject *py_open_hive(PyTypeObject *type, PyObject *args, PyObject *kwargs)
+{
+        const char *kwnames[] = { "location", "lp_ctx", "session_info", "credentials", NULL };
+        WERROR result;
+        struct loadparm_context *lp_ctx;
+        PyObject *py_lp_ctx, *py_session_info, *py_credentials;
+        struct auth_session_info *session_info;
+        struct cli_credentials *credentials;
+        char *location;
+        struct hive_key *hive_key;
+        TALLOC_CTX *mem_ctx;
+
+        if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|OOO",
+                                         discard_const_p(char *, kwnames),
+                                         &location,
+                                         &py_lp_ctx, &py_session_info,
+                                         &py_credentials))
+                return NULL;
+
+        mem_ctx = talloc_new(NULL);
+        if (mem_ctx == NULL) {
+                PyErr_NoMemory();
+                return NULL;
+        }
+
+        lp_ctx = lpcfg_from_py_object(mem_ctx, py_lp_ctx);
+        if (lp_ctx == NULL) {
+                PyErr_SetString(PyExc_TypeError, "Expected loadparm context");
+                talloc_free(mem_ctx);
+                return NULL;
+        }
+
+        credentials = cli_credentials_from_py_object(py_credentials);
+        if (credentials == NULL) {
+                PyErr_SetString(PyExc_TypeError, "Expected credentials");
+                talloc_free(mem_ctx);
+                return NULL;
+        }
+        session_info = NULL;
+
+        result = reg_open_hive(NULL, location, session_info, credentials,
+                               tevent_context_init(NULL),
+                               lp_ctx, &hive_key);
+        talloc_free(mem_ctx);
+        PyErr_WERROR_IS_ERR_RAISE(result);
+
+        return py_talloc_steal(&PyHiveKey, hive_key);
 }
 
@@ -253 +295 @@
         .tp_name = "HiveKey",
         .tp_methods = hive_key_methods,
-        .tp_new = hive_open,
+        .tp_new = hive_new,
         .tp_basicsize = sizeof(py_talloc_Object),
-        .tp_dealloc = py_talloc_dealloc,
         .tp_flags = Py_TPFLAGS_DEFAULT,
 };
@@ -262 +303 @@
         .tp_name = "RegistryKey",
         .tp_basicsize = sizeof(py_talloc_Object),
-        .tp_dealloc = py_talloc_dealloc,
         .tp_flags = Py_TPFLAGS_DEFAULT,
 };
@@ -271 +311 @@
         struct registry_context *reg_ctx;
         WERROR result;
-    struct loadparm_context *lp_ctx;
+        struct loadparm_context *lp_ctx;
         PyObject *py_lp_ctx, *py_session_info, *py_credentials;
         struct auth_session_info *session_info;
-    struct cli_credentials *credentials;
-        if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOO", discard_const_p(char *, kwnames),
-                                         &py_lp_ctx, &py_session_info, &py_credentials))
-                return NULL;
-
-    lp_ctx = lp_from_py_object(py_lp_ctx);
-    if (lp_ctx == NULL) {
+        struct cli_credentials *credentials;
+        TALLOC_CTX *mem_ctx;
+
+        if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOO",
+                                         discard_const_p(char *, kwnames),
+                                         &py_lp_ctx, &py_session_info,
+                                         &py_credentials))
+                return NULL;
+
+        mem_ctx = talloc_new(NULL);
+        if (mem_ctx == NULL) {
+                PyErr_NoMemory();
+                return NULL;
+        }
+
+        lp_ctx = lpcfg_from_py_object(mem_ctx, py_lp_ctx);
+        if (lp_ctx == NULL) {
                 PyErr_SetString(PyExc_TypeError, "Expected loadparm context");
-                return NULL;
-    }
+                talloc_free(mem_ctx);
+                return NULL;
+        }
 
         credentials = cli_credentials_from_py_object(py_credentials);
         if (credentials == NULL) {
                 PyErr_SetString(PyExc_TypeError, "Expected credentials");
+                talloc_free(mem_ctx);
                 return NULL;
         }
@@ -295 +347 @@
         result = reg_open_samba(NULL, &reg_ctx, NULL, 
                                 lp_ctx, session_info, credentials);
+        talloc_free(mem_ctx);
         if (!W_ERROR_IS_OK(result)) {
                 PyErr_SetWERROR(result);
                 return NULL;
         }
-        
+
         return py_talloc_steal(&PyRegistry, reg_ctx);
 }
@@ -339 +392 @@
         WERROR result;
         char *location;
-    struct loadparm_context *lp_ctx;
-    struct cli_credentials *credentials;
+        struct loadparm_context *lp_ctx;
+        struct cli_credentials *credentials;
         struct hive_key *key;
         struct auth_session_info *session_info;
+        TALLOC_CTX *mem_ctx;
 
         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|OOO", 
-                                                                         discard_const_p(char *, kwnames), 
-                                                                         &location, 
-                                                                         &py_session_info, &py_credentials,
-                                                                         &py_lp_ctx))
-                return NULL;
-
-    lp_ctx = lp_from_py_object(py_lp_ctx);
-    if (lp_ctx == NULL) {
+                                         discard_const_p(char *, kwnames),
+                                         &location, &py_session_info,
+                                         &py_credentials, &py_lp_ctx))
+                return NULL;
+
+        mem_ctx = talloc_new(NULL);
+        if (mem_ctx == NULL) {
+                PyErr_NoMemory();
+                return NULL;
+        }
+
+        lp_ctx = lpcfg_from_py_object(mem_ctx, py_lp_ctx);
+        if (lp_ctx == NULL) {
                 PyErr_SetString(PyExc_TypeError, "Expected loadparm context");
-                return NULL;
-    }
+                talloc_free(mem_ctx);
+                return NULL;
+        }
 
         credentials = cli_credentials_from_py_object(py_credentials);
         if (credentials == NULL) {
                 PyErr_SetString(PyExc_TypeError, "Expected credentials");
+                talloc_free(mem_ctx);
                 return NULL;
         }
@@ -366 +427 @@
 
         result = reg_open_ldb_file(NULL, location, session_info, credentials,
-                                                           tevent_context_init(NULL), lp_ctx, &key);
+                                   s4_event_context_init(NULL), lp_ctx, &key);
+        talloc_free(mem_ctx);
         PyErr_WERROR_IS_ERR_RAISE(result);
 
@@ -401 +463 @@
         { "create_directory", py_create_directory, METH_VARARGS, "create_dir(location) -> key" },
         { "open_ldb", (PyCFunction)py_open_ldb_file, METH_VARARGS|METH_KEYWORDS, "open_ldb(location, session_info=None, credentials=None, loadparm_context=None) -> key" },
+        { "open_hive", (PyCFunction)py_open_hive, METH_VARARGS|METH_KEYWORDS, "open_hive(location, session_info=None, credentials=None, loadparm_context=None) -> key" },
         { "str_regtype", py_str_regtype, METH_VARARGS, "str_regtype(int) -> str" },
         { "get_predef_name", py_get_predef_name, METH_VARARGS, "get_predef_name(hkey) -> str" },
@@ -409 +472 @@
 {
         PyObject *m;
+        PyTypeObject *talloc_type = PyTalloc_GetObjectType();
+
+        if (talloc_type == NULL)
+                return;
+
+        PyHiveKey.tp_base = talloc_type;
+        PyRegistry.tp_base = talloc_type;
+        PyRegistryKey.tp_base = talloc_type;
 
         if (PyType_Ready(&PyHiveKey) < 0)

vendor/current/source4/lib/registry/regf.c

@@ -3 +3 @@
    Registry backend for REGF files
    Copyright (C) 2005-2007 Jelmer Vernooij, jelmer@samba.org
-   Copyright (C) 2006 Wilco Baan Hofman, wilco@baanhofman.nl
+   Copyright (C) 2006-2010 Wilco Baan Hofman, wilco@baanhofman.nl
 
    This program is free software; you can redistribute it and/or modify
@@ -50 +50 @@
         struct hbin_block **hbins;
         struct regf_hdr *header;
-        struct smb_iconv_convenience *iconv_convenience;
+        time_t last_write;
 };
 
-static WERROR regf_save_hbin(struct regf_data *data);
+static WERROR regf_save_hbin(struct regf_data *data, bool flush);
 
 struct regf_key_data {
@@ -65 +65 @@
                                          uint32_t offset, uint32_t *rel_offset)
 {
-        int i;
+        unsigned int i;
 
         for (i = 0; data->hbins[i]; i++) {
@@ -87 +87 @@
 {
         uint32_t checksum = 0, x;
-        int i;
+        unsigned int i;
 
         for (i = 0; i < 0x01FB; i+= 4) {
@@ -112 +112 @@
 
         if (hbin == NULL) {
-                DEBUG(1, ("Can't find HBIN containing 0x%04x\n", offset));
+                DEBUG(1, ("Can't find HBIN at 0x%04x\n", offset));
                 return ret;
         }
@@ -135 +135 @@
                          TALLOC_CTX *ctx, tdr_pull_fn_t pull_fn, void *p)
 {
-        struct tdr_pull *pull = tdr_pull_init(regf, regf->iconv_convenience);
+        struct tdr_pull *pull = tdr_pull_init(regf);
 
         pull->data = hbin_get(regf, offset);
@@ -160 +160 @@
 {
         DATA_BLOB ret;
-        uint32_t rel_offset = -1; /* Relative offset ! */
+        uint32_t rel_offset = (uint32_t) -1; /* Relative offset ! */
         struct hbin_block *hbin = NULL;
-        int i;
+        unsigned int i;
 
         *offset = 0;
@@ -218 +218 @@
                 DEBUG(4, ("No space available in other HBINs for block of size %d, allocating new HBIN\n",
                         size));
+
+                /* Add extra hbin block */
                 data->hbins = talloc_realloc(data, data->hbins,
                                              struct hbin_block *, i+2);
@@ -226 +228 @@
                 data->hbins[i+1] = NULL;
 
+                /* Set hbin data */
                 hbin->HBIN_ID = talloc_strdup(hbin, "hbin");
                 hbin->offset_from_first = (i == 0?0:data->hbins[i-1]->offset_from_first+data->hbins[i-1]->offset_to_next);
                 hbin->offset_to_next = 0x1000;
                 hbin->unknown[0] = 0;
-                hbin->unknown[0] = 0;
+                hbin->unknown[1] = 0;
                 unix_to_nt_time(&hbin->last_change, time(NULL));
                 hbin->block_size = hbin->offset_to_next;
                 hbin->data = talloc_zero_array(hbin, uint8_t, hbin->block_size - 0x20);
-
+                /* Update the regf header */
+                data->header->last_block += hbin->offset_to_next;
+
+                /* Set the next block to it's proper size and set the
+                 * rel_offset for this block */
+                SIVAL(hbin->data, size, hbin->block_size - size - 0x20);
                 rel_offset = 0x0;
-                SIVAL(hbin->data, size, hbin->block_size - size - 0x20);
         }
 
@@ -262 +269 @@
         memcpy(dest.data, blob.data, blob.length);
 
+        /* Make sure that we have no tailing garbage in the block */
+        if (dest.length > blob.length) {
+                memset(dest.data + blob.length, 0, dest.length - blob.length);
+        }
+
         return ret;
 }
@@ -268 +280 @@
                                tdr_push_fn_t push_fn, void *p)
 {
-        struct tdr_push *push = tdr_push_init(data, data->iconv_convenience);
+        struct tdr_push *push = tdr_push_init(data);
         uint32_t ret;
 
@@ -311 +323 @@
 
         /* If the next block is free, merge into big free block */
-        if (rel_offset + size < hbin->offset_to_next) {
+        if (rel_offset + size < hbin->offset_to_next - 0x20) {
                 next_size = IVALS(hbin->data, rel_offset+size);
                 if (next_size > 0) {
@@ -336 +348 @@
         int32_t needed_size;
         int32_t possible_size;
-        int i;
+        unsigned int i;
 
         SMB_ASSERT(orig_offset > 0);
@@ -395 +407 @@
                                       uint32_t orig_offset, void *p)
 {
-        struct tdr_push *push = tdr_push_init(regf, regf->iconv_convenience);
+        struct tdr_push *push = tdr_push_init(regf);
         uint32_t ret;
 
@@ -451 +463 @@
                                                     (char*)data.data,
                                                     private_data->nk->clsname_length);
+                        W_ERROR_HAVE_NO_MEMORY(*classname);
                 } else
                         *classname = NULL;
@@ -485 +498 @@
         if (!hbin_get_tdr(regf, offset, nk,
                           (tdr_pull_fn_t)tdr_pull_nk_block, nk)) {
-                DEBUG(0, ("Unable to find HBIN data for offset %d\n", offset));
+                DEBUG(0, ("Unable to find HBIN data for offset 0x%x\n", offset));
                 return NULL;
         }
@@ -500 +513 @@
 
 static WERROR regf_get_value(TALLOC_CTX *ctx, struct hive_key *key,
-                             int idx, const char **name,
+                             uint32_t idx, const char **name,
                              uint32_t *data_type, DATA_BLOB *data)
 {
@@ -515 +528 @@
         tmp = hbin_get(regf, private_data->nk->values_offset);
         if (!tmp.data) {
-                DEBUG(0, ("Unable to find value list\n"));
+                DEBUG(0, ("Unable to find value list at 0x%x\n",
+                                private_data->nk->values_offset));
                 return WERR_GENERAL_FAILURE;
         }
@@ -530 +544 @@
         if (!hbin_get_tdr(regf, vk_offset, vk,
                           (tdr_pull_fn_t)tdr_pull_vk_block, vk)) {
-                DEBUG(0, ("Unable to get VK block at %d\n", vk_offset));
+                DEBUG(0, ("Unable to get VK block at 0x%x\n", vk_offset));
                 talloc_free(vk);
                 return WERR_GENERAL_FAILURE;
@@ -536 +550 @@
 
         /* FIXME: name character set ?*/
-        if (name != NULL)
+        if (name != NULL) {
                 *name = talloc_strndup(ctx, vk->data_name, vk->name_length);
+                W_ERROR_HAVE_NO_MEMORY(*name);
+        }
 
         if (data_type != NULL)
@@ -543 +559 @@
 
         if (vk->data_length & 0x80000000) {
-                vk->data_length &=~0x80000000;
-                data->data = (uint8_t *)talloc_memdup(ctx, (uint8_t *)&vk->data_offset, vk->data_length);
-                data->length = vk->data_length;
+                /* this is data of type "REG_DWORD" or "REG_DWORD_BIG_ENDIAN" */
+                data->data = talloc_size(ctx, sizeof(uint32_t));
+                W_ERROR_HAVE_NO_MEMORY(data->data);
+                SIVAL(data->data, 0, vk->data_offset);
+                data->length = sizeof(uint32_t);
         } else {
                 *data = hbin_get(regf, vk->data_offset);
@@ -563 +581 @@
                                      uint32_t *type, DATA_BLOB *data)
 {
-        int i;
+        unsigned int i;
         const char *vname;
         WERROR error;
@@ -598 +616 @@
                 return WERR_NO_MORE_ITEMS;
 
+        /* Make sure that we don't crash if the key is empty */
+        if (nk->subkeys_offset == -1) {
+                return WERR_NO_MORE_ITEMS;
+        }
+
         data = hbin_get(private_data->hive, nk->subkeys_offset);
         if (!data.data) {
-                DEBUG(0, ("Unable to find subkey list\n"));
+                DEBUG(0, ("Unable to find subkey list at 0x%x\n",
+                        nk->subkeys_offset));
                 return WERR_GENERAL_FAILURE;
         }
@@ -606 +630 @@
         if (!strncmp((char *)data.data, "li", 2)) {
                 struct li_block li;
-                struct tdr_pull *pull = tdr_pull_init(private_data->hive, private_data->hive->iconv_convenience);
+                struct tdr_pull *pull = tdr_pull_init(private_data->hive);
 
                 DEBUG(10, ("Subkeys in LI list\n"));
@@ -627 +651 @@
         } else if (!strncmp((char *)data.data, "lf", 2)) {
                 struct lf_block lf;
-                struct tdr_pull *pull = tdr_pull_init(private_data->hive, private_data->hive->iconv_convenience);
+                struct tdr_pull *pull = tdr_pull_init(private_data->hive);
 
                 DEBUG(10, ("Subkeys in LF list\n"));
@@ -648 +672 @@
         } else if (!strncmp((char *)data.data, "lh", 2)) {
                 struct lh_block lh;
-                struct tdr_pull *pull = tdr_pull_init(private_data->hive, private_data->hive->iconv_convenience);
+                struct tdr_pull *pull = tdr_pull_init(private_data->hive);
 
                 DEBUG(10, ("Subkeys in LH list\n"));
@@ -668 +692 @@
         } else if (!strncmp((char *)data.data, "ri", 2)) {
                 struct ri_block ri;
-                struct tdr_pull *pull = tdr_pull_init(ctx, private_data->hive->iconv_convenience);
+                struct tdr_pull *pull = tdr_pull_init(ctx);
                 uint16_t i;
                 uint16_t sublist_count = 0;
@@ -769 +793 @@
                                                     (char*)db.data,
                                                     ret->nk->clsname_length);
+                        W_ERROR_HAVE_NO_MEMORY(*classname);
                 } else
                         *classname = NULL;
@@ -801 +826 @@
         }
 
-        pull = tdr_pull_init(ctx, private_data->hive->iconv_convenience);
+        pull = tdr_pull_init(ctx);
 
         pull->data = subkey_data;
@@ -836 +861 @@
         uint32_t key_off = 0;
 
+        /* Make sure that we don't crash if the key is empty */
+        if (nk->subkeys_offset == -1) {
+                return WERR_BADFILE;
+        }
+
         data = hbin_get(private_data->hive, nk->subkeys_offset);
         if (!data.data) {
@@ -844 +874 @@
         if (!strncmp((char *)data.data, "li", 2)) {
                 struct li_block li;
-                struct tdr_pull *pull = tdr_pull_init(ctx, private_data->hive->iconv_convenience);
+                struct tdr_pull *pull = tdr_pull_init(ctx);
                 uint16_t i;
 
@@ -875 +905 @@
         } else if (!strncmp((char *)data.data, "lf", 2)) {
                 struct lf_block lf;
-                struct tdr_pull *pull = tdr_pull_init(ctx, private_data->hive->iconv_convenience);
+                struct tdr_pull *pull = tdr_pull_init(ctx);
                 uint16_t i;
 
@@ -910 +940 @@
         } else if (!strncmp((char *)data.data, "lh", 2)) {
                 struct lh_block lh;
-                struct tdr_pull *pull = tdr_pull_init(ctx, private_data->hive->iconv_convenience);
+                struct tdr_pull *pull = tdr_pull_init(ctx);
                 uint16_t i;
                 uint32_t hash;
@@ -947 +977 @@
         } else if (!strncmp((char *)data.data, "ri", 2)) {
                 struct ri_block ri;
-                struct tdr_pull *pull = tdr_pull_init(ctx, private_data->hive->iconv_convenience);
+                struct tdr_pull *pull = tdr_pull_init(ctx);
                 uint16_t i, j;
 
@@ -1052 +1082 @@
 
         /* Push the security descriptor to a blob */
-        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_push_struct_blob(&data, regf, NULL, 
+        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_push_struct_blob(&data, regf, 
                                                           sec_desc, (ndr_push_flags_fn_t)ndr_push_security_descriptor))) {
                 DEBUG(0, ("Unable to push security descriptor\n"));
@@ -1205 +1235 @@
         data.data = sk.sec_desc;
         data.length = sk.rec_size;
-        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_pull_struct_blob(&data, ctx, NULL, *sd,
+        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_pull_struct_blob(&data, ctx, *sd,
                                                   (ndr_pull_flags_fn_t)ndr_pull_security_descriptor))) {
                 DEBUG(0, ("Error parsing security descriptor\n"));
@@ -1289 +1319 @@
 
         if (!strncmp((char *)data.data, "li", 2)) {
-                struct tdr_pull *pull = tdr_pull_init(regf, regf->iconv_convenience);
+                struct tdr_pull *pull = tdr_pull_init(regf);
                 struct li_block li;
+                struct nk_block sub_nk;
+                int32_t i, j;
 
                 pull->data = data;
@@ -1307 +1339 @@
                 }
 
+                /* 
+                 * Find the position to store the pointer
+                 * Extensive testing reveils that at least on windows 7 subkeys 
+                 * *MUST* be stored in alphabetical order
+                 */
+                for (i = 0; i < li.key_count; i++) {
+                        /* Get the nk */
+                        hbin_get_tdr(regf, li.nk_offset[i], regf,
+                                        (tdr_pull_fn_t) tdr_pull_nk_block, &sub_nk);
+                        if (strcasecmp(name, sub_nk.key_name) < 0) {
+                                break;
+                        }
+                }
+
                 li.nk_offset = talloc_realloc(regf, li.nk_offset,
                                               uint32_t, li.key_count+1);
                 W_ERROR_HAVE_NO_MEMORY(li.nk_offset);
-                li.nk_offset[li.key_count] = key_offset;
+
+                /* Move everything behind this offset */
+                for (j = li.key_count - 1; j >= i; j--) {
+                        li.nk_offset[j+1] = li.nk_offset[j];
+                }
+                        
+                li.nk_offset[i] = key_offset;
                 li.key_count++;
                 *ret = hbin_store_tdr_resize(regf,
@@ -1318 +1370 @@
                 talloc_free(li.nk_offset);
         } else if (!strncmp((char *)data.data, "lf", 2)) {
-                struct tdr_pull *pull = tdr_pull_init(regf, regf->iconv_convenience);
+                struct tdr_pull *pull = tdr_pull_init(regf);
                 struct lf_block lf;
+                struct nk_block sub_nk;
+                int32_t i, j;
 
                 pull->data = data;
@@ -1331 +1385 @@
                 SMB_ASSERT(!strncmp(lf.header, "lf", 2));
 
+                /* 
+                 * Find the position to store the hash record
+                 * Extensive testing reveils that at least on windows 7 subkeys 
+                 * *MUST* be stored in alphabetical order
+                 */
+                for (i = 0; i < lf.key_count; i++) {
+                        /* Get the nk */
+                        hbin_get_tdr(regf, lf.hr[i].nk_offset, regf,
+                                        (tdr_pull_fn_t) tdr_pull_nk_block, &sub_nk);
+                        if (strcasecmp(name, sub_nk.key_name) < 0) {
+                                break;
+                        }
+                }
+
                 lf.hr = talloc_realloc(regf, lf.hr, struct hash_record,
                                        lf.key_count+1);
                 W_ERROR_HAVE_NO_MEMORY(lf.hr);
-                lf.hr[lf.key_count].nk_offset = key_offset;
-                lf.hr[lf.key_count].hash = talloc_strndup(lf.hr, name, 4);
+
+                /* Move everything behind this hash record */
+                for (j = lf.key_count - 1; j >= i; j--) {
+                        lf.hr[j+1] = lf.hr[j];
+                }
+
+                lf.hr[i].nk_offset = key_offset;
+                lf.hr[i].hash = talloc_strndup(lf.hr, name, 4);
                 W_ERROR_HAVE_NO_MEMORY(lf.hr[lf.key_count].hash);
                 lf.key_count++;
@@ -1344 +1418 @@
                 talloc_free(lf.hr);
         } else if (!strncmp((char *)data.data, "lh", 2)) {
-                struct tdr_pull *pull = tdr_pull_init(regf, regf->iconv_convenience);
+                struct tdr_pull *pull = tdr_pull_init(regf);
                 struct lh_block lh;
+                struct nk_block sub_nk;
+                int32_t i, j;
 
                 pull->data = data;
@@ -1357 +1433 @@
                 SMB_ASSERT(!strncmp(lh.header, "lh", 2));
 
+                /* 
+                 * Find the position to store the hash record
+                 * Extensive testing reveils that at least on windows 7 subkeys 
+                 * *MUST* be stored in alphabetical order
+                 */
+                for (i = 0; i < lh.key_count; i++) {
+                        /* Get the nk */
+                        hbin_get_tdr(regf, lh.hr[i].nk_offset, regf,
+                                        (tdr_pull_fn_t) tdr_pull_nk_block, &sub_nk);
+                        if (strcasecmp(name, sub_nk.key_name) < 0) {
+                                break;
+                        }
+                }
+
                 lh.hr = talloc_realloc(regf, lh.hr, struct lh_hash,
                                        lh.key_count+1);
                 W_ERROR_HAVE_NO_MEMORY(lh.hr);
-                lh.hr[lh.key_count].nk_offset = key_offset;
-                lh.hr[lh.key_count].base37 = regf_create_lh_hash(name);
+
+                /* Move everything behind this hash record */
+                for (j = lh.key_count - 1; j >= i; j--) {
+                        lh.hr[j+1] = lh.hr[j];
+                }
+
+                lh.hr[i].nk_offset = key_offset;
+                lh.hr[i].base37 = regf_create_lh_hash(name);
                 lh.key_count++;
                 *ret = hbin_store_tdr_resize(regf,
@@ -1393 +1489 @@
         if (strncmp((char *)data.data, "li", 2) == 0) {
                 struct li_block li;
-                struct tdr_pull *pull = tdr_pull_init(regf, regf->iconv_convenience);
+                struct tdr_pull *pull = tdr_pull_init(regf);
                 uint16_t i;
                 bool found_offset = false;
@@ -1437 +1533 @@
         } else if (strncmp((char *)data.data, "lf", 2) == 0) {
                 struct lf_block lf;
-                struct tdr_pull *pull = tdr_pull_init(regf, regf->iconv_convenience);
+                struct tdr_pull *pull = tdr_pull_init(regf);
                 uint16_t i;
                 bool found_offset = false;
@@ -1483 +1579 @@
         } else if (strncmp((char *)data.data, "lh", 2) == 0) {
                 struct lh_block lh;
-                struct tdr_pull *pull = tdr_pull_init(regf, regf->iconv_convenience);
+                struct tdr_pull *pull = tdr_pull_init(regf);
                 uint16_t i;
                 bool found_offset = false;
@@ -1538 +1634 @@
 }
 
-static WERROR regf_del_value (struct hive_key *key, const char *name)
+static WERROR regf_del_value(TALLOC_CTX *mem_ctx, struct hive_key *key,
+                             const char *name)
 {
         struct regf_key_data *private_data = (struct regf_key_data *)key;
@@ -1547 +1644 @@
         bool found_offset = false;
         DATA_BLOB values;
-        uint32_t i;
+        unsigned int i;
 
         if (nk->values_offset == -1) {
@@ -1592 +1689 @@
                               private_data->offset, nk);
 
-        return regf_save_hbin(private_data->hive);
-}
-
-
-static WERROR regf_del_key(const struct hive_key *parent, const char *name)
+        return regf_save_hbin(private_data->hive, 0);
+}
+
+
+static WERROR regf_del_key(TALLOC_CTX *mem_ctx, const struct hive_key *parent,
+                           const char *name)
 {
         const struct regf_key_data *private_data =
@@ -1623 +1721 @@
                 char *sk_name;
                 struct hive_key *sk = (struct hive_key *)key;
-                int i = key->nk->num_subkeys;
+                unsigned int i = key->nk->num_subkeys;
                 while (i--) {
                         /* Get subkey information. */
@@ -1635 +1733 @@
 
                         /* Delete subkey. */
-                        error = regf_del_key(sk, sk_name);
+                        error = regf_del_key(NULL, sk, sk_name);
                         if (!W_ERROR_IS_OK(error)) {
                                 DEBUG(0, ("Can't delete key '%s'.\n", sk_name));
@@ -1649 +1747 @@
                 struct hive_key *sk = (struct hive_key *)key;
                 DATA_BLOB data;
-                int i = key->nk->num_values;
+                unsigned int i = key->nk->num_values;
                 while (i--) {
                         /* Get value information. */
@@ -1661 +1759 @@
 
                         /* Delete value. */
-                        error = regf_del_value(sk, val_name);
+                        error = regf_del_value(NULL, sk, val_name);
                         if (!W_ERROR_IS_OK(error)) {
                                 DEBUG(0, ("Can't delete value '%s'.\n", val_name));
@@ -1690 +1788 @@
         hbin_free(private_data->hive, key->offset);
 
-        return regf_save_hbin(private_data->hive);
+        return regf_save_hbin(private_data->hive, 0);
 }
 
@@ -1717 +1815 @@
         nk.num_values = 0;
         nk.values_offset = -1;
-        memset(nk.unk3, 0, 5);
+        memset(nk.unk3, 0, sizeof(nk.unk3));
         nk.clsname_offset = -1; /* FIXME: fill in */
         nk.clsname_length = 0;
@@ -1728 +1826 @@
         if (!hbin_get_tdr(regf, regf->header->data_offset, root,
                           (tdr_pull_fn_t)tdr_pull_nk_block, root)) {
-                DEBUG(0, ("Unable to find HBIN data for offset %d\n",
+                DEBUG(0, ("Unable to find HBIN data for offset 0x%x\n",
                         regf->header->data_offset));
                 return WERR_GENERAL_FAILURE;
@@ -1753 +1851 @@
         *ret = (struct hive_key *)regf_get_key(ctx, regf, offset);
 
-        return regf_save_hbin(private_data->hive);
+        DEBUG(9, ("Storing key %s\n", name));
+        return regf_save_hbin(private_data->hive, 0);
 }
 
@@ -1764 +1863 @@
         struct vk_block vk;
         uint32_t i;
-        uint32_t tmp_vk_offset, vk_offset, old_vk_offset = -1;
+        uint32_t tmp_vk_offset, vk_offset, old_vk_offset = (uint32_t) -1;
         DATA_BLOB values;
 
@@ -1778 +1877 @@
                                           (tdr_pull_fn_t)tdr_pull_vk_block,
                                           &vk)) {
-                                DEBUG(0, ("Unable to get VK block at %d\n",
+                                DEBUG(0, ("Unable to get VK block at 0x%x\n",
                                         tmp_vk_offset));
                                 return WERR_GENERAL_FAILURE;
@@ -1787 +1886 @@
                         }
                 }
-                /* Free data, if any */
-                if (!(vk.data_length & 0x80000000)) {
-                        hbin_free(regf, vk.data_offset);
-                }
-        }
+        }
+
+        /* If it's new, create the vk struct, if it's old, free the old data. */
         if (old_vk_offset == -1) {
                 vk.header = "vk";
@@ -1802 +1899 @@
                         vk.flag = 0;
                 }
-        }
+        } else {
+                /* Free data, if any */
+                if (!(vk.data_length & 0x80000000)) {
+                        hbin_free(regf, vk.data_offset);
+                }
+        }
+
         /* Set the type and data */
         vk.data_length = data.length;
         vk.data_type = type;
-        if (type == REG_DWORD) {
+        if ((type == REG_DWORD) || (type == REG_DWORD_BIG_ENDIAN)) {
+                if (vk.data_length != sizeof(uint32_t)) {
+                        DEBUG(0, ("DWORD or DWORD_BIG_ENDIAN value with size other than 4 byte!\n"));
+                        return WERR_NOT_SUPPORTED;
+                }
                 vk.data_length |= 0x80000000;
-                vk.data_offset = *(uint32_t *)data.data;
+                vk.data_offset = IVAL(data.data, 0);
         } else {
                 /* Store data somewhere */
@@ -1864 +1971 @@
                               (tdr_push_fn_t) tdr_push_nk_block,
                               private_data->offset, nk);
-        return regf_save_hbin(private_data->hive);
-}
-
-static WERROR regf_save_hbin(struct regf_data *regf)
-{
-        struct tdr_push *push = tdr_push_init(regf, regf->iconv_convenience);
-        int i;
+        return regf_save_hbin(private_data->hive, 0);
+}
+
+static WERROR regf_save_hbin(struct regf_data *regf, bool flush)
+{
+        struct tdr_push *push = tdr_push_init(regf);
+        unsigned int i;
 
         W_ERROR_HAVE_NO_MEMORY(push);
+
+        /* Only write once every 5 seconds, or when flush is set */
+        if (!flush && regf->last_write + 5 >= time(NULL)) {
+                return WERR_OK;
+        }
+
+        regf->last_write = time(NULL);
 
         if (lseek(regf->fd, 0, SEEK_SET) == -1) {
@@ -1887 +2001 @@
         talloc_free(push);
 
-        if (NT_STATUS_IS_ERR(tdr_push_to_fd(regf->fd, regf->iconv_convenience,
+        if (NT_STATUS_IS_ERR(tdr_push_to_fd(regf->fd,
                                             (tdr_push_fn_t)tdr_push_regf_hdr,
                                             regf->header))) {
@@ -1900 +2014 @@
 
         for (i = 0; regf->hbins[i]; i++) {
-                if (NT_STATUS_IS_ERR(tdr_push_to_fd(regf->fd, regf->iconv_convenience,
+                if (NT_STATUS_IS_ERR(tdr_push_to_fd(regf->fd, 
                                                     (tdr_push_fn_t)tdr_push_hbin_block,
                                                     regf->hbins[i]))) {
@@ -1912 +2026 @@
 
 WERROR reg_create_regf_file(TALLOC_CTX *parent_ctx, 
-                            struct smb_iconv_convenience *iconv_convenience,
                             const char *location,
                             int minor_version, struct hive_key **key)
@@ -1926 +2039 @@
 
         regf = (struct regf_data *)talloc_zero(NULL, struct regf_data);
-
-        regf->iconv_convenience = iconv_convenience;
 
         W_ERROR_HAVE_NO_MEMORY(regf);
@@ -1963 +2074 @@
 
         nk.header = "nk";
-        nk.type = REG_SUB_KEY;
+        nk.type = REG_ROOT_KEY;
         unix_to_nt_time(&nk.last_change, time(NULL));
         nk.uk1 = 0;
@@ -1997 +2108 @@
         
         /* Push the security descriptor to a blob */
-        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_push_struct_blob(&data, regf, NULL, 
+        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_push_struct_blob(&data, regf, 
                                      sd, (ndr_push_flags_fn_t)ndr_push_security_descriptor))) {
                 DEBUG(0, ("Unable to push security descriptor\n"));
@@ -2028 +2139 @@
                                                regf->header->data_offset);
 
-        error = regf_save_hbin(regf);
+        error = regf_save_hbin(regf, 1);
         if (!W_ERROR_IS_OK(error)) {
                 return error;
@@ -2034 +2145 @@
         
         /* We can drop our own reference now that *key will have created one */
-        talloc_free(regf);
+        talloc_unlink(NULL, regf);
 
         return WERR_OK;
 }
 
+static WERROR regf_flush_key(struct hive_key *key)
+{
+        struct regf_key_data *private_data = (struct regf_key_data *)key;
+        struct regf_data *regf = private_data->hive;
+        WERROR error;
+
+        error = regf_save_hbin(regf, 1);
+        if (!W_ERROR_IS_OK(error)) {
+                DEBUG(0, ("Failed to flush regf to disk\n"));
+                return error;
+        }
+
+        return WERR_OK;
+}
+
+static int regf_destruct(struct regf_data *regf)
+{
+        WERROR error;
+
+        /* Write to disk */
+        error = regf_save_hbin(regf, 1);
+        if (!W_ERROR_IS_OK(error)) {
+                DEBUG(0, ("Failed to flush registry to disk\n"));
+                return -1;
+        }
+
+        /* Close file descriptor */
+        close(regf->fd);
+
+        return 0;
+}
+
 WERROR reg_open_regf_file(TALLOC_CTX *parent_ctx, const char *location, 
-                          struct smb_iconv_convenience *iconv_convenience, struct hive_key **key)
+                          struct hive_key **key)
 {
         struct regf_data *regf;
         struct regf_hdr *regf_hdr;
         struct tdr_pull *pull;
-        int i;
+        unsigned int i;
 
         regf = (struct regf_data *)talloc_zero(parent_ctx, struct regf_data);
-
-        regf->iconv_convenience = iconv_convenience;
-
         W_ERROR_HAVE_NO_MEMORY(regf);
+
+        talloc_set_destructor(regf, regf_destruct);
 
         DEBUG(5, ("Attempting to load registry file\n"));
@@ -2065 +2207 @@
         }
 
-        pull = tdr_pull_init(regf, regf->iconv_convenience);
+        pull = tdr_pull_init(regf);
 
         pull->data.data = (uint8_t*)fd_load(regf->fd, &pull->data.length, 0, regf);
@@ -2163 +2305 @@
         .del_key = regf_del_key,
         .delete_value = regf_del_value,
+        .flush_key = regf_flush_key
 };

vendor/current/source4/lib/registry/regf.idl

@@ -25 +25 @@
         [noprint] struct regf_version {
                 [value(1)] uint32 major; 
-                [value(3)] uint32 minor;
+                uint32 minor;
                 [value(0)] uint32 release;
                 [value(1)] uint32 build;
@@ -75 +75 @@
 
         [noprint] enum reg_key_type { 
-                REG_ROOT_KEY = 0x20, 
-                REG_SUB_KEY  = 0x2C, 
+                REG_ROOT_KEY = 0x2C, 
+                REG_SUB_KEY  = 0x20, 
                 REG_SYM_LINK = 0x10 
         };

vendor/current/source4/lib/registry/registry.h

@@ -24 +24 @@
 struct registry_context;
 struct loadparm_context;
-struct smb_iconv_convenience;
 
 #include <talloc.h>
@@ -71 +70 @@
          */
         WERROR (*add_key) (TALLOC_CTX *ctx,
-                           const struct hive_key *parent_key, const char *name,
+                           const struct hive_key *parent_key, const char *path,
                            const char *classname,
                            struct security_descriptor *desc,
@@ -78 +77 @@
          * Remove an existing key.
          */
-        WERROR (*del_key) (const struct hive_key *key, const char *name);
+        WERROR (*del_key) (TALLOC_CTX *mem_ctx,
+                           const struct hive_key *key, const char *name);
 
         /**
@@ -89 +89 @@
          */
         WERROR (*enum_value) (TALLOC_CTX *mem_ctx,
-                              struct hive_key *key, int idx,
+                              struct hive_key *key, uint32_t idx,
                               const char **name, uint32_t *type,
                               DATA_BLOB *data);
@@ -109 +109 @@
          * Remove a value.
          */
-        WERROR (*delete_value) (struct hive_key *key, const char *name);
+        WERROR (*delete_value) (TALLOC_CTX *mem_ctx,
+                                struct hive_key *key, const char *name);
 
         /* Security Descriptors */
@@ -167 +168 @@
                          struct security_descriptor *desc,
                          struct hive_key **key);
-WERROR hive_key_del(const struct hive_key *key, const char *name);
+WERROR hive_key_del(TALLOC_CTX *mem_ctx,
+                    const struct hive_key *key, const char *name);
 WERROR hive_get_key_by_name(TALLOC_CTX *mem_ctx,
                             const struct hive_key *key, const char *name,
@@ -194 +196 @@
                          const struct security_descriptor *security);
 
-WERROR hive_key_del_value(struct hive_key *key, const char *name);
+WERROR hive_key_del_value(TALLOC_CTX *mem_ctx,
+                          struct hive_key *key, const char *name);
 
 WERROR hive_key_flush(struct hive_key *key);
@@ -203 +206 @@
                           const char *location, struct hive_key **key);
 WERROR reg_open_regf_file(TALLOC_CTX *parent_ctx,
-                          const char *location, struct smb_iconv_convenience *iconv_convenience,
-                          struct hive_key **key);
+                          const char *location, struct hive_key **key);
 WERROR reg_open_ldb_file(TALLOC_CTX *parent_ctx, const char *location,
                          struct auth_session_info *session_info,
@@ -216 +218 @@
                             const char *location, struct hive_key **key);
 WERROR reg_create_regf_file(TALLOC_CTX *parent_ctx,
-                            struct smb_iconv_convenience *iconv_convenience,
                             const char *location,
                             int major_version,
@@ -305 +306 @@
                               struct registry_key **key);
 
-        WERROR (*delete_key) (struct registry_key *key, const char *name);
-
-        WERROR (*delete_value) (struct registry_key *key, const char *name);
+        WERROR (*delete_key) (TALLOC_CTX *mem_ctx,
+                              struct registry_key *key, const char *name);
+
+        WERROR (*delete_value) (TALLOC_CTX *mem_ctx,
+                                struct registry_key *key, const char *name);
 
         WERROR (*enum_key) (TALLOC_CTX *mem_ctx,
@@ -412 +415 @@
 WERROR reg_key_get_subkey_by_index(TALLOC_CTX *mem_ctx,
                                    const struct registry_key *key,
-                                   int idx,
+                                   uint32_t idx,
                                    const char **name,
                                    const char **classname,
@@ -425 +428 @@
                                  uint32_t *type,
                                  DATA_BLOB *data);
-WERROR reg_key_del(struct registry_key *parent, const char *name);
+WERROR reg_key_del(TALLOC_CTX *mem_ctx,
+                   struct registry_key *parent, const char *name);
 WERROR reg_key_add_name(TALLOC_CTX *mem_ctx,
                         struct registry_key *parent, const char *name,
@@ -435 +439 @@
 WERROR reg_get_sec_desc(TALLOC_CTX *ctx, const struct registry_key *key,
                         struct security_descriptor **secdesc);
-WERROR reg_del_value(struct registry_key *key, const char *valname);
+WERROR reg_del_value(TALLOC_CTX *mem_ctx,
+                     struct registry_key *key, const char *valname);
 WERROR reg_key_flush(struct registry_key *key);
 WERROR reg_create_key(TALLOC_CTX *mem_ctx,
@@ -446 +451 @@
 /* Utility functions */
 const char *str_regtype(int type);
-char *reg_val_data_string(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, uint32_t type, const DATA_BLOB data);
-char *reg_val_description(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, const char *name,
+bool push_reg_sz(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, const char *s);
+bool push_reg_multi_sz(TALLOC_CTX *mem_ctx, DATA_BLOB *blob, const char **a);
+bool pull_reg_sz(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob, const char **s);
+bool pull_reg_multi_sz(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob, const char ***a);
+int regtype_by_string(const char *str);
+char *reg_val_data_string(TALLOC_CTX *mem_ctx, uint32_t type, const DATA_BLOB data);
+char *reg_val_description(TALLOC_CTX *mem_ctx, const char *name,
                           uint32_t type, const DATA_BLOB data);
-bool reg_string_to_val(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, const char *type_str,
+bool reg_string_to_val(TALLOC_CTX *mem_ctx, const char *type_str,
                        const char *data_str, uint32_t *type, DATA_BLOB *data);
 WERROR reg_open_key_abs(TALLOC_CTX *mem_ctx, struct registry_context *handle,
@@ -486 +496 @@
 
 WERROR reg_diff_apply(struct registry_context *ctx, 
-                                          struct smb_iconv_convenience *ic, const char *filename);
+                                          const char *filename);
 
 WERROR reg_generate_diff(struct registry_context *ctx1,
@@ -493 +503 @@
                          void *callback_data);
 WERROR reg_dotreg_diff_save(TALLOC_CTX *ctx, const char *filename,
-                            struct smb_iconv_convenience *iconv_convenience,
                             struct reg_diff_callbacks **callbacks,
                             void **callback_data);
 WERROR reg_preg_diff_save(TALLOC_CTX *ctx, const char *filename,
-                          struct smb_iconv_convenience *ic,
                           struct reg_diff_callbacks **callbacks,
                           void **callback_data);
@@ -506 +514 @@
                              void *callback_data);
 WERROR reg_diff_load(const char *filename,
-                     struct smb_iconv_convenience *iconv_convenience,
                      const struct reg_diff_callbacks *callbacks,
                      void *callback_data);
 
 WERROR reg_dotreg_diff_load(int fd,
-                                     struct smb_iconv_convenience *iconv_convenience,
                                      const struct reg_diff_callbacks *callbacks,
                                      void *callback_data);
 
 WERROR reg_preg_diff_load(int fd,
-                   struct smb_iconv_convenience *iconv_convenience, 
                                    const struct reg_diff_callbacks *callbacks,
                                    void *callback_data);

vendor/current/source4/lib/registry/registry.pc.in

@@ -8 +8 @@
 Requires: talloc
 Requires.private: ldb
-Version: 0.0.1
-Libs: -L${libdir} -lregistry 
+Version: @PACKAGE_VERSION@
+Libs: @LIB_RPATH@ -L${libdir} -lregistry
 Cflags: -I${includedir}  -DHAVE_IMMEDIATE_STRUCTURES=1

vendor/current/source4/lib/registry/rpc.c

@@ -28 +28 @@
         struct registry_key key;
         struct policy_handle pol;
-        struct dcerpc_pipe *pipe;
-
+        struct dcerpc_binding_handle *binding_handle;
         const char* classname;  
         uint32_t num_subkeys;
@@ -44 +43 @@
         struct registry_context context;
         struct dcerpc_pipe *pipe;
+        struct dcerpc_binding_handle *binding_handle;
 };
 
@@ -52 +52 @@
  */
 
-#define openhive(u) static WERROR open_ ## u(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct policy_handle *hnd) \
+#define openhive(u) static WERROR open_ ## u(struct dcerpc_binding_handle *b, TALLOC_CTX *mem_ctx, struct policy_handle *hnd) \
 { \
         struct winreg_Open ## u r; \
@@ -62 +62 @@
         r.out.handle = hnd;\
 \
-        status = dcerpc_winreg_Open ## u(p, mem_ctx, &r); \
+        status = dcerpc_winreg_Open ## u ## _r(b, mem_ctx, &r); \
 \
         if (!NT_STATUS_IS_OK(status)) { \
@@ -82 +82 @@
 static struct {
         uint32_t hkey;
-        WERROR (*open) (struct dcerpc_pipe *p, TALLOC_CTX *,
+        WERROR (*open) (struct dcerpc_binding_handle *b, TALLOC_CTX *,
                         struct policy_handle *h);
 } known_hives[] = {
@@ -118 +118 @@
 
         mykeydata = talloc_zero(ctx, struct rpc_key);
+        W_ERROR_HAVE_NO_MEMORY(mykeydata);
         mykeydata->key.context = ctx;
-        mykeydata->pipe = talloc_reference(mykeydata, rctx->pipe);
+        mykeydata->binding_handle = rctx->binding_handle;
         mykeydata->num_values = -1;
         mykeydata->num_subkeys = -1;
         *k = (struct registry_key *)mykeydata;
-        return known_hives[n].open(mykeydata->pipe, mykeydata, &(mykeydata->pol));
+        return known_hives[n].open(mykeydata->binding_handle, mykeydata, &mykeydata->pol);
 }
 
@@ -161 +162 @@
 
         mykeydata = talloc_zero(mem_ctx, struct rpc_key);
+        W_ERROR_HAVE_NO_MEMORY(mykeydata);
         mykeydata->key.context = parentkeydata->key.context;
-        mykeydata->pipe = talloc_reference(mykeydata, parentkeydata->pipe);
+        mykeydata->binding_handle = parentkeydata->binding_handle;
         mykeydata->num_values = -1;
         mykeydata->num_subkeys = -1;
@@ -171 +173 @@
         r.in.parent_handle = &parentkeydata->pol;
         r.in.keyname.name = name;
-        r.in.unknown = 0x00000000;
+        r.in.options = 0x00000000;
         r.in.access_mask = 0x02000000;
         r.out.handle = &mykeydata->pol;
 
-        status = dcerpc_winreg_OpenKey(mykeydata->pipe, mem_ctx, &r);
+        status = dcerpc_winreg_OpenKey_r(mykeydata->binding_handle, mem_ctx, &r);
 
         if (!NT_STATUS_IS_OK(status)) {
@@ -213 +215 @@
         r.in.enum_index = n;
         r.in.name = &name;
-        r.in.type = type;
+        r.in.type = (enum winreg_Type *) type;
         r.in.value = &value;
         r.in.size = &val_size;
         r.in.length = &zero;
         r.out.name = &name;
-        r.out.type = type;
+        r.out.type = (enum winreg_Type *) type;
         r.out.value = &value;
         r.out.size = &val_size;
         r.out.length = &zero;
 
-        status = dcerpc_winreg_EnumValue(mykeydata->pipe, mem_ctx, &r);
+        status = dcerpc_winreg_EnumValue_r(mykeydata->binding_handle, mem_ctx, &r);
 
         if (!NT_STATUS_IS_OK(status)) {
@@ -230 +232 @@
         }
 
-        *value_name = talloc_reference(mem_ctx, r.out.name->name);
+        *value_name = talloc_steal(mem_ctx, r.out.name->name);
         *type = *(r.out.type);
         *data = data_blob_talloc(mem_ctx, r.out.value, *r.out.length);
@@ -262 +264 @@
         r.in.handle = &mykeydata->pol;
         r.in.value_name = &name;
-        r.in.type = type;
+        r.in.type = (enum winreg_Type *) type;
         r.in.data = &value;
         r.in.data_size = &val_size;
         r.in.data_length = &zero;
-        r.out.type = type;
+        r.out.type = (enum winreg_Type *) type;
         r.out.data = &value;
         r.out.data_size = &val_size;
         r.out.data_length = &zero;
 
-        status = dcerpc_winreg_QueryValue(mykeydata->pipe, mem_ctx, &r);
+        status = dcerpc_winreg_QueryValue_r(mykeydata->binding_handle, mem_ctx, &r);
 
         if (!NT_STATUS_IS_OK(status)) {
@@ -312 +314 @@
         r.out.last_changed_time = &change_time;
 
-        status = dcerpc_winreg_EnumKey(mykeydata->pipe, mem_ctx, &r);
+        status = dcerpc_winreg_EnumKey_r(mykeydata->binding_handle, mem_ctx, &r);
 
         if (!NT_STATUS_IS_OK(status)) {
@@ -320 +322 @@
 
         if (name != NULL)
-                *name = talloc_reference(mem_ctx, r.out.name->name);
+                *name = talloc_steal(mem_ctx, r.out.name->name);
         if (keyclass != NULL)
-                *keyclass = talloc_reference(mem_ctx, r.out.keyclass->name);
+                *keyclass = talloc_steal(mem_ctx, r.out.keyclass->name);
         if (last_changed_time != NULL)
                 *last_changed_time = *(r.out.last_changed_time);
@@ -330 +332 @@
 
 static WERROR rpc_add_key(TALLOC_CTX *mem_ctx,
-                          struct registry_key *parent, const char *name,
+                          struct registry_key *parent, const char *path,
                           const char *key_class,
                           struct security_descriptor *sec,
@@ -343 +345 @@
         ZERO_STRUCT(r);
         r.in.handle = &parentkd->pol;
-        r.in.name.name = name;
+        r.in.name.name = path;
         r.in.keyclass.name = NULL;
         r.in.options = 0;
@@ -352 +354 @@
         r.out.action_taken = NULL;
 
-        status = dcerpc_winreg_CreateKey(parentkd->pipe, mem_ctx, &r);
+        status = dcerpc_winreg_CreateKey_r(parentkd->binding_handle, mem_ctx, &r);
 
         if (!NT_STATUS_IS_OK(status)) {
@@ -360 +362 @@
         }
 
-        rpck->pipe = talloc_reference(rpck, parentkd->pipe);
+        rpck->binding_handle = parentkd->binding_handle;
         *key = (struct registry_key *)rpck;
 
@@ -388 +390 @@
         r.out.last_changed_time = &mykeydata->last_changed_time;
 
-        status = dcerpc_winreg_QueryInfoKey(mykeydata->pipe, mem_ctx, &r);
+        status = dcerpc_winreg_QueryInfoKey_r(mykeydata->binding_handle, mem_ctx, &r);
 
         if (!NT_STATUS_IS_OK(status)) {
@@ -395 +397 @@
         }
 
-        mykeydata->classname = talloc_reference(mem_ctx, r.out.classname->name);
-
-        return r.out.result;
-}
-
-static WERROR rpc_del_key(struct registry_key *parent, const char *name)
+        mykeydata->classname = talloc_steal(mem_ctx, r.out.classname->name);
+
+        return r.out.result;
+}
+
+static WERROR rpc_del_key(TALLOC_CTX *mem_ctx, struct registry_key *parent,
+                          const char *name)
 {
         NTSTATUS status;
         struct rpc_key *mykeydata = talloc_get_type(parent, struct rpc_key);
         struct winreg_DeleteKey r;
-        TALLOC_CTX *mem_ctx = talloc_init("del_key");
 
         ZERO_STRUCT(r);
@@ -411 +413 @@
         r.in.key.name = name;
 
-        status = dcerpc_winreg_DeleteKey(mykeydata->pipe, mem_ctx, &r);
-
-        talloc_free(mem_ctx);
+        status = dcerpc_winreg_DeleteKey_r(mykeydata->binding_handle, mem_ctx, &r);
 
         if (!NT_STATUS_IS_OK(status)) {
@@ -474 +474 @@
         .delete_key = rpc_del_key,
         .get_key_info = rpc_get_info,
-        .get_predefined_key = rpc_get_predefined_key,
 };
 
@@ -490 +489 @@
 
         rctx = talloc(NULL, struct rpc_registry_context);
+        W_ERROR_HAVE_NO_MEMORY(rctx);
 
         /* Default to local smbd if no connection is specified */
@@ -498 +498 @@
         status = dcerpc_pipe_connect(rctx /* TALLOC_CTX */,
                                      &p, location,
-                                         &ndr_table_winreg,
+                                     &ndr_table_winreg,
                                      credentials, ev, lp_ctx);
-        rctx->pipe = p;
-
         if(NT_STATUS_IS_ERR(status)) {
                 DEBUG(1, ("Unable to open '%s': %s\n", location,
@@ -510 +508 @@
         }
 
+        rctx->pipe = p;
+        rctx->binding_handle = p->binding_handle;
+
         *ctx = (struct registry_context *)rctx;
         (*ctx)->ops = &reg_backend_rpc;

vendor/current/source4/lib/registry/samba.c

@@ -39 +39 @@
 
         location = talloc_asprintf(ctx, "%s/%s.ldb",
-                                   lp_private_dir(lp_ctx),
+                                   lpcfg_private_dir(lp_ctx),
                                    name);
+        W_ERROR_HAVE_NO_MEMORY(location);
 
         error = reg_open_hive(ctx, location, auth_info, creds, event_ctx, lp_ctx, &hive);
@@ -47 +48 @@
                 error = reg_open_ldb_file(ctx, location, auth_info,
                                           creds, event_ctx, lp_ctx, &hive);
+
+        talloc_free(discard_const_p(char, location));
 
         if (!W_ERROR_IS_OK(error))

vendor/current/source4/lib/registry/tests/diff.c

@@ -53 +53 @@
 {
         struct diff_tcase_data *td = tcase_data;
-        struct smb_iconv_convenience *ic;
         struct reg_diff_callbacks *callbacks;
         void *data;
         WERROR error;
 
-        ic = lp_iconv_convenience(tctx->lp_ctx);
-
-        error = reg_diff_load(td->filename, iconv_convenience, callbacks, data);
+        error = reg_diff_load(td->filename, callbacks, data);
         torture_assert_werr_ok(tctx, error, "reg_diff_load");
 
@@ -72 +69 @@
         WERROR error;
 
-        error = reg_diff_apply(td->r1_ctx, lp_iconv_convenience(tctx->lp_ctx), td->filename);
+        error = reg_diff_apply(td->r1_ctx, td->filename);
         torture_assert_werr_ok(tctx, error, "reg_diff_apply");
 
@@ -228 +225 @@
         torture_assert_werr_ok(tctx, error, "Creating HKLM\\..\\Policies\\Explorer failed");
 
-
-        blob.data = (void *)talloc(r2_ctx, uint32_t);
-        SIVAL(blob.data, 0, 0x03ffffff);
-        blob.length = sizeof(uint32_t);
+        blob.data = talloc_array(r2_ctx, uint8_t, 4);
+        /* set "0x03FFFFFF" in little endian format */
+        blob.data[0] = 0xFF; blob.data[1] = 0xFF;
+        blob.data[2] = 0xFF; blob.data[3] = 0x03;
+        blob.length = 4;
 
         r1_ctx->ops->set_value(newkey, "NoDrives", REG_DWORD, blob);
@@ -247 +245 @@
 {
         struct diff_tcase_data *td;
-        struct smb_iconv_convenience *ic;
         WERROR error;
 
@@ -253 +250 @@
         td = *data;
 
-        ic = lp_iconv_convenience(tctx->lp_ctx);
-
         td->filename = talloc_asprintf(tctx, "%s/test.pol", td->tempdir);
-        error = reg_preg_diff_save(tctx, td->filename, ic, &td->callbacks, &td->callback_data);
+        error = reg_preg_diff_save(tctx, td->filename,  &td->callbacks,
+                                                           &td->callback_data);
         torture_assert_werr_ok(tctx, error, "reg_preg_diff_save");
 
@@ -265 +261 @@
 {
         struct diff_tcase_data *td;
-        struct smb_iconv_convenience *ic;
         WERROR error;
 
@@ -271 +266 @@
         td = *data;
 
-        ic = lp_iconv_convenience(tctx->lp_ctx);
-        
         td->filename = talloc_asprintf(tctx, "%s/test.reg", td->tempdir);
-        error = reg_dotreg_diff_save(tctx, td->filename, ic, &td->callbacks, &td->callback_data);
+        error = reg_dotreg_diff_save(tctx, td->filename, &td->callbacks,
+                                                                 &td->callback_data);
         torture_assert_werr_ok(tctx, error, "reg_dotreg_diff_save");
 
@@ -283 +277 @@
 {
         struct torture_tcase *tcase;
-        struct torture_suite *suite = torture_suite_create(mem_ctx, "DIFF");
+        struct torture_suite *suite = torture_suite_create(mem_ctx, "diff");
 
         tcase = torture_suite_add_tcase(suite, "PReg");

vendor/current/source4/lib/registry/tests/generic.c

@@ -32 +32 @@
 static bool test_str_regtype(struct torture_context *ctx)
 {
+        torture_assert_str_equal(ctx, str_regtype(0),
+                                 "REG_NONE", "REG_NONE failed");
         torture_assert_str_equal(ctx, str_regtype(1),
                                  "REG_SZ", "REG_SZ failed");
+        torture_assert_str_equal(ctx, str_regtype(2),
+                                 "REG_EXPAND_SZ", "REG_EXPAND_SZ failed");
+        torture_assert_str_equal(ctx, str_regtype(3),
+                                 "REG_BINARY", "REG_BINARY failed");
         torture_assert_str_equal(ctx, str_regtype(4),
                                  "REG_DWORD", "REG_DWORD failed");
+        torture_assert_str_equal(ctx, str_regtype(5),
+                                 "REG_DWORD_BIG_ENDIAN", "REG_DWORD_BIG_ENDIAN failed");
+        torture_assert_str_equal(ctx, str_regtype(6),
+                                 "REG_LINK", "REG_LINK failed");
+        torture_assert_str_equal(ctx, str_regtype(7),
+                                 "REG_MULTI_SZ", "REG_MULTI_SZ failed");
+        torture_assert_str_equal(ctx, str_regtype(8),
+                                 "REG_RESOURCE_LIST", "REG_RESOURCE_LIST failed");
+        torture_assert_str_equal(ctx, str_regtype(9),
+                                 "REG_FULL_RESOURCE_DESCRIPTOR", "REG_FULL_RESOURCE_DESCRIPTOR failed");
+        torture_assert_str_equal(ctx, str_regtype(10),
+                                 "REG_RESOURCE_REQUIREMENTS_LIST", "REG_RESOURCE_REQUIREMENTS_LIST failed");
+        torture_assert_str_equal(ctx, str_regtype(11),
+                                 "REG_QWORD", "REG_QWORD failed");
 
         return true;
@@ -43 +63 @@
 static bool test_reg_val_data_string_dword(struct torture_context *ctx)
 {
-        uint32_t d = 0x20;
-        DATA_BLOB db = { (uint8_t *)&d, sizeof(d) };
-        torture_assert_str_equal(ctx, "0x20",
-                                 reg_val_data_string(ctx, lp_iconv_convenience(ctx->lp_ctx), REG_DWORD, db),
+        uint8_t d[] = { 0x20, 0x00, 0x00, 0x00 };
+        DATA_BLOB db = { d, 4 };
+        torture_assert_str_equal(ctx, "0x00000020",
+                                 reg_val_data_string(ctx, REG_DWORD, db),
                                  "dword failed");
+        return true;
+}
+
+static bool test_reg_val_data_string_dword_big_endian(struct torture_context *ctx)
+{
+        uint8_t d[] = { 0x20, 0x00, 0x00, 0x00 };
+        DATA_BLOB db = { d, 4 };
+        torture_assert_str_equal(ctx, "0x00000020",
+                                 reg_val_data_string(ctx, REG_DWORD_BIG_ENDIAN, db),
+                                 "dword failed");
+        return true;
+}
+
+static bool test_reg_val_data_string_qword(struct torture_context *ctx)
+{
+        uint8_t d[] = { 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+        DATA_BLOB db = { d, 8 };
+        torture_assert_str_equal(ctx, "0x0000000000000020",
+                                 reg_val_data_string(ctx, REG_QWORD, db),
+                                 "qword failed");
         return true;
 }
@@ -54 +94 @@
 {
         DATA_BLOB db;
-        convert_string_talloc_convenience(ctx, lp_iconv_convenience(ctx->lp_ctx), CH_UTF8, CH_UTF16,
+        convert_string_talloc(ctx, CH_UTF8, CH_UTF16,
                                           "bla", 3, (void **)&db.data, &db.length, false);
         torture_assert_str_equal(ctx, "bla",
-                                 reg_val_data_string(ctx, lp_iconv_convenience(ctx->lp_ctx), REG_SZ, db),
+                                 reg_val_data_string(ctx, REG_SZ, db),
                                  "sz failed");
         db.length = 4;
         torture_assert_str_equal(ctx, "bl",
-                                 reg_val_data_string(ctx, lp_iconv_convenience(ctx->lp_ctx), REG_SZ, db),
+                                 reg_val_data_string(ctx, REG_SZ, db),
                                  "sz failed");
         return true;
@@ -71 +111 @@
         DATA_BLOB db = { x, 4 };
         torture_assert_str_equal(ctx, "01020304",
-                                 reg_val_data_string(ctx, lp_iconv_convenience(ctx->lp_ctx), REG_BINARY, db),
+                                 reg_val_data_string(ctx, REG_BINARY, db),
                                  "binary failed");
         return true;
@@ -81 +121 @@
         DATA_BLOB db = { NULL, 0 };
         torture_assert_str_equal(ctx, "",
-                                 reg_val_data_string(ctx, lp_iconv_convenience(ctx->lp_ctx), REG_BINARY, db),
+                                 reg_val_data_string(ctx, REG_BINARY, db),
                                  "empty failed");
         return true;
@@ -89 +129 @@
 {
         DATA_BLOB data;
-        convert_string_talloc_convenience(ctx, lp_iconv_convenience(ctx->lp_ctx), CH_UTF8, CH_UTF16,
+        convert_string_talloc(ctx, CH_UTF8, CH_UTF16,
                                             "stationary traveller",
                                             strlen("stationary traveller"),
                                             (void **)&data.data, &data.length, false);
         torture_assert_str_equal(ctx, "camel = REG_SZ : stationary traveller",
-                                 reg_val_description(ctx, lp_iconv_convenience(ctx->lp_ctx), "camel", REG_SZ, data),
+                                 reg_val_description(ctx, "camel", REG_SZ, data),
                                  "reg_val_description failed");
         return true;
@@ -103 +143 @@
 {
         DATA_BLOB data;
-        convert_string_talloc_convenience(ctx, lp_iconv_convenience(ctx->lp_ctx), CH_UTF8, CH_UTF16,
+        convert_string_talloc(ctx, CH_UTF8, CH_UTF16,
                                             "west berlin",
                                             strlen("west berlin"),
                                             (void **)&data.data, &data.length, false);
         torture_assert_str_equal(ctx, "<No Name> = REG_SZ : west berlin",
-                                 reg_val_description(ctx, lp_iconv_convenience(ctx->lp_ctx), NULL, REG_SZ, data),
+                                 reg_val_description(ctx, NULL, REG_SZ, data),
                                  "description with null name failed");
         return true;
@@ -115 +155 @@
 struct torture_suite *torture_registry(TALLOC_CTX *mem_ctx)
 {
-        struct torture_suite *suite = torture_suite_create(mem_ctx, "REGISTRY");
+        struct torture_suite *suite = torture_suite_create(mem_ctx, "registry");
         torture_suite_add_simple_test(suite, "str_regtype",
                                       test_str_regtype);
         torture_suite_add_simple_test(suite, "reg_val_data_string dword",
                                       test_reg_val_data_string_dword);
+        torture_suite_add_simple_test(suite, "reg_val_data_string dword_big_endian",
+                                      test_reg_val_data_string_dword_big_endian);
+        torture_suite_add_simple_test(suite, "reg_val_data_string qword",
+                                      test_reg_val_data_string_qword);
         torture_suite_add_simple_test(suite, "reg_val_data_string sz",
                                       test_reg_val_data_string_sz);

vendor/current/source4/lib/registry/tests/hive.c

@@ -33 +33 @@
 {
         const struct hive_key *root = (const struct hive_key *)test_data;
-        WERROR error = hive_key_del(root, "bla");
+        WERROR error = hive_key_del(tctx, root, "bla");
         torture_assert_werr_equal(tctx, error, WERR_BADFILE,
                                   "invalid return code");
@@ -70 +70 @@
         WERROR error;
         struct hive_key *subkey;
-        char data[4];
-        SIVAL(data, 0, 42);
+        uint8_t d[] = { 0x42, 0x00, 0x00, 0x00 };
+        DATA_BLOB db = { d, 4 };
 
         error = hive_key_add_name(tctx, root, "Nested Keyll", NULL,
@@ -77 +77 @@
         torture_assert_werr_ok(tctx, error, "hive_key_add_name");
 
-        error = hive_key_set_value(root, "Answer", REG_DWORD,
-                               data_blob_talloc(tctx, data, sizeof(data)));
+        error = hive_key_set_value(root, "Answer", REG_DWORD, db);
         torture_assert_werr_ok(tctx, error, "hive_key_set_value");
 
@@ -108 +107 @@
         torture_assert_werr_ok(tctx, error, "hive_key_add_name");
 
-        error = hive_key_del(root, "Nested Key");
+        error = hive_key_del(mem_ctx, root, "Nested Key");
         torture_assert_werr_ok(tctx, error, "reg_key_del");
 
@@ -122 +121 @@
         const struct hive_key *root = (const struct hive_key *)test_data;
         TALLOC_CTX *mem_ctx = tctx;
-        char data[4];
-        SIVAL(data, 0, 42);
+        uint8_t d[] = { 0x42, 0x00, 0x00, 0x00 };
+        DATA_BLOB db = { d, 4 };
 
         /* Create a new key under the root */
@@ -136 +135 @@
 
         /* Create a new value under "Child Key" */
-        error = hive_key_set_value(subkey2, "Answer Recursive", REG_DWORD,
-                               data_blob_talloc(mem_ctx, data, sizeof(data)));
+        error = hive_key_set_value(subkey2, "Answer Recursive", REG_DWORD, db);
         torture_assert_werr_ok(tctx, error, "hive_key_set_value");
 
         /* Deleting "Parent Key" will also delete "Child Key" and the value. */
-        error = hive_key_del(root, "Parent Key");
+        error = hive_key_del(mem_ctx, root, "Parent Key");
         torture_assert_werr_ok(tctx, error, "hive_key_del");
 
@@ -167 +165 @@
         torture_assert_werr_ok(tctx, error, "hive_key_add_name");
 
-        error = hive_key_del(root, "Nested Key");
+        error = hive_key_del(mem_ctx, root, "Nested Key");
         torture_assert_werr_ok(tctx, error, "reg_key_del");
 
-        error = hive_key_del(root, "Nested Key");
+        error = hive_key_del(mem_ctx, root, "Nested Key");
         torture_assert_werr_equal(tctx, error, WERR_BADFILE, "reg_key_del");
 
@@ -183 +181 @@
         const struct hive_key *root = (const struct hive_key *)test_data;
         TALLOC_CTX *mem_ctx = tctx;
-        char data[4];
-        SIVAL(data, 0, 42);
+        uint8_t d[] = { 0x42, 0x00, 0x00, 0x00 };
+        DATA_BLOB db = { d, 4 };
 
         error = hive_key_add_name(mem_ctx, root, "YA Nested Key", NULL,
@@ -190 +188 @@
         torture_assert_werr_ok(tctx, error, "hive_key_add_name");
 
-        error = hive_key_set_value(subkey, "Answer", REG_DWORD,
-                               data_blob_talloc(mem_ctx, data, sizeof(data)));
+        error = hive_key_set_value(subkey, "Answer", REG_DWORD, db);
         torture_assert_werr_ok(tctx, error, "hive_key_set_value");
 
@@ -203 +200 @@
         const struct hive_key *root = (const struct hive_key *)test_data;
         TALLOC_CTX *mem_ctx = tctx;
-        char data[4];
         uint32_t type;
-        DATA_BLOB value;
-
-        SIVAL(data, 0, 42);
+        uint8_t d[] = { 0x42, 0x00, 0x00, 0x00 };
+        DATA_BLOB db = { d, 4 }, data;
 
         error = hive_key_add_name(mem_ctx, root, "EYA Nested Key", NULL,
@@ -213 +208 @@
         torture_assert_werr_ok(tctx, error, "hive_key_add_name");
 
-        error = hive_get_value(mem_ctx, subkey, "Answer", &type, &value);
+        error = hive_get_value(mem_ctx, subkey, "Answer", &type, &data);
         torture_assert_werr_equal(tctx, error, WERR_BADFILE,
                                   "getting missing value");
 
-        error = hive_key_set_value(subkey, "Answer", REG_DWORD,
-                               data_blob_talloc(mem_ctx, data, sizeof(data)));
-        torture_assert_werr_ok(tctx, error, "hive_key_set_value");
-
-        error = hive_get_value(mem_ctx, subkey, "Answer", &type, &value);
+        error = hive_key_set_value(subkey, "Answer", REG_DWORD, db);
+        torture_assert_werr_ok(tctx, error, "hive_key_set_value");
+
+        error = hive_get_value(mem_ctx, subkey, "Answer", &type, &data);
         torture_assert_werr_ok(tctx, error, "getting value");
 
-        torture_assert_int_equal(tctx, value.length, 4, "value length");
+        torture_assert_int_equal(tctx, data.length, 4, "value length");
         torture_assert_int_equal(tctx, type, REG_DWORD, "value type");
 
-        torture_assert_mem_equal(tctx, &data, value.data, sizeof(uint32_t),
-                                 "value data");
+        torture_assert_mem_equal(tctx, data.data, db.data, 4, "value data");
 
         return true;
@@ -239 +232 @@
         const struct hive_key *root = (const struct hive_key *)test_data;
         TALLOC_CTX *mem_ctx = tctx;
-        char data[4];
         uint32_t type;
-        DATA_BLOB value;
-
-        SIVAL(data, 0, 42);
+        uint8_t d[] = { 0x42, 0x00, 0x00, 0x00 };
+        DATA_BLOB db = { d, 4 };
 
         error = hive_key_add_name(mem_ctx, root, "EEYA Nested Key", NULL,
@@ -249 +240 @@
         torture_assert_werr_ok(tctx, error, "hive_key_add_name");
 
-        error = hive_key_set_value(subkey, "Answer", REG_DWORD,
-                               data_blob_talloc(mem_ctx, data, sizeof(data)));
-        torture_assert_werr_ok(tctx, error, "hive_key_set_value");
-
-        error = hive_key_del_value(subkey, "Answer");
+        error = hive_key_set_value(subkey, "Answer", REG_DWORD, db);
+        torture_assert_werr_ok(tctx, error, "hive_key_set_value");
+
+        error = hive_key_del_value(mem_ctx, subkey, "Answer");
         torture_assert_werr_ok(tctx, error, "deleting value");
 
-        error = hive_get_value(mem_ctx, subkey, "Answer", &type, &value);
+        error = hive_get_value(mem_ctx, subkey, "Answer", &type, &db);
         torture_assert_werr_equal(tctx, error, WERR_BADFILE, "getting value");
 
-        error = hive_key_del_value(subkey, "Answer");
+        error = hive_key_del_value(mem_ctx, subkey, "Answer");
         torture_assert_werr_equal(tctx, error, WERR_BADFILE,
                                   "deleting value");
@@ -273 +263 @@
         const struct hive_key *root = (const struct hive_key *)test_data;
         TALLOC_CTX *mem_ctx = tctx;
-        char data[4];
         uint32_t type;
-        DATA_BLOB value;
+        uint8_t d[] = { 0x42, 0x00, 0x00, 0x00 };
+        DATA_BLOB db = { d, 4 }, data;
         const char *name;
-        int data_val = 42;
-        SIVAL(data, 0, data_val);
 
         error = hive_key_add_name(mem_ctx, root, "AYAYA Nested Key", NULL,
@@ -284 +272 @@
         torture_assert_werr_ok(tctx, error, "hive_key_add_name");
 
-        error = hive_key_set_value(subkey, "Answer", REG_DWORD,
-                               data_blob_talloc(mem_ctx, data, sizeof(data)));
+        error = hive_key_set_value(subkey, "Answer", REG_DWORD, db);
         torture_assert_werr_ok(tctx, error, "hive_key_set_value");
 
         error = hive_get_value_by_index(mem_ctx, subkey, 0, &name,
-                                        &type, &value);
+                                        &type, &data);
         torture_assert_werr_ok(tctx, error, "getting value");
 
         torture_assert_str_equal(tctx, name, "Answer", "value name");
 
-        torture_assert_int_equal(tctx, value.length, 4, "value length");
+        torture_assert_int_equal(tctx, data.length, 4, "value length");
         torture_assert_int_equal(tctx, type, REG_DWORD, "value type");
         
+        torture_assert_mem_equal(tctx, data.data, db.data, 4, "value data");
         
-        torture_assert_int_equal(tctx, data_val, IVAL(value.data, 0), "value data");
-
         error = hive_get_value_by_index(mem_ctx, subkey, 1, &name,
-                                        &type, &value);
+                                        &type, &data);
         torture_assert_werr_equal(tctx, error, WERR_NO_MORE_ITEMS,
                                   "getting missing value");
@@ -450 +436 @@
         rmdir(dirname);
 
-        error = reg_create_regf_file(tctx, lp_iconv_convenience(tctx->lp_ctx),
-                                     dirname, 5, &key);
+        error = reg_create_regf_file(tctx, dirname, 5, &key);
         if (!W_ERROR_IS_OK(error)) {
                 fprintf(stderr, "Unable to create new regf file\n");
@@ -473 +458 @@
 {
         struct torture_tcase *tcase;
-        struct torture_suite *suite = torture_suite_create(mem_ctx, "HIVE");
+        struct torture_suite *suite = torture_suite_create(mem_ctx, "hive");
 
         torture_suite_add_simple_test(suite, "dir-refuses-null-location",

vendor/current/source4/lib/registry/tests/registry.c

@@ -118 +118 @@
 {
         struct registry_context *rctx = (struct registry_context *)_data;
-        struct registry_key *root, *newkey1, *newkey2;
+        struct registry_key *root, *newkey;
         WERROR error;
 
@@ -125 +125 @@
                                "getting predefined key failed");
 
-        error = reg_key_add_name(rctx, root, "Hamburg", NULL, NULL,
-                                 &newkey1);
+        error = reg_key_add_name(rctx, root, "Hamburg\\Hamburg", NULL, NULL,
+                                 &newkey);
         torture_assert_werr_ok(tctx, error, "Creating key return code");
-        torture_assert(tctx, newkey1 != NULL, "Creating new key");
-
-        error = reg_key_add_name(rctx, root, "Hamburg\\Hamburg", NULL, NULL,
-                                 &newkey2);
-        torture_assert_werr_ok(tctx, error, "Creating key return code");
-        torture_assert(tctx, newkey2 != NULL, "Creating new key");
+        torture_assert(tctx, newkey != NULL, "Creating new key");
 
         return true;
@@ -201 +196 @@
         torture_assert(tctx, newkey != NULL, "Creating new key");
 
-        error = reg_key_del(root, "Polen");
+        error = reg_key_del(tctx, root, "Polen");
         torture_assert_werr_ok(tctx, error, "Delete key");
 
-        error = reg_key_del(root, "Polen");
+        error = reg_key_del(tctx, root, "Polen");
         torture_assert_werr_equal(tctx, error, WERR_BADFILE,
                                   "Delete missing key");
@@ -465 +460 @@
         torture_assert_werr_ok (tctx, error, "setting value");
 
-        error = reg_del_value(subkey, __FUNCTION__);
+        error = reg_del_value(tctx, subkey, __FUNCTION__);
         torture_assert_werr_ok (tctx, error, "unsetting value");
 
@@ -585 +580 @@
 {
         struct torture_tcase *tcase;
-        struct torture_suite *suite = torture_suite_create(mem_ctx, "REGISTRY");
+        struct torture_suite *suite = torture_suite_create(mem_ctx, "registry");
 
         tcase = torture_suite_add_tcase(suite, "local");

vendor/current/source4/lib/registry/tools/regdiff.c

@@ -131 +131 @@
         poptFreeContext(pc);
 
-        error = reg_dotreg_diff_save(ctx, outputfile, lp_iconv_convenience(cmdline_lp_ctx), &callbacks,
-                                     &callback_data);
+        error = reg_dotreg_diff_save(ctx, outputfile, &callbacks, &callback_data);
         if (!W_ERROR_IS_OK(error)) {
                 fprintf(stderr, "Problem saving registry diff to '%s': %s\n",

vendor/current/source4/lib/registry/tools/regpatch.c

@@ -69 +69 @@
         poptFreeContext(pc);
 
-        reg_diff_apply(h, lp_iconv_convenience(cmdline_lp_ctx), patch);
+        reg_diff_apply(h, patch);
 
         return 0;

vendor/current/source4/lib/registry/tools/regshell.c

@@ -25 +25 @@
 #include "lib/events/events.h"
 #include "system/time.h"
-#include "lib/smbreadline/smbreadline.h"
+#include "../libcli/smbreadline/smbreadline.h"
 #include "librpc/gen_ndr/ndr_security.h"
 #include "lib/registry/tools/common.h"
@@ -126 +126 @@
                 printf("Key Class: %s\n", classname);
         last_mod = nt_time_to_unix(last_change);
-        printf("Time Last Modified: %s\n", ctime(&last_mod));
+        printf("Time Last Modified: %s", ctime(&last_mod));
         printf("Number of subkeys: %d\n", num_subkeys);
         printf("Number of values: %d\n", num_values);
@@ -141 +141 @@
         error = reg_get_sec_desc(ctx, ctx->current, &sec_desc);
         if (!W_ERROR_IS_OK(error)) {
-                printf("Error getting security descriptor\n");
-                return error;
+                printf("Error getting security descriptor: %s\n", win_errstr(error));
+                return WERR_OK;
         }
         ndr_print_debug((ndr_print_fn_t)ndr_print_security_descriptor,
@@ -196 +196 @@
         }
 
-        if (!reg_string_to_val(ctx, lp_iconv_convenience(cmdline_lp_ctx), 
-                               argv[2], argv[3], &val.data_type,
-                               &val.data)) {
+        if (!reg_string_to_val(ctx, argv[2], argv[3], &val.data_type, &val.data)) {
                 fprintf(stderr, "Unable to interpret data\n");
                 return WERR_INVALID_PARAM;
@@ -260 +258 @@
 
         printf("%s\n%s\n", str_regtype(value_type),
-                   reg_val_data_string(ctx, lp_iconv_convenience(cmdline_lp_ctx), value_type, value_data));
+                   reg_val_data_string(ctx, value_type, value_data));
 
         return WERR_OK;
@@ -267 +265 @@
 static WERROR cmd_ls(struct regshell_context *ctx, int argc, char **argv)
 {
-        int i;
+        unsigned int i;
         WERROR error;
         uint32_t valuetype;
@@ -283 +281 @@
 
         if (!W_ERROR_EQUAL(error, WERR_NO_MORE_ITEMS)) {
-                fprintf(stderr, "Error occured while browsing thru keys: %s\n",
+                fprintf(stderr, "Error occurred while browsing through keys: %s\n",
                         win_errstr(error));
                 return error;
@@ -291 +289 @@
                 ctx->current, i, &name, &valuetype, &valuedata)); i++)
                 printf("V \"%s\" %s %s\n", name, str_regtype(valuetype),
-                           reg_val_data_string(ctx, lp_iconv_convenience(cmdline_lp_ctx), valuetype, valuedata));
+                           reg_val_data_string(ctx, valuetype, valuedata));
 
         return WERR_OK;
@@ -326 +324 @@
         }
 
-        error = reg_key_del(ctx->current, argv[1]);
+        error = reg_key_del(ctx, ctx->current, argv[1]);
         if(!W_ERROR_IS_OK(error)) {
                 fprintf(stderr, "Error deleting '%s'\n", argv[1]);
@@ -346 +344 @@
         }
 
-        error = reg_del_value(ctx->current, argv[1]);
+        error = reg_del_value(ctx, ctx->current, argv[1]);
         if(!W_ERROR_IS_OK(error)) {
                 fprintf(stderr, "Error deleting value '%s'\n", argv[1]);
@@ -389 +387 @@
                        int argc, char **argv)
 {
-        int i;
+        unsigned int i;
         printf("Available commands:\n");
         for(i = 0; regshell_cmds[i].name; i++) {
@@ -430 +428 @@
         /* Complete command */
         char **matches;
-        int i, len, samelen=0, count=1;
+        size_t len, samelen=0;
+        unsigned int i, count=1;
 
         matches = malloc_array_p(char *, MAX_COMPLETIONS);
@@ -478 +477 @@
         struct registry_key *base;
         const char *subkeyname;
-        int i, j = 1;
-        int samelen = 0;
-        int len;
+        unsigned int i, j = 1;
+        size_t len, samelen = 0;
         char **matches;
         const char *base_n = "";
@@ -594 +592 @@
 
         if (ctx->current == NULL) {
-                int i;
+                unsigned int i;
 
                 for (i = 0; (reg_predefined_keys[i].handle != 0) &&
@@ -617 +615 @@
         if (ctx->current == NULL) {
                 fprintf(stderr, "Unable to access any of the predefined keys\n");
-                return -1;
+                return 1;
         }
 
@@ -625 +623 @@
                 char *line, *prompt;
 
-                asprintf(&prompt, "%s\\%s> ", ctx->predef?ctx->predef:"", ctx->path);
+                if (asprintf(&prompt, "%s\\%s> ", ctx->predef?ctx->predef:"",
+                             ctx->path) < 0) {
+                        ret = false;
+                        break;
+                }
 
                 current_key = ctx->current;             /* No way to pass a void * pointer

vendor/current/source4/lib/registry/tools/regtree.c

@@ -34 +34 @@
  * @param novals Whether values should not be printed
  */
-static void print_tree(int level, struct registry_key *p,
+static void print_tree(unsigned int level, struct registry_key *p,
                        const char *name,
                        bool fullpath, bool novals)
@@ -44 +44 @@
         struct security_descriptor *sec_desc;
         WERROR error;
-        int i;
+        unsigned int i;
         TALLOC_CTX *mem_ctx;
 
@@ -70 +70 @@
 
         if(!W_ERROR_EQUAL(error, WERR_NO_MORE_ITEMS)) {
-                DEBUG(0, ("Error occured while fetching subkeys for '%s': %s\n",
+                DEBUG(0, ("Error occurred while fetching subkeys for '%s': %s\n",
                                   name, win_errstr(error)));
         }
@@ -79 +79 @@
                         mem_ctx, p, i, &valuename, &valuetype, &valuedata));
                         i++) {
-                        int j;
+                        unsigned int j;
                         for(j = 0; j < level+1; j++) putchar(' ');
                         printf("%s\n",  reg_val_description(mem_ctx,
-                                lp_iconv_convenience(cmdline_lp_ctx), valuename,
-                                valuetype, valuedata));
+                                valuename, valuetype, valuedata));
                 }
                 talloc_free(mem_ctx);
 
                 if(!W_ERROR_EQUAL(error, WERR_NO_MORE_ITEMS)) {
-                        DEBUG(0, ("Error occured while fetching values for '%s': %s\n",
+                        DEBUG(0, ("Error occurred while fetching values for '%s': %s\n",
                                 name, win_errstr(error)));
                 }
@@ -102 +101 @@
 int main(int argc, char **argv)
 {
-        int opt, i;
+        int opt;
+        unsigned int i;
         const char *file = NULL;
         const char *remote = NULL;

vendor/current/source4/lib/registry/util.c

@@ -3 +3 @@
    Transparent registry backend handling
    Copyright (C) Jelmer Vernooij                        2003-2007.
+   Copyright (C) Wilco Baan Hofman                      2010.
 
    This program is free software; you can redistribute it and/or modify
@@ -21 +22 @@
 #include "lib/registry/registry.h"
 #include "librpc/gen_ndr/winreg.h"
-
-/**
- * @file
- * @brief Registry utility functions
- */
-
-static const struct {
-        uint32_t id;
-        const char *name;
-} reg_value_types[] = {
-        { REG_SZ, "REG_SZ" },
-        { REG_DWORD, "REG_DWORD" },
-        { REG_BINARY, "REG_BINARY" },
-        { REG_EXPAND_SZ, "REG_EXPAND_SZ" },
-        { REG_NONE, "REG_NONE" },
-        { 0, NULL }
-};
-
-/** Return string description of registry value type */
-_PUBLIC_ const char *str_regtype(int type)
-{
-        int i;
-        for (i = 0; reg_value_types[i].name; i++) {
-                if (reg_value_types[i].id == type)
-                        return reg_value_types[i].name;
-        }
-
-        return "Unknown";
-}
-
-_PUBLIC_ char *reg_val_data_string(TALLOC_CTX *mem_ctx, 
-                                   struct smb_iconv_convenience *iconv_convenience,
-                                   uint32_t type,
+#include "lib/util/data_blob.h"
+
+_PUBLIC_ char *reg_val_data_string(TALLOC_CTX *mem_ctx, uint32_t type,
                                    const DATA_BLOB data)
 {
@@ -64 +35 @@
                 case REG_EXPAND_SZ:
                 case REG_SZ:
-                        convert_string_talloc_convenience(mem_ctx, iconv_convenience, CH_UTF16, CH_UNIX,
+                        convert_string_talloc(mem_ctx,
+                                              CH_UTF16, CH_UNIX,
                                               data.data, data.length,
                                               (void **)&ret, NULL, false);
-                        return ret;
+                        break;
+                case REG_DWORD:
+                case REG_DWORD_BIG_ENDIAN:
+                        SMB_ASSERT(data.length == sizeof(uint32_t));
+                        ret = talloc_asprintf(mem_ctx, "0x%8.8x",
+                                              IVAL(data.data, 0));
+                        break;
+                case REG_QWORD:
+                        SMB_ASSERT(data.length == sizeof(uint64_t));
+                        ret = talloc_asprintf(mem_ctx, "0x%16.16llx",
+                                              (long long)BVAL(data.data, 0));
+                        break;
                 case REG_BINARY:
-                        ret = data_blob_hex_string(mem_ctx, &data);
-                        return ret;
-                case REG_DWORD:
-                        if (*(int *)data.data == 0)
-                                return talloc_strdup(mem_ctx, "0");
-                        return talloc_asprintf(mem_ctx, "0x%x",
-                                               *(int *)data.data);
+                        ret = data_blob_hex_string_upper(mem_ctx, &data);
+                        break;
+                case REG_NONE:
+                        /* "NULL" is the right return value */
+                        break;
                 case REG_MULTI_SZ:
+                        /* FIXME: We don't support this yet */
+                        break;
+                default:
                         /* FIXME */
-                        break;
-                default:
+                        /* Other datatypes aren't supported -> return "NULL" */
                         break;
         }
@@ -87 +70 @@
 
 /** Generate a string that describes a registry value */
-_PUBLIC_ char *reg_val_description(TALLOC_CTX *mem_ctx, 
-                                   struct smb_iconv_convenience *iconv_convenience, 
+_PUBLIC_ char *reg_val_description(TALLOC_CTX *mem_ctx,
                                    const char *name,
                                    uint32_t data_type,
@@ -95 +77 @@
         return talloc_asprintf(mem_ctx, "%s = %s : %s", name?name:"<No Name>",
                                str_regtype(data_type),
-                               reg_val_data_string(mem_ctx, iconv_convenience, data_type, data));
-}
-
-_PUBLIC_ bool reg_string_to_val(TALLOC_CTX *mem_ctx, 
-                                struct smb_iconv_convenience *iconv_convenience,
-                                const char *type_str,
-                                const char *data_str, uint32_t *type,
-                                DATA_BLOB *data)
-{
-        int i;
-        *type = -1;
-
-        /* Find the correct type */
-        for (i = 0; reg_value_types[i].name; i++) {
-                if (!strcmp(reg_value_types[i].name, type_str)) {
-                        *type = reg_value_types[i].id;
-                        break;
+                               reg_val_data_string(mem_ctx, data_type, data));
+}
+
+/*
+ * This implements reading hex bytes that include comma's.
+ * It was previously handled by strhex_to_data_blob, but that did not cover
+ * the format used by windows.
+ */
+static DATA_BLOB reg_strhex_to_data_blob(TALLOC_CTX *mem_ctx, const char *str)
+{
+        DATA_BLOB ret;
+        const char *HEXCHARS = "0123456789ABCDEF";
+        size_t i, j;
+        char *hi, *lo;
+
+        ret = data_blob_talloc_zero(mem_ctx, (strlen(str)+(strlen(str) % 3))/3);
+        j = 0;
+        for (i = 0; i < strlen(str); i++) {
+                hi = strchr(HEXCHARS, toupper(str[i]));
+                if (hi == NULL)
+                        continue;
+
+                i++;
+                lo = strchr(HEXCHARS, toupper(str[i]));
+                if (lo == NULL)
+                        break;
+
+                ret.data[j] = PTR_DIFF(hi, HEXCHARS) << 4;
+                ret.data[j] += PTR_DIFF(lo, HEXCHARS);
+                j++;
+
+                if (j > ret.length) {
+                        DEBUG(0, ("Trouble converting hex string to bin\n"));
+                        break;
+                }
+        }
+        return ret;
+}
+
+
+_PUBLIC_ bool reg_string_to_val(TALLOC_CTX *mem_ctx, const char *type_str,
+                                const char *data_str, uint32_t *type, DATA_BLOB *data)
+{
+        char *tmp_type_str, *p, *q;
+        int result;
+
+        *type = regtype_by_string(type_str);
+
+        if (*type == -1) {
+                /* Normal windows format is hex, hex(type int as string),
+                   dword or just a string. */
+                if (strncmp(type_str, "hex(", 4) == 0) {
+                        /* there is a hex string with the value type between
+                           the braces */
+                        tmp_type_str = talloc_strdup(mem_ctx, type_str);
+                        q = p = tmp_type_str + strlen("hex(");
+
+                        /* Go to the closing brace or end of the string */
+                        while (*q != ')' && *q != '\0') q++;
+                        *q = '\0';
+
+                        /* Convert hex string to int, store it in type */
+                        result = sscanf(p, "%x", type);
+                        if (!result) {
+                                DEBUG(0, ("Could not convert hex to int\n"));
+                                return false;
+                        }
+                        talloc_free(tmp_type_str);
+                } else if (strcmp(type_str, "hex") == 0) {
+                        *type = REG_BINARY;
+                } else if (strcmp(type_str, "dword") == 0) {
+                        *type = REG_DWORD;
                 }
         }
@@ -120 +157 @@
         /* Convert data appropriately */
 
-        switch (*type)
-        {
+        switch (*type) {
                 case REG_SZ:
+                        return convert_string_talloc(mem_ctx,
+                                                     CH_UNIX, CH_UTF16,
+                                                     data_str, strlen(data_str)+1,
+                                                     (void **)&data->data,
+                                                     &data->length, false);
+                        break;
+                case REG_MULTI_SZ:
                 case REG_EXPAND_SZ:
-                convert_string_talloc_convenience(mem_ctx, iconv_convenience, CH_UNIX, CH_UTF16,
-                                                     data_str, strlen(data_str),
-                                                     (void **)&data->data, &data->length, false);
-                        break;
-
-                case REG_DWORD: {
-                        uint32_t tmp = strtol(data_str, NULL, 0);
-                        *data = data_blob_talloc(mem_ctx, &tmp, 4);
+                case REG_BINARY:
+                        *data = reg_strhex_to_data_blob(mem_ctx, data_str);
+                        break;
+                case REG_DWORD:
+                case REG_DWORD_BIG_ENDIAN: {
+                        uint32_t tmp = strtol(data_str, NULL, 16);
+                        *data = data_blob_talloc(mem_ctx, NULL, sizeof(uint32_t));
+                        if (data->data == NULL) return false;
+                        SIVAL(data->data, 0, tmp);
                         }
                         break;
-
+                case REG_QWORD: {
+                        uint64_t tmp = strtoll(data_str, NULL, 16);
+                        *data = data_blob_talloc(mem_ctx, NULL, sizeof(uint64_t));
+                        if (data->data == NULL) return false;
+                        SBVAL(data->data, 0, tmp);
+                        }
+                        break;
                 case REG_NONE:
                         ZERO_STRUCTP(data);
                         break;
-
-                case REG_BINARY:
-                        *data = strhex_to_data_blob(mem_ctx, data_str);
-                        break;
-
                 default:
                         /* FIXME */
+                        /* Other datatypes aren't supported -> return no success */
                         return false;
         }
@@ -156 +202 @@
         struct registry_key *predef;
         WERROR error;
-        int predeflength;
+        size_t predeflength;
         char *predefname;
 
@@ -165 +211 @@
 
         predefname = talloc_strndup(mem_ctx, name, predeflength);
+        W_ERROR_HAVE_NO_MEMORY(predefname);
         error = reg_get_predefined_key_by_name(handle, predefname, &predef);
         talloc_free(predefname);
@@ -193 +240 @@
 
         parent_name = talloc_strndup(mem_ctx, path, strrchr(path, '\\')-path);
-
+        W_ERROR_HAVE_NO_MEMORY(parent_name);
         error = reg_open_key_abs(mem_ctx, ctx, parent_name, parent);
+        talloc_free(parent_name);
         if (!W_ERROR_IS_OK(error)) {
                 return error;
@@ -200 +248 @@
 
         *name = talloc_strdup(mem_ctx, strrchr(path, '\\')+1);
+        W_ERROR_HAVE_NO_MEMORY(*name);
 
         return WERR_OK;
@@ -217 +266 @@
         error = get_abs_parent(mem_ctx, ctx, path, &parent, &n);
         if (W_ERROR_IS_OK(error)) {
-                error = reg_key_del(parent, n);
+                error = reg_key_del(mem_ctx, parent, n);
         }
 
@@ -233 +282 @@
         const char *n;
         WERROR error;
+
+        *result = NULL;
 
         if (!strchr(path, '\\')) {