Changeset 988 for vendor/current/source3/registry

Timestamp:

Nov 24, 2016, 1:14:11 PM (9 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: update vendor to version 4.4.3

Location:

vendor/current/source3/registry

Files:

• reg_api.c (modified) (26 diffs)
• reg_api.h (modified) (2 diffs)
• reg_api_util.c (modified) (6 diffs)
• reg_api_util.h (modified) (2 diffs)
• reg_backend_current_version.c (modified) (1 diff)
• reg_backend_db.c (modified) (64 diffs)
• reg_backend_db.h (modified) (1 diff)
• reg_backend_hkpt_params.c (modified) (3 diffs)
• reg_backend_netlogon_params.c (modified) (1 diff)
• reg_backend_printing.c (modified) (5 diffs)
• reg_backend_shares.c (modified) (1 diff)
• reg_backend_smbconf.c (modified) (2 diffs)
• reg_cachehook.c (modified) (1 diff)
• reg_db.h (modified) (1 diff)
• reg_dispatcher.c (modified) (6 diffs)
• reg_dispatcher.h (modified) (1 diff)
• reg_format.c (modified) (2 diffs)
• reg_import.c (modified) (11 diffs)
• reg_import.h (modified) (1 diff)
• reg_init_full.c (modified) (1 diff)
• reg_objects.c (modified) (14 diffs)
• reg_objects.h (modified) (2 diffs)
• reg_parse.c (modified) (4 diffs)
• reg_parse_internal.c (modified) (5 diffs)
• reg_parse_internal.h (modified) (2 diffs)
• reg_parse_prs.c (modified) (16 diffs)
• reg_parse_prs.h (modified) (2 diffs)
• reg_perfcount.c (modified) (42 diffs)
• reg_perfcount.h (modified) (1 diff)
• reg_util_internal.c (modified) (2 diffs)
• reg_util_token.c (modified) (1 diff)
• regfio.c (modified) (75 diffs)
• regfio.h (modified) (9 diffs)

vendor/current/source3/registry/reg_api.c

@@ -71 +71 @@
 #include "reg_objects.h"
 #include "../librpc/gen_ndr/ndr_security.h"
+#include "reg_parse_internal.h"
 
 #undef DBGC_CLASS
@@ -112 +113 @@
         }
 
+        TALLOC_FREE(key->subkeys);
         werr = regsubkey_ctr_init(key, &(key->subkeys));
         W_ERROR_NOT_OK_RETURN(werr);
@@ -132 +134 @@
                                    const char *name,
                                    const struct security_token *token,
-                                   uint32 access_desired,
+                                   uint32_t access_desired,
                                    struct registry_key **pregkey)
 {
@@ -143 +145 @@
         SMB_ASSERT(strchr(name, '\\') == NULL);
 
-        if (!(regkey = TALLOC_ZERO_P(mem_ctx, struct registry_key)) ||
+        if (!(regkey = talloc_zero(mem_ctx, struct registry_key)) ||
             !(regkey->token = dup_nt_token(regkey, token)) ||
-            !(regkey->key = TALLOC_ZERO_P(regkey, struct registry_key_handle)))
+            !(regkey->key = talloc_zero(regkey, struct registry_key_handle)))
         {
                 result = WERR_NOMEM;
@@ -190 +192 @@
         /* Tag this as a Performance Counter Key */
 
-        if( StrnCaseCmp(key->name, KEY_HKPD, strlen(KEY_HKPD)) == 0 )
+        if( strncasecmp_m(key->name, KEY_HKPD, strlen(KEY_HKPD)) == 0 )
                 key->type = REG_KEY_HKPD;
 
@@ -228 +230 @@
 
 WERROR reg_openhive(TALLOC_CTX *mem_ctx, const char *hive,
-                    uint32 desired_access,
+                    uint32_t desired_access,
                     const struct security_token *token,
                     struct registry_key **pkey)
 {
+        const struct hive_info *hi;
         SMB_ASSERT(hive != NULL);
-        SMB_ASSERT(hive[0] != '\0');
         SMB_ASSERT(strchr(hive, '\\') == NULL);
 
-        return regkey_open_onelevel(mem_ctx, NULL, hive, token, desired_access,
-                                    pkey);
+        hi = hive_info(hive);
+        if (hi == NULL) {
+                return WERR_BADFILE;
+        }
+
+        return regkey_open_onelevel(mem_ctx, NULL, hi->short_name, token,
+                                    desired_access, pkey);
 }
 
@@ -246 +253 @@
 
 WERROR reg_openkey(TALLOC_CTX *mem_ctx, struct registry_key *parent,
-                   const char *name, uint32 desired_access,
+                   const char *name, uint32_t desired_access,
                    struct registry_key **pkey)
 {
@@ -298 +305 @@
 
 WERROR reg_enumkey(TALLOC_CTX *mem_ctx, struct registry_key *key,
-                   uint32 idx, char **name, NTTIME *last_write_time)
+                   uint32_t idx, char **name, NTTIME *last_write_time)
 {
         WERROR err;
@@ -306 +313 @@
         }
 
-        if (!W_ERROR_IS_OK(err = fill_subkey_cache(key))) {
+        err = fill_subkey_cache(key);
+        if (!W_ERROR_IS_OK(err)) {
                 return err;
         }
@@ -328 +336 @@
 
 WERROR reg_enumvalue(TALLOC_CTX *mem_ctx, struct registry_key *key,
-                     uint32 idx, char **pname, struct registry_value **pval)
+                     uint32_t idx, char **pname, struct registry_value **pval)
 {
         struct registry_value *val;
@@ -338 +346 @@
         }
 
-        if (!(W_ERROR_IS_OK(err = fill_value_cache(key)))) {
+        err = fill_value_cache(key);
+        if (!(W_ERROR_IS_OK(err))) {
                 return err;
         }
@@ -369 +378 @@
 static WERROR reg_enumvalue_nocachefill(TALLOC_CTX *mem_ctx,
                                         struct registry_key *key,
-                                        uint32 idx, char **pname,
+                                        uint32_t idx, char **pname,
                                         struct registry_value **pval)
 {
@@ -408 +417 @@
 {
         WERROR err;
-        uint32 i;
+        uint32_t i;
 
         if (!(key->key->access_granted & KEY_QUERY_VALUE)) {
@@ -492 +501 @@
                         NTTIME *last_changed_time)
 {
-        uint32 i, max_size;
+        uint32_t i, max_size;
         size_t max_len;
         TALLOC_CTX *mem_ctx;
@@ -549 +558 @@
 
 WERROR reg_createkey(TALLOC_CTX *ctx, struct registry_key *parent,
-                     const char *subkeypath, uint32 desired_access,
+                     const char *subkeypath, uint32_t desired_access,
                      struct registry_key **pkey,
                      enum winreg_CreateAction *paction)
 {
         struct registry_key *key = parent;
-        struct registry_key *create_parent;
         TALLOC_CTX *mem_ctx;
         char *path, *end;
@@ -627 +635 @@
         {
                 err = WERR_ACCESS_DENIED;
-                goto done;
+                goto trans_done;
         }
 
@@ -666 +674 @@
 }
 
-WERROR reg_deletekey(struct registry_key *parent, const char *path)
+static WERROR reg_deletekey_internal(TALLOC_CTX *mem_ctx,
+                                     struct registry_key *parent,
+                                     const char *path, bool lazy)
 {
         WERROR err;
         char *name, *end;
-        struct registry_key *tmp_key, *key;
-        TALLOC_CTX *mem_ctx = talloc_stackframe();
-
+        struct registry_key *key;
         name = talloc_strdup(mem_ctx, path);
         if (name == NULL) {
@@ -679 +687 @@
         }
 
+        /* no subkeys - proceed with delete */
+        end = strrchr(name, '\\');
+        if (end != NULL) {
+                *end = '\0';
+
+                err = reg_openkey(mem_ctx, parent, name,
+                                  KEY_CREATE_SUB_KEY, &key);
+                W_ERROR_NOT_OK_GOTO_DONE(err);
+
+                parent = key;
+                name = end+1;
+        }
+
+        if (name[0] == '\0') {
+                err = WERR_INVALID_PARAM;
+                goto done;
+        }
+
+        err = delete_reg_subkey(parent->key, name, lazy);
+
+done:
+        return err;
+}
+
+WERROR reg_deletekey(struct registry_key *parent, const char *path)
+{
+        WERROR err;
+        struct registry_key *key;
+        TALLOC_CTX *mem_ctx = talloc_stackframe();
+
         /* check if the key has subkeys */
-        err = reg_openkey(mem_ctx, parent, name, REG_KEY_READ, &key);
+        err = reg_openkey(mem_ctx, parent, path, REG_KEY_READ, &key);
         W_ERROR_NOT_OK_GOTO_DONE(err);
 
@@ -691 +729 @@
 
         err = fill_subkey_cache(key);
-        W_ERROR_NOT_OK_GOTO(err, trans_done);
+        if (!W_ERROR_IS_OK(err)) {
+                goto trans_done;
+        }
 
         if (regsubkey_ctr_numkeys(key->subkeys) > 0) {
@@ -697 +737 @@
                 goto trans_done;
         }
-
-        /* no subkeys - proceed with delete */
-        end = strrchr(name, '\\');
-        if (end != NULL) {
-                *end = '\0';
-
-                err = reg_openkey(mem_ctx, parent, name,
-                                  KEY_CREATE_SUB_KEY, &tmp_key);
-                W_ERROR_NOT_OK_GOTO(err, trans_done);
-
-                parent = tmp_key;
-                name = end+1;
-        }
-
-        if (name[0] == '\0') {
-                err = WERR_INVALID_PARAM;
-                goto trans_done;
-        }
-
-        err = delete_reg_subkey(parent->key, name);
+        err = reg_deletekey_internal(mem_ctx, parent, path, false);
 
 trans_done:
@@ -735 +756 @@
         return err;
 }
+
 
 WERROR reg_setvalue(struct registry_key *key, const char *name,
@@ -932 +954 @@
 static WERROR reg_deletekey_recursive_internal(struct registry_key *parent,
                                                const char *path,
-                                               bool del_key)
+                                               bool del_key, bool lazy)
 {
         WERROR werr = WERR_OK;
         struct registry_key *key;
         char *subkey_name = NULL;
-        uint32 i;
+        uint32_t i;
         TALLOC_CTX *mem_ctx = talloc_stackframe();
+
+        DEBUG(5, ("reg_deletekey_recursive_internal: deleting '%s' from '%s'\n",
+                  path, parent->key->name));
 
         /* recurse through subkeys first */
         werr = reg_openkey(mem_ctx, parent, path, REG_KEY_ALL, &key);
         if (!W_ERROR_IS_OK(werr)) {
+                DEBUG(3, ("reg_deletekey_recursive_internal: error opening "
+                          "subkey '%s' of '%s': '%s'\n",
+                          path, parent->key->name, win_errstr(werr)));
                 goto done;
         }
@@ -955 +983 @@
         for (i = regsubkey_ctr_numkeys(key->subkeys) ; i > 0; i--) {
                 subkey_name = regsubkey_ctr_specific_key(key->subkeys, i-1);
-                werr = reg_deletekey_recursive_internal(key, subkey_name, true);
+                werr = reg_deletekey_recursive_internal(key, subkey_name, true, del_key);
                 W_ERROR_NOT_OK_GOTO_DONE(werr);
         }
@@ -961 +989 @@
         if (del_key) {
                 /* now delete the actual key */
-                werr = reg_deletekey(parent, path);
+                werr = reg_deletekey_internal(mem_ctx, parent, path, lazy);
         }
 
 done:
+
+        DEBUG(5, ("reg_deletekey_recursive_internal: done deleting '%s' from "
+                  "'%s': %s\n",
+                  path, parent->key->name, win_errstr(werr)));
         TALLOC_FREE(mem_ctx);
         return werr;
@@ -983 +1015 @@
         }
 
-        werr = reg_deletekey_recursive_internal(parent, path, del_key);
+        werr = reg_deletekey_recursive_internal(parent, path, del_key, false);
 
         if (!W_ERROR_IS_OK(werr)) {
                 WERROR werr2;
-
-                DEBUG(1, (__location__ " failed to delete key '%s' from key "
-                          "'%s': %s\n", path, parent->key->name,
-                          win_errstr(werr)));
+                DEBUG(W_ERROR_EQUAL(werr, WERR_BADFILE) ? 5 : 1,
+                      (__location__ ": failed to delete key '%s' from key "
+                       "'%s': %s\n", path, parent->key->name,
+                       win_errstr(werr)));
 
                 werr2 = regdb_transaction_cancel();
@@ -1008 +1040 @@
                                   "error committing transaction: %s\n",
                                   win_errstr(werr)));
+                } else {
+                        DEBUG(5, ("reg_deletekey_recursive_trans: deleted key '%s' from '%s'\n",
+                                  path, parent->key->name));
+
                 }
         }

vendor/current/source3/registry/reg_api.h

@@ -25 +25 @@
 
 WERROR reg_openhive(TALLOC_CTX *mem_ctx, const char *hive,
-                    uint32 desired_access,
+                    uint32_t desired_access,
                     const struct security_token *token,
                     struct registry_key **pkey);
 WERROR reg_openkey(TALLOC_CTX *mem_ctx, struct registry_key *parent,
-                   const char *name, uint32 desired_access,
+                   const char *name, uint32_t desired_access,
                    struct registry_key **pkey);
 WERROR reg_enumkey(TALLOC_CTX *mem_ctx, struct registry_key *key,
-                   uint32 idx, char **name, NTTIME *last_write_time);
+                   uint32_t idx, char **name, NTTIME *last_write_time);
 WERROR reg_enumvalue(TALLOC_CTX *mem_ctx, struct registry_key *key,
-                     uint32 idx, char **pname, struct registry_value **pval);
+                     uint32_t idx, char **pname, struct registry_value **pval);
 WERROR reg_queryvalue(TALLOC_CTX *mem_ctx, struct registry_key *key,
                       const char *name, struct registry_value **pval);
@@ -49 +49 @@
                         NTTIME *last_changed_time);
 WERROR reg_createkey(TALLOC_CTX *ctx, struct registry_key *parent,
-                     const char *subkeypath, uint32 desired_access,
+                     const char *subkeypath, uint32_t desired_access,
                      struct registry_key **pkey,
                      enum winreg_CreateAction *paction);

vendor/current/source3/registry/reg_api_util.c

@@ -27 +27 @@
 #include "reg_api.h"
 #include "reg_api_util.h"
+#include "libcli/registry/util_reg.h"
 
 /**
@@ -32 +33 @@
  */
 WERROR reg_open_path(TALLOC_CTX *mem_ctx, const char *orig_path,
-                     uint32 desired_access, const struct security_token *token,
+                     uint32_t desired_access, const struct security_token *token,
                      struct registry_key **pkey)
 {
@@ -83 +84 @@
 }
 
-#if 0
-/* these two functions are unused. */
-
 /**
  * Utility function to create a registry key without opening the hive
@@ -92 +90 @@
 
 WERROR reg_create_path(TALLOC_CTX *mem_ctx, const char *orig_path,
-                       uint32 desired_access,
+                       uint32_t desired_access,
                        const struct security_token *token,
                        enum winreg_CreateAction *paction,
@@ -142 +140 @@
 
 /*
- * Utility function to create a registry key without opening the hive
- * before. Will not delete a hive.
+ * Utility function to recursively delete a registry key without opening the
+ * hive before. Will not delete a hive.
  */
 
@@ -175 +173 @@
         }
 
-        err = reg_deletekey(hive, p+1);
+        err = reg_deletekey_recursive(hive, p+1);
         SAFE_FREE(path);
         TALLOC_FREE(hive);
         return err;
 }
-#endif /* #if 0 */
+
+struct registry_value *registry_value_dw(TALLOC_CTX *mem_ctx, uint32_t dw)
+{
+        struct registry_value *ret;
+
+        ret = talloc_zero(mem_ctx, struct registry_value);
+        if (ret == NULL) {
+                return NULL;
+        }
+
+        ret->data = data_blob_talloc(ret, NULL, sizeof(uint32_t));
+        if (ret->data.data == NULL) {
+                talloc_free(ret);
+                return NULL;
+        }
+
+        ret->type = REG_DWORD;
+
+        SIVAL(ret->data.data, 0, dw);
+
+        return ret;
+}
+
+struct registry_value *registry_value_sz(TALLOC_CTX *mem_ctx, const char *str)
+{
+        struct registry_value *ret;
+
+        ret = talloc_zero(mem_ctx, struct registry_value);
+        if (ret == NULL) {
+                return NULL;
+        }
+
+        if (!push_reg_sz(ret, &ret->data, str)) {
+                talloc_free(ret);
+                return NULL;
+        }
+
+        ret->type = REG_SZ;
+
+        return ret;
+}
+
+struct registry_value *registry_value_multi_sz(TALLOC_CTX *mem_ctx, const char **str)
+{
+        struct registry_value *ret;
+
+        ret = talloc_zero(mem_ctx, struct registry_value);
+        if (ret == NULL) {
+                return NULL;
+        }
+
+        if (!push_reg_multi_sz(ret, &ret->data, str)) {
+                talloc_free(ret);
+                return NULL;
+        }
+
+        ret->type = REG_MULTI_SZ;
+
+        return ret;
+}
+
+int registry_value_cmp(const struct registry_value* v1, const struct registry_value* v2)
+{
+        if (v1->type == v2->type) {
+                return data_blob_cmp(&v1->data, &v2->data);
+        }
+        return v1->type - v2->type;
+}

vendor/current/source3/registry/reg_api_util.h

@@ -30 +30 @@
  */
 WERROR reg_open_path(TALLOC_CTX *mem_ctx, const char *orig_path,
-                     uint32 desired_access, const struct security_token *token,
+                     uint32_t desired_access, const struct security_token *token,
                      struct registry_key **pkey);
 
-#if 0
-/* currently unused */
 WERROR reg_create_path(TALLOC_CTX *mem_ctx, const char *orig_path,
-                       uint32 desired_access,
+                       uint32_t desired_access,
                        const struct security_token *token,
                        enum winreg_CreateAction *paction,
@@ -42 +40 @@
 WERROR reg_delete_path(const struct security_token *token,
                        const char *orig_path);
-#endif
+
+struct registry_value *registry_value_dw(TALLOC_CTX *mem_ctx, uint32_t dw);
+struct registry_value *registry_value_sz(TALLOC_CTX *mem_ctx, const char *str);
+struct registry_value *registry_value_multi_sz(TALLOC_CTX *mem_ctx, const char **str);
+
+int registry_value_cmp(const struct registry_value *v1, const struct registry_value *v2);
 
 #endif /* _REG_API_UTIL_H */

vendor/current/source3/registry/reg_backend_current_version.c

@@ -59 +59 @@
         regval_ctr_addvalue_sz(values, "SystemRoot", sysroot_string);
 
-        fstr_sprintf(sysversion, "%d.%d", lp_major_announce_version(),
-                     lp_minor_announce_version());
+        fstr_sprintf(sysversion, "%d.%d", SAMBA_MAJOR_NBT_ANNOUNCE_VERSION,
+                     SAMBA_MINOR_NBT_ANNOUNCE_VERSION);
 
         regval_ctr_addvalue_sz(values, "CurrentVersion", sysversion);

vendor/current/source3/registry/reg_backend_db.c

@@ -3 +3 @@
  *  Virtual Windows Registry Layer
  *  Copyright (C) Gerald Carter                     2002-2005
- *  Copyright (C) Michael Adam                      2007-2009
+ *  Copyright (C) Michael Adam                      2007-2011
+ *  Copyright (C) Gregor Beck                       2011
  *
  *  This program is free software; you can redistribute it and/or modify
@@ -26 +27 @@
 #include "reg_db.h"
 #include "reg_util_internal.h"
+#include "reg_parse_internal.h"
 #include "reg_backend_db.h"
 #include "reg_objects.h"
 #include "nt_printing.h"
 #include "util_tdb.h"
-#include "dbwrap.h"
+#include "dbwrap/dbwrap.h"
+#include "dbwrap/dbwrap_open.h"
+#include "../libcli/security/secdesc.h"
 
 #undef DBGC_CLASS
 #define DBGC_CLASS DBGC_REGISTRY
 
+#define REGDB_VERSION_KEYNAME "INFO/version"
+
 static struct db_context *regdb = NULL;
 static int regdb_refcount;
 
 static bool regdb_key_exists(struct db_context *db, const char *key);
-static bool regdb_key_is_base_key(const char *key);
 static WERROR regdb_fetch_keys_internal(struct db_context *db, const char *key,
                                         struct regsubkey_ctr *ctr);
@@ -46 +51 @@
 static int regdb_fetch_values_internal(struct db_context *db, const char* key,
                                        struct regval_ctr *values);
-static bool regdb_store_values_internal(struct db_context *db, const char *key,
-                                        struct regval_ctr *values);
-
-static NTSTATUS create_sorted_subkeys(const char *key);
+static NTSTATUS regdb_store_values_internal(struct db_context *db, const char *key,
+                                            struct regval_ctr *values);
+static WERROR regdb_store_subkey_list(struct db_context *db, const char *parent,
+                                      const char *key);
+
+static WERROR regdb_create_basekey(struct db_context *db, const char *key);
+static WERROR regdb_create_subkey_internal(struct db_context *db,
+                                           const char *key,
+                                           const char *subkey);
+
+
+struct regdb_trans_ctx {
+        NTSTATUS (*action)(struct db_context *, void *);
+        void *private_data;
+};
+
+static NTSTATUS regdb_trans_do_action(struct db_context *db, void *private_data)
+{
+        NTSTATUS status;
+        int32_t version_id;
+        struct regdb_trans_ctx *ctx = (struct regdb_trans_ctx *)private_data;
+
+        status = dbwrap_fetch_int32_bystring(db, REGDB_VERSION_KEYNAME,
+                                             &version_id);
+
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(0, ("ERROR: could not fetch registry db version: %s. "
+                          "Denying access.\n", nt_errstr(status)));
+                return NT_STATUS_ACCESS_DENIED;
+        }
+
+        if (version_id != REGDB_CODE_VERSION) {
+                DEBUG(0, ("ERROR: changed registry version %d found while "
+                          "trying to write to the registry. Version %d "
+                          "expected.  Denying access.\n",
+                          version_id, REGDB_CODE_VERSION));
+                return NT_STATUS_ACCESS_DENIED;
+        }
+
+        status = ctx->action(db,  ctx->private_data);
+        return status;
+}
+
+static WERROR regdb_trans_do(struct db_context *db,
+                             NTSTATUS (*action)(struct db_context *, void *),
+                             void *private_data)
+{
+        NTSTATUS status;
+        struct regdb_trans_ctx ctx;
+
+
+        ctx.action = action;
+        ctx.private_data = private_data;
+
+        status = dbwrap_trans_do(db, regdb_trans_do_action, &ctx);
+
+        return ntstatus_to_werror(status);
+}
 
 /* List the deepest path into the registry.  All part components will be created.*/
@@ -95 +154 @@
         const char *path;
         const char *valuename;
-        uint32 type;
+        uint32_t type;
         union {
                 const char *string;
-                uint32 dw_value;
+                uint32_t dw_value;
         } data;
 };
@@ -114 +173 @@
 };
 
+static WERROR create_key_recursive(struct db_context *db,
+                                   char *path,
+                                   const char *subkey)
+{
+        WERROR werr;
+        char *p;
+
+        if (subkey == NULL) {
+                return WERR_INVALID_PARAM;
+        }
+
+        if (path == NULL) {
+                return regdb_create_basekey(db, subkey);
+        }
+
+        p = strrchr_m(path, '\\');
+
+        if (p == NULL) {
+                werr = create_key_recursive(db, NULL, path);
+        } else {
+                *p = '\0';
+                werr = create_key_recursive(db, path, p+1);
+                *p = '\\';
+        }
+
+        if (!W_ERROR_IS_OK(werr)) {
+                goto done;
+        }
+
+        werr = regdb_create_subkey_internal(db, path, subkey);
+
+done:
+        return werr;
+}
+
 /**
  * Initialize a key in the registry:
@@ -121 +215 @@
                                          const char *add_path)
 {
+        char *subkey, *key;
         WERROR werr;
         TALLOC_CTX *frame = talloc_stackframe();
-        char *path = NULL;
-        char *base = NULL;
-        char *remaining = NULL;
-        char *keyname;
-        char *subkeyname;
-        struct regsubkey_ctr *subkeys;
-        const char *p, *p2;
-
-        DEBUG(6, ("init_registry_key: Adding [%s]\n", add_path));
-
-        path = talloc_strdup(frame, add_path);
-        base = talloc_strdup(frame, "");
-        if (!path || !base) {
-                werr = WERR_NOMEM;
-                goto fail;
-        }
-        p = path;
-
-        while (next_token_talloc(frame, &p, &keyname, "\\")) {
-
-                /* build up the registry path from the components */
-
-                if (*base) {
-                        base = talloc_asprintf(frame, "%s\\", base);
-                        if (!base) {
-                                werr = WERR_NOMEM;
-                                goto fail;
-                        }
-                }
-                base = talloc_asprintf_append(base, "%s", keyname);
-                if (!base) {
-                        werr = WERR_NOMEM;
-                        goto fail;
-                }
-
-                /* get the immediate subkeyname (if we have one ) */
-
-                subkeyname = talloc_strdup(frame, "");
-                if (!subkeyname) {
-                        werr = WERR_NOMEM;
-                        goto fail;
-                }
-                if (*p) {
-                        remaining = talloc_strdup(frame, p);
-                        if (!remaining) {
-                                werr = WERR_NOMEM;
-                                goto fail;
-                        }
-                        p2 = remaining;
-
-                        if (!next_token_talloc(frame, &p2,
-                                                &subkeyname, "\\"))
-                        {
-                                subkeyname = talloc_strdup(frame,p2);
-                                if (!subkeyname) {
-                                        werr = WERR_NOMEM;
-                                        goto fail;
-                                }
-                        }
-                }
-
-                DEBUG(10,("init_registry_key: Storing key [%s] with "
-                          "subkey [%s]\n", base,
-                          *subkeyname ? subkeyname : "NULL"));
-
-                /* we don't really care if the lookup succeeds or not
-                 * since we are about to update the record.
-                 * We just want any subkeys already present */
-
-                werr = regsubkey_ctr_init(frame, &subkeys);
-                if (!W_ERROR_IS_OK(werr)) {
-                        DEBUG(0,("talloc() failure!\n"));
-                        goto fail;
-                }
-
-                werr = regdb_fetch_keys_internal(db, base, subkeys);
-                if (!W_ERROR_IS_OK(werr) &&
-                    !W_ERROR_EQUAL(werr, WERR_NOT_FOUND))
-                {
-                        goto fail;
-                }
-
-                if (*subkeyname) {
-                        werr = regsubkey_ctr_addkey(subkeys, subkeyname);
-                        if (!W_ERROR_IS_OK(werr)) {
-                                goto fail;
-                        }
-                }
-                if (!regdb_store_keys_internal(db, base, subkeys)) {
-                        werr = WERR_CAN_NOT_COMPLETE;
-                        goto fail;
-                }
-        }
-
-        werr = WERR_OK;
-
-fail:
-        TALLOC_FREE(frame);
+
+        if (add_path == NULL) {
+                werr = WERR_INVALID_PARAM;
+                goto done;
+        }
+
+        key = talloc_strdup(frame, add_path);
+
+        subkey = strrchr_m(key, '\\');
+        if (subkey == NULL) {
+                subkey = key;
+                key = NULL;
+        } else {
+                *subkey = '\0';
+                subkey++;
+        }
+
+        werr = create_key_recursive(db, key, subkey);
+
+done:
+        talloc_free(frame);
         return werr;
 }
@@ -253 +271 @@
         init_ctx.add_path = add_path;
 
-        return ntstatus_to_werror(dbwrap_trans_do(regdb,
-                                                  init_registry_key_action,
-                                                  &init_ctx));
+        return regdb_trans_do(regdb,
+                              init_registry_key_action,
+                              &init_ctx);
 }
 
@@ -269 +287 @@
                 regval_ctr_addvalue(ctr, value->valuename, REG_DWORD,
                                     (uint8_t *)&value->data.dw_value,
-                                    sizeof(uint32));
+                                    sizeof(uint32_t));
                 break;
 
@@ -326 +344 @@
                         regdb_ctr_add_value(values,
                                             &builtin_registry_values[i]);
-                        regdb_store_values_internal(db,
+                        status = regdb_store_values_internal(db,
                                         builtin_registry_values[i].path,
                                         values);
+                        if (!NT_STATUS_IS_OK(status)) {
+                                goto done;
+                        }
                 }
                 TALLOC_FREE(values);
@@ -388 +409 @@
          */
 
-        werr = ntstatus_to_werror(dbwrap_trans_do(regdb,
-                                                  init_registry_data_action,
-                                                  NULL));
+        werr = regdb_trans_do(regdb,
+                              init_registry_data_action,
+                              NULL);
 
 done:
@@ -403 +424 @@
         const char *keyname;
         NTSTATUS status;
-
-        if (rec->key.dptr == NULL || rec->key.dsize == 0) {
+        TDB_DATA key;
+        TDB_DATA value;
+        struct db_context *db = (struct db_context *)private_data;
+
+        key = dbwrap_record_get_key(rec);
+        if (key.dptr == NULL || key.dsize == 0) {
                 return 0;
         }
 
-        keyname = strchr((const char *) rec->key.dptr, '/');
+        value = dbwrap_record_get_value(rec);
+
+        if (db == NULL) {
+                DEBUG(0, ("regdb_normalize_keynames_fn: ERROR: "
+                          "NULL db context handed in via private_data\n"));
+                return 1;
+        }
+
+        if (strncmp((const char *)key.dptr, REGDB_VERSION_KEYNAME,
+            strlen(REGDB_VERSION_KEYNAME)) == 0)
+        {
+                return 0;
+        }
+
+        keyname = strchr((const char *)key.dptr, '/');
         if (keyname) {
-                struct db_record new_rec;
-
                 keyname = talloc_string_sub(mem_ctx,
-                                            (const char *) rec->key.dptr,
+                                            (const char *)key.dptr,
                                             "/",
                                             "\\");
 
                 DEBUG(2, ("regdb_normalize_keynames_fn: Convert %s to %s\n",
-                          (const char *) rec->key.dptr,
+                          (const char *)key.dptr,
                           keyname));
 
-                new_rec.value = rec->value;
-                new_rec.key = string_term_tdb_data(keyname);
-                new_rec.private_data = rec->private_data;
-
                 /* Delete the original record and store the normalized key */
-                status = rec->delete_rec(rec);
+                status = dbwrap_record_delete(rec);
                 if (!NT_STATUS_IS_OK(status)) {
                         DEBUG(0,("regdb_normalize_keynames_fn: "
                                  "tdb_delete for [%s] failed!\n",
-                                 rec->key.dptr));
+                                 (const char *)key.dptr));
                         return 1;
                 }
 
-                status = rec->store(&new_rec, new_rec.value, TDB_REPLACE);
+                status = dbwrap_store_bystring(db, keyname, value, TDB_REPLACE);
                 if (!NT_STATUS_IS_OK(status)) {
                         DEBUG(0,("regdb_normalize_keynames_fn: "
@@ -446 +479 @@
 }
 
-static WERROR regdb_store_regdb_version(uint32_t version)
+static WERROR regdb_store_regdb_version(struct db_context *db, uint32_t version)
 {
         NTSTATUS status;
-        const char *version_keyname = "INFO/version";
-
-        if (!regdb) {
+        if (db == NULL) {
                 return WERR_CAN_NOT_COMPLETE;
         }
 
-        status = dbwrap_trans_store_int32(regdb, version_keyname, version);
+        status = dbwrap_trans_store_int32_bystring(db, REGDB_VERSION_KEYNAME,
+                                                   version);
         if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(1, ("regdb_store_regdb_version: error storing %s = %d: %s\n",
-                          version_keyname, version, nt_errstr(status)));
+                          REGDB_VERSION_KEYNAME, version, nt_errstr(status)));
                 return ntstatus_to_werror(status);
         } else {
                 DEBUG(10, ("regdb_store_regdb_version: stored %s = %d\n",
-                          version_keyname, version));
+                          REGDB_VERSION_KEYNAME, version));
                 return WERR_OK;
         }
 }
 
-static WERROR regdb_upgrade_v1_to_v2(void)
+static WERROR regdb_upgrade_v1_to_v2(struct db_context *db)
 {
         TALLOC_CTX *mem_ctx;
-        int rc;
+        NTSTATUS status;
         WERROR werr;
 
         mem_ctx = talloc_stackframe();
-        if (mem_ctx == NULL) {
-                return WERR_NOMEM;
-        }
-
-        rc = regdb->traverse(regdb, regdb_normalize_keynames_fn, mem_ctx);
-
-        talloc_destroy(mem_ctx);
-
-        if (rc == -1) {
-                return WERR_REG_IO_FAILURE;
-        }
-
-        werr = regdb_store_regdb_version(REGVER_V2);
+
+        status = dbwrap_traverse(db, regdb_normalize_keynames_fn, db, NULL);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = WERR_REG_IO_FAILURE;
+                goto done;
+        }
+
+        werr = regdb_store_regdb_version(db, REGDB_VERSION_V2);
+
+done:
+        talloc_free(mem_ctx);
+        return werr;
+}
+
+static bool tdb_data_read_uint32(TDB_DATA *buf, uint32_t *result)
+{
+        const size_t len = sizeof(uint32_t);
+        if (buf->dsize >= len) {
+                *result = IVAL(buf->dptr, 0);
+                buf->dptr += len;
+                buf->dsize -= len;
+                return true;
+        }
+        return false;
+}
+
+static bool tdb_data_read_cstr(TDB_DATA *buf, char **result)
+{
+        const size_t len = strnlen((char*)buf->dptr, buf->dsize) + 1;
+        if (buf->dsize >= len) {
+                *result = (char*)buf->dptr;
+                buf->dptr += len;
+                buf->dsize -= len;
+                return true;
+        }
+        return false;
+}
+
+static bool tdb_data_is_cstr(TDB_DATA d) {
+        if (tdb_data_is_empty(d) || (d.dptr[d.dsize-1] != '\0')) {
+                return false;
+        }
+        return strlen((char *)d.dptr) == (d.dsize-1);
+}
+
+static bool upgrade_v2_to_v3_check_subkeylist(struct db_context *db,
+                                              const char *key,
+                                              const char *subkey)
+{
+        static uint32_t zero = 0;
+        static TDB_DATA empty_subkey_list = {
+                .dptr = (unsigned char*)&zero,
+                .dsize = sizeof(uint32_t),
+        };
+        bool success = false;
+        char *path = talloc_asprintf(talloc_tos(), "%s\\%s", key, subkey);
+        if (!strupper_m(path)) {
+                goto done;
+        }
+
+        if (!dbwrap_exists(db, string_term_tdb_data(path))) {
+                NTSTATUS status;
+
+                DEBUG(10, ("regdb_upgrade_v2_to_v3: writing subkey list [%s]\n",
+                           path));
+
+                status = dbwrap_store_bystring(db, path, empty_subkey_list,
+                                               TDB_INSERT);
+                if (!NT_STATUS_IS_OK(status)) {
+                        DEBUG(0, ("regdb_upgrade_v2_to_v3: writing subkey list "
+                                  "[%s] failed\n", path));
+                        goto done;
+                }
+        }
+        success = true;
+done:
+        talloc_free(path);
+        return success;
+}
+
+static bool upgrade_v2_to_v3_check_parent(struct db_context *db,
+                                          const char *key)
+{
+        const char *sep = strrchr_m(key, '\\');
+        if (sep != NULL) {
+                char *pkey = talloc_strndup(talloc_tos(), key, sep-key);
+                if (!dbwrap_exists(db, string_term_tdb_data(pkey))) {
+                        DEBUG(0, ("regdb_upgrade_v2_to_v3: missing subkey list "
+                                  "[%s]\nrun \"net registry check\"\n", pkey));
+                }
+                talloc_free(pkey);
+        }
+        return true;
+}
+
+
+#define IS_EQUAL(d,s) (((d).dsize == strlen(s)+1) &&    \
+                       (strcmp((char*)(d).dptr, (s)) == 0))
+#define STARTS_WITH(d,s) (((d).dsize > strlen(s)) &&                    \
+                          (strncmp((char*)(d).dptr, (s), strlen(s)) == 0))
+#define SSTR(d) (int)(d).dsize , (char*)(d).dptr
+
+
+static int regdb_upgrade_v2_to_v3_fn(struct db_record *rec, void *private_data)
+{
+        struct db_context *db = (struct db_context *)private_data;
+        TDB_DATA key = dbwrap_record_get_key(rec);
+        TDB_DATA val = dbwrap_record_get_value(rec);
+
+        if (tdb_data_is_empty(key)) {
+                return 0;
+        }
+
+        if (db == NULL) {
+                DEBUG(0, ("regdb_upgrade_v2_to_v3_fn: ERROR: "
+                          "NULL db context handed in via private_data\n"));
+                return 1;
+        }
+
+        if (IS_EQUAL(key, REGDB_VERSION_KEYNAME) ||
+            STARTS_WITH(key, REG_VALUE_PREFIX) ||
+            STARTS_WITH(key, REG_SECDESC_PREFIX))
+        {
+                DEBUG(10, ("regdb_upgrade_v2_to_v3: skipping [%.*s]\n",
+                           SSTR(key)));
+                return 0;
+        }
+
+        if (STARTS_WITH(key, REG_SORTED_SUBKEYS_PREFIX)) {
+                NTSTATUS status;
+                /* Delete the deprecated sorted subkeys cache. */
+
+                DEBUG(10, ("regdb_upgrade_v2_to_v3: deleting [%.*s]\n",
+                           SSTR(key)));
+
+                status = dbwrap_record_delete(rec);
+                if (!NT_STATUS_IS_OK(status)) {
+                        DEBUG(0, ("regdb_upgrade_v2_to_v3: deleting [%.*s] "
+                                  "failed!\n", SSTR(key)));
+                        return 1;
+                }
+
+                return 0;
+        }
+
+        if ( tdb_data_is_cstr(key) &&
+             hive_info((char*)key.dptr) != NULL )
+        {
+                /*
+                 * Found a regular subkey list record.
+                 * Walk the list and create the list record for those
+                 * subkeys that don't already have one.
+                 */
+                TDB_DATA pos = val;
+                char *subkey, *path = (char*)key.dptr;
+                uint32_t num_items, found_items = 0;
+
+
+                DEBUG(10, ("regdb_upgrade_v2_to_v3: scanning subkeylist of "
+                           "[%s]\n", path));
+
+                if (!tdb_data_read_uint32(&pos, &num_items)) {
+                        /* invalid or empty - skip */
+                        return 0;
+                }
+
+                while (tdb_data_read_cstr(&pos, &subkey)) {
+                        found_items++;
+
+                        if (!upgrade_v2_to_v3_check_subkeylist(db, path, subkey))
+                        {
+                                return 1;
+                        }
+
+                        if (!upgrade_v2_to_v3_check_parent(db, path)) {
+                                return 1;
+                        }
+                }
+                if (found_items != num_items) {
+                        DEBUG(0, ("regdb_upgrade_v2_to_v3: inconsistent subkey "
+                                  "list [%s]\nrun \"net registry check\"\n",
+                                  path));
+                }
+        } else {
+                DEBUG(10, ("regdb_upgrade_v2_to_v3: skipping invalid [%.*s]\n"
+                           "run \"net registry check\"\n", SSTR(key)));
+        }
+
+        return 0;
+}
+
+static WERROR regdb_upgrade_v2_to_v3(struct db_context *db)
+{
+        NTSTATUS status;
+        WERROR werr;
+
+        status = dbwrap_traverse(db, regdb_upgrade_v2_to_v3_fn, db, NULL);
+        if (!NT_STATUS_IS_OK(status)) {
+                werr = WERR_REG_IO_FAILURE;
+                goto done;
+        }
+
+        werr = regdb_store_regdb_version(db, REGDB_VERSION_V3);
+
+done:
         return werr;
 }
@@ -496 +720 @@
 WERROR regdb_init(void)
 {
-        const char *vstring = "INFO/version";
-        uint32 vers_id, expected_version;
+        int32_t vers_id;
         WERROR werr;
+        NTSTATUS status;
+        char *db_path;
 
         if (regdb) {
@@ -507 +732 @@
         }
 
-        regdb = db_open(NULL, state_path("registry.tdb"), 0,
-                              REG_TDB_FLAGS, O_RDWR, 0600);
+        db_path = state_path("registry.tdb");
+        if (db_path == NULL) {
+                return WERR_NOMEM;
+        }
+
+        regdb = db_open(NULL, db_path, 0,
+                        REG_TDB_FLAGS, O_RDWR, 0600,
+                        DBWRAP_LOCK_ORDER_1, REG_DBWRAP_FLAGS);
         if (!regdb) {
-                regdb = db_open(NULL, state_path("registry.tdb"), 0,
-                                      REG_TDB_FLAGS, O_RDWR|O_CREAT, 0600);
+                regdb = db_open(NULL, db_path, 0,
+                                REG_TDB_FLAGS, O_RDWR|O_CREAT, 0600,
+                                DBWRAP_LOCK_ORDER_1, REG_DBWRAP_FLAGS);
                 if (!regdb) {
                         werr = ntstatus_to_werror(map_nt_error_from_unix(errno));
                         DEBUG(1,("regdb_init: Failed to open registry %s (%s)\n",
-                                state_path("registry.tdb"), strerror(errno) ));
+                                db_path, strerror(errno) ));
+                        TALLOC_FREE(db_path);
                         return werr;
                 }
 
+                werr = regdb_store_regdb_version(regdb, REGDB_CODE_VERSION);
+                if (!W_ERROR_IS_OK(werr)) {
+                        DEBUG(1, ("regdb_init: Failed to store version: %s\n",
+                                  win_errstr(werr)));
+                        TALLOC_FREE(db_path);
+                        return werr;
+                }
+
                 DEBUG(10,("regdb_init: Successfully created registry tdb\n"));
         }
+        TALLOC_FREE(db_path);
 
         regdb_refcount = 1;
@@ -526 +768 @@
                    regdb_refcount));
 
-        expected_version = REGVER_V2;
-
-        vers_id = dbwrap_fetch_int32(regdb, vstring);
-        if (vers_id == -1) {
+        status = dbwrap_fetch_int32_bystring(regdb, REGDB_VERSION_KEYNAME,
+                                             &vers_id);
+        if (!NT_STATUS_IS_OK(status)) {
                 DEBUG(10, ("regdb_init: registry version uninitialized "
                            "(got %d), initializing to version %d\n",
-                           vers_id, expected_version));
-
-                werr = regdb_store_regdb_version(expected_version);
-                return werr;
-        }
-
-        if (vers_id > expected_version || vers_id == 0) {
-                DEBUG(1, ("regdb_init: unknown registry version %d "
+                           vers_id, REGDB_VERSION_V1));
+
+                /*
+                 * There was a regdb format version prior to version 1
+                 * which did not store a INFO/version key. The format
+                 * of this version was identical to version 1 except for
+                 * the lack of the sorted subkey cache records.
+                 * Since these are disposable, we can safely assume version
+                 * 1 if no INFO/version key is found and run the db through
+                 * the whole chain of upgrade. If the database was not
+                 * initialized, this does not harm. If it was the unversioned
+                 * version ("0"), then it do the right thing with the records.
+                 */
+                werr = regdb_store_regdb_version(regdb, REGDB_VERSION_V1);
+                if (!W_ERROR_IS_OK(werr)) {
+                        return werr;
+                }
+                vers_id = REGDB_VERSION_V1;
+        }
+
+        if (vers_id == REGDB_CODE_VERSION) {
+                return WERR_OK;
+        }
+
+        if (vers_id > REGDB_CODE_VERSION || vers_id == 0) {
+                DEBUG(0, ("regdb_init: unknown registry version %d "
                           "(code version = %d), refusing initialization\n",
-                          vers_id, expected_version));
+                          vers_id, REGDB_CODE_VERSION));
                 return WERR_CAN_NOT_COMPLETE;
         }
 
-        if (vers_id == REGVER_V1) {
-                DEBUG(10, ("regdb_init: got registry db version %d, upgrading "
-                           "to version %d\n", REGVER_V1, REGVER_V2));
-
-                if (regdb->transaction_start(regdb) != 0) {
-                        return WERR_REG_IO_FAILURE;
-                }
-
-                werr = regdb_upgrade_v1_to_v2();
+        if (dbwrap_transaction_start(regdb) != 0) {
+                return WERR_REG_IO_FAILURE;
+        }
+
+        if (vers_id == REGDB_VERSION_V1) {
+                DEBUG(10, ("regdb_init: upgrading registry from version %d "
+                           "to %d\n", REGDB_VERSION_V1, REGDB_VERSION_V2));
+
+                werr = regdb_upgrade_v1_to_v2(regdb);
                 if (!W_ERROR_IS_OK(werr)) {
-                        regdb->transaction_cancel(regdb);
+                        dbwrap_transaction_cancel(regdb);
                         return werr;
                 }
 
-                if (regdb->transaction_commit(regdb) != 0) {
-                        return WERR_REG_IO_FAILURE;
-                }
-
-                vers_id = REGVER_V2;
+                vers_id = REGDB_VERSION_V2;
+        }
+
+        if (vers_id == REGDB_VERSION_V2) {
+                DEBUG(10, ("regdb_init: upgrading registry from version %d "
+                           "to %d\n", REGDB_VERSION_V2, REGDB_VERSION_V3));
+
+                werr = regdb_upgrade_v2_to_v3(regdb);
+                if (!W_ERROR_IS_OK(werr)) {
+                        dbwrap_transaction_cancel(regdb);
+                        return werr;
+                }
+
+                vers_id = REGDB_VERSION_V3;
         }
 
         /* future upgrade code should go here */
+
+        if (dbwrap_transaction_commit(regdb) != 0) {
+                return WERR_REG_IO_FAILURE;
+        }
 
         return WERR_OK;
@@ -578 +850 @@
 {
         WERROR result = WERR_OK;
+        char *db_path;
+        int saved_errno;
 
         if ( regdb ) {
@@ -586 +860 @@
         }
 
+        db_path = state_path("registry.tdb");
+        if (db_path == NULL) {
+                return WERR_NOMEM;
+        }
+
         become_root();
 
-        regdb = db_open(NULL, state_path("registry.tdb"), 0,
-                              REG_TDB_FLAGS, O_RDWR, 0600);
+        regdb = db_open(NULL, db_path, 0,
+                        REG_TDB_FLAGS, O_RDWR, 0600,
+                        DBWRAP_LOCK_ORDER_1, REG_DBWRAP_FLAGS);
+        saved_errno = errno;
+        unbecome_root();
         if ( !regdb ) {
-                result = ntstatus_to_werror( map_nt_error_from_unix( errno ) );
+                result = ntstatus_to_werror(map_nt_error_from_unix(saved_errno));
                 DEBUG(0,("regdb_open: Failed to open %s! (%s)\n",
-                        state_path("registry.tdb"), strerror(errno) ));
-        }
-
-        unbecome_root();
+                         db_path, strerror(saved_errno)));
+                TALLOC_FREE(db_path);
+                return result;
+        }
+        TALLOC_FREE(db_path);
 
         regdb_refcount = 1;
@@ -602 +885 @@
                    regdb_refcount));
 
-        return result;
+        return WERR_OK;
 }
 
@@ -630 +913 @@
 WERROR regdb_transaction_start(void)
 {
-        return (regdb->transaction_start(regdb) == 0) ?
+        return (dbwrap_transaction_start(regdb) == 0) ?
                 WERR_OK : WERR_REG_IO_FAILURE;
 }
@@ -636 +919 @@
 WERROR regdb_transaction_commit(void)
 {
-        return (regdb->transaction_commit(regdb) == 0) ?
+        return (dbwrap_transaction_commit(regdb) == 0) ?
                 WERR_OK : WERR_REG_IO_FAILURE;
 }
@@ -642 +925 @@
 WERROR regdb_transaction_cancel(void)
 {
-        return (regdb->transaction_cancel(regdb) == 0) ?
+        return (dbwrap_transaction_cancel(regdb) == 0) ?
                 WERR_OK : WERR_REG_IO_FAILURE;
 }
@@ -653 +936 @@
 int regdb_get_seqnum(void)
 {
-        return regdb->get_seqnum(regdb);
+        return dbwrap_get_seqnum(regdb);
 }
 
@@ -684 +967 @@
         }
 
-        werr = ntstatus_to_werror(dbwrap_delete_bystring(db, path));
-
-        /* treat "not" found" as ok */
-        if (W_ERROR_EQUAL(werr, WERR_NOT_FOUND)) {
-                werr = WERR_OK;
-        }
+        werr = ntstatus_to_werror(dbwrap_purge_bystring(db, path));
 
 done:
@@ -711 +989 @@
         return regdb_delete_key_with_prefix(db, keyname, NULL);
 }
+
 
 static WERROR regdb_delete_key_lists(struct db_context *db, const char *keyname)
@@ -752 +1031 @@
 {
         TDB_DATA dbuf;
-        uint8 *buffer = NULL;
+        uint8_t *buffer = NULL;
         int i = 0;
-        uint32 len, buflen;
-        uint32 num_subkeys = regsubkey_ctr_numkeys(ctr);
+        uint32_t len, buflen;
+        uint32_t num_subkeys = regsubkey_ctr_numkeys(ctr);
         char *keyname = NULL;
         TALLOC_CTX *ctx = talloc_stackframe();
@@ -779 +1058 @@
         /* allocate some initial memory */
 
-        buffer = (uint8 *)SMB_MALLOC(1024);
+        buffer = (uint8_t *)SMB_MALLOC(1024);
         if (buffer == NULL) {
                 werr = WERR_NOMEM;
@@ -832 +1111 @@
         werr = ntstatus_to_werror(dbwrap_store_bystring(db, keyname, dbuf,
                                                         TDB_REPLACE));
-        W_ERROR_NOT_OK_GOTO_DONE(werr);
-
-        /*
-         * recreate the sorted subkey cache for regdb_key_exists()
-         */
-        werr = ntstatus_to_werror(create_sorted_subkeys(keyname));
 
 done:
         TALLOC_FREE(ctx);
         SAFE_FREE(buffer);
+        return werr;
+}
+
+/**
+ * Utility function to store a new empty list of
+ * subkeys of given key specified as parent and subkey name
+ * (thereby creating the key).
+ * If the parent keyname is NULL, then the "subkey" is
+ * interpreted as a base key.
+ * If the subkey list does already exist, it is not modified.
+ *
+ * Must be called from within a transaction.
+ */
+static WERROR regdb_store_subkey_list(struct db_context *db, const char *parent,
+                                      const char *key)
+{
+        WERROR werr;
+        char *path = NULL;
+        struct regsubkey_ctr *subkeys = NULL;
+        TALLOC_CTX *frame = talloc_stackframe();
+
+        if (parent == NULL) {
+                path = talloc_strdup(frame, key);
+        } else {
+                path = talloc_asprintf(frame, "%s\\%s", parent, key);
+        }
+        if (!path) {
+                werr = WERR_NOMEM;
+                goto done;
+        }
+
+        werr = regsubkey_ctr_init(frame, &subkeys);
+        W_ERROR_NOT_OK_GOTO_DONE(werr);
+
+        werr = regdb_fetch_keys_internal(db, path, subkeys);
+        if (W_ERROR_IS_OK(werr)) {
+                /* subkey list exists already - don't modify */
+                goto done;
+        }
+
+        werr = regsubkey_ctr_reinit(subkeys);
+        W_ERROR_NOT_OK_GOTO_DONE(werr);
+
+        /* create a record with 0 subkeys */
+        werr = regdb_store_keys_internal2(db, path, subkeys);
+        if (!W_ERROR_IS_OK(werr)) {
+                DEBUG(0, ("regdb_store_keys: Failed to store new record for "
+                          "key [%s]: %s\n", path, win_errstr(werr)));
+                goto done;
+        }
+
+done:
+        talloc_free(frame);
         return werr;
 }
@@ -862 +1188 @@
         int num_subkeys, i;
         char *path = NULL;
-        struct regsubkey_ctr *subkeys = NULL, *old_subkeys = NULL;
+        struct regsubkey_ctr *old_subkeys = NULL;
         char *oldkeyname = NULL;
         TALLOC_CTX *mem_ctx = talloc_stackframe();
@@ -945 +1271 @@
         num_subkeys = regsubkey_ctr_numkeys(store_ctx->ctr);
 
-        if (num_subkeys == 0) {
-                werr = regsubkey_ctr_init(mem_ctx, &subkeys);
+        for (i=0; i<num_subkeys; i++) {
+                const char *subkey;
+
+                subkey = regsubkey_ctr_specific_key(store_ctx->ctr, i);
+
+                werr = regdb_store_subkey_list(db, store_ctx->key, subkey);
                 W_ERROR_NOT_OK_GOTO_DONE(werr);
-
-                werr = regdb_store_keys_internal2(db, store_ctx->key, subkeys);
-                if (!W_ERROR_IS_OK(werr)) {
-                        DEBUG(0,("regdb_store_keys: Failed to store "
-                                 "new record for key [%s]: %s\n",
-                                 store_ctx->key, win_errstr(werr)));
-                        goto done;
-                }
-                TALLOC_FREE(subkeys);
-        }
-
-        for (i=0; i<num_subkeys; i++) {
-                path = talloc_asprintf(mem_ctx, "%s\\%s", store_ctx->key,
-                                regsubkey_ctr_specific_key(store_ctx->ctr, i));
-                if (!path) {
-                        werr = WERR_NOMEM;
-                        goto done;
-                }
-                werr = regsubkey_ctr_init(mem_ctx, &subkeys);
-                W_ERROR_NOT_OK_GOTO_DONE(werr);
-
-                werr = regdb_fetch_keys_internal(db, path, subkeys);
-                if (!W_ERROR_IS_OK(werr)) {
-                        /* create a record with 0 subkeys */
-                        werr = regdb_store_keys_internal2(db, path, subkeys);
-                        if (!W_ERROR_IS_OK(werr)) {
-                                DEBUG(0,("regdb_store_keys: Failed to store "
-                                         "new record for key [%s]: %s\n", path,
-                                         win_errstr(werr)));
-                                goto done;
-                        }
-                }
-
-                TALLOC_FREE(subkeys);
-                TALLOC_FREE(path);
         }
 
@@ -989 +1284 @@
          * prevent next read from going to disk
          */
-        werr = regsubkey_ctr_set_seqnum(store_ctx->ctr, db->get_seqnum(db));
+        werr = regsubkey_ctr_set_seqnum(store_ctx->ctr, dbwrap_get_seqnum(db));
 
 done:
@@ -1006 +1301 @@
         struct regdb_store_keys_context store_ctx;
 
-        if (!regdb_key_is_base_key(key) && !regdb_key_exists(db, key)) {
+        if (!regdb_key_exists(db, key)) {
                 goto done;
         }
@@ -1057 +1352 @@
         store_ctx.ctr = ctr;
 
-        werr = ntstatus_to_werror(dbwrap_trans_do(db,
-                                                  regdb_store_keys_action,
-                                                  &store_ctx));
+        werr = regdb_trans_do(db,
+                              regdb_store_keys_action,
+                              &store_ctx);
 
         ret = W_ERROR_IS_OK(werr);
@@ -1069 +1364 @@
 }
 
-bool regdb_store_keys(const char *key, struct regsubkey_ctr *ctr)
+static bool regdb_store_keys(const char *key, struct regsubkey_ctr *ctr)
 {
         return regdb_store_keys_internal(regdb, key, ctr);
@@ -1109 +1404 @@
         }
 
+        werr = regdb_store_subkey_list(db, create_ctx->key, create_ctx->subkey);
+
 done:
         talloc_free(mem_ctx);
@@ -1114 +1411 @@
 }
 
-static WERROR regdb_create_subkey(const char *key, const char *subkey)
+static WERROR regdb_create_subkey_internal(struct db_context *db,
+                                           const char *key,
+                                           const char *subkey)
 {
         WERROR werr;
@@ -1121 +1420 @@
         struct regdb_create_subkey_context create_ctx;
 
-        if (!regdb_key_is_base_key(key) && !regdb_key_exists(regdb, key)) {
+        if (!regdb_key_exists(db, key)) {
                 werr = WERR_NOT_FOUND;
                 goto done;
@@ -1129 +1428 @@
         W_ERROR_NOT_OK_GOTO_DONE(werr);
 
-        werr = regdb_fetch_keys_internal(regdb, key, subkeys);
+        werr = regdb_fetch_keys_internal(db, key, subkeys);
         W_ERROR_NOT_OK_GOTO_DONE(werr);
 
         if (regsubkey_ctr_key_exists(subkeys, subkey)) {
-                werr = WERR_OK;
-                goto done;
+                char *newkey;
+
+                newkey = talloc_asprintf(mem_ctx, "%s\\%s", key, subkey);
+                if (newkey == NULL) {
+                        werr = WERR_NOMEM;
+                        goto done;
+                }
+
+                if (regdb_key_exists(db, newkey)) {
+                        werr = WERR_OK;
+                        goto done;
+                }
         }
 
@@ -1142 +1451 @@
         create_ctx.subkey = subkey;
 
-        werr = ntstatus_to_werror(dbwrap_trans_do(regdb,
-                                                  regdb_create_subkey_action,
-                                                  &create_ctx));
+        werr = regdb_trans_do(db,
+                              regdb_create_subkey_action,
+                              &create_ctx);
 
 done:
         talloc_free(mem_ctx);
+        return werr;
+}
+
+static WERROR regdb_create_subkey(const char *key, const char *subkey)
+{
+        return regdb_create_subkey_internal(regdb, key, subkey);
+}
+
+/**
+ * create a base key
+ */
+
+struct regdb_create_basekey_context {
+        const char *key;
+};
+
+static NTSTATUS regdb_create_basekey_action(struct db_context *db,
+                                            void *private_data)
+{
+        WERROR werr;
+        struct regdb_create_basekey_context *create_ctx;
+
+        create_ctx = (struct regdb_create_basekey_context *)private_data;
+
+        werr = regdb_store_subkey_list(db, NULL, create_ctx->key);
+
+        return werror_to_ntstatus(werr);
+}
+
+static WERROR regdb_create_basekey(struct db_context *db, const char *key)
+{
+        WERROR werr;
+        struct regdb_create_subkey_context create_ctx;
+
+        create_ctx.key = key;
+
+        werr = regdb_trans_do(db,
+                              regdb_create_basekey_action,
+                              &create_ctx);
+
         return werr;
 }
@@ -1159 +1508 @@
         const char *subkey;
         const char *path;
+        bool lazy;
 };
 
@@ -1173 +1523 @@
         werr = regdb_delete_key_lists(db, delete_ctx->path);
         W_ERROR_NOT_OK_GOTO_DONE(werr);
+
+        if (delete_ctx->lazy) {
+                goto done;
+        }
 
         werr = regsubkey_ctr_init(mem_ctx, &subkeys);
@@ -1195 +1549 @@
 }
 
-static WERROR regdb_delete_subkey(const char *key, const char *subkey)
+static WERROR regdb_delete_subkey(const char *key, const char *subkey, bool lazy)
 {
         WERROR werr;
@@ -1202 +1556 @@
         TALLOC_CTX *mem_ctx = talloc_stackframe();
 
-        if (!regdb_key_is_base_key(key) && !regdb_key_exists(regdb, key)) {
+        if (!regdb_key_exists(regdb, key)) {
                 werr = WERR_NOT_FOUND;
                 goto done;
@@ -1221 +1575 @@
         delete_ctx.subkey = subkey;
         delete_ctx.path = path;
-
-        werr = ntstatus_to_werror(dbwrap_trans_do(regdb,
-                                                  regdb_delete_subkey_action,
-                                                  &delete_ctx));
+        delete_ctx.lazy = lazy;
+
+        werr = regdb_trans_do(regdb,
+                              regdb_delete_subkey_action,
+                              &delete_ctx);
 
 done:
@@ -1236 +1591 @@
         char *path = NULL;
         TDB_DATA data;
+        NTSTATUS status;
 
         path = normalize_reg_path(mem_ctx, key);
@@ -1242 +1598 @@
         }
 
-        data = dbwrap_fetch_bystring(db, mem_ctx, path);
+        status = dbwrap_fetch_bystring(db, mem_ctx, path, &data);
+        if (!NT_STATUS_IS_OK(status)) {
+                data = tdb_null;
+        }
 
         TALLOC_FREE(path);
@@ -1250 +1609 @@
 
 /**
- * check whether a given key name represents a base key,
- * i.e one without a subkey separator ('\').
+ * Check for the existence of a key.
+ *
+ * Existence of a key is authoritatively defined by
+ * the existence of the record that contains the list
+ * of its subkeys.
+ *
+ * Return false, if the record does not match the correct
+ * structure of an initial 4-byte counter and then a
+ * list of the corresponding number of zero-terminated
+ * strings.
  */
-static bool regdb_key_is_base_key(const char *key)
+static bool regdb_key_exists(struct db_context *db, const char *key)
 {
         TALLOC_CTX *mem_ctx = talloc_stackframe();
+        TDB_DATA value;
         bool ret = false;
         char *path;
+        uint32_t buflen;
+        const char *buf;
+        uint32_t num_items, i;
+        int32_t len;
 
         if (key == NULL) {
@@ -1273 +1645 @@
         }
 
-        ret = (strrchr(path, '\\') == NULL);
-
-done:
-        TALLOC_FREE(mem_ctx);
-        return ret;
-}
-
-/*
- * regdb_key_exists() is a very frequent operation. It can be quite
- * time-consuming to fully fetch the parent's subkey list, talloc_strdup all
- * subkeys and then compare the keyname linearly to all the parent's subkeys.
- *
- * The following code tries to make this operation as efficient as possible:
- * Per registry key we create a list of subkeys that is very efficient to
- * search for existence of a subkey. Its format is:
- *
- * 4 bytes num_subkeys
- * 4*num_subkey bytes offset into the string array
- * then follows a sorted list of subkeys in uppercase
- *
- * This record is created by create_sorted_subkeys() on demand if it does not
- * exist. scan_parent_subkeys() uses regdb->parse_record to search the sorted
- * list, the parsing code and the binary search can be found in
- * parent_subkey_scanner. The code uses parse_record() to avoid a memcpy of
- * the potentially large subkey record.
- *
- * The sorted subkey record is deleted in regdb_store_keys_internal2 and
- * recreated on demand.
- */
-
-static int cmp_keynames(char **p1, char **p2)
-{
-        return StrCaseCmp(*p1, *p2);
-}
-
-struct create_sorted_subkeys_context {
-        const char *key;
-        const char *sorted_keyname;
-};
-
-static NTSTATUS create_sorted_subkeys_action(struct db_context *db,
-                                             void *private_data)
-{
-        char **sorted_subkeys;
-        struct regsubkey_ctr *ctr;
-        NTSTATUS status;
-        char *buf;
-        char *p;
-        int i;
-        size_t len;
-        int num_subkeys;
-        struct create_sorted_subkeys_context *sorted_ctx;
-
-        sorted_ctx = (struct create_sorted_subkeys_context *)private_data;
+        value = regdb_fetch_key_internal(db, mem_ctx, path);
+        if (value.dptr == NULL) {
+                goto done;
+        }
+
+        if (value.dsize == 0) {
+                DEBUG(10, ("regdb_key_exists: subkeylist-record for key "
+                          "[%s] is empty: Could be a deleted record in a "
+                          "clustered (ctdb) environment?\n",
+                          path));
+                goto done;
+        }
+
+        len = tdb_unpack(value.dptr, value.dsize, "d", &num_items);
+        if (len == (int32_t)-1) {
+                DEBUG(1, ("regdb_key_exists: ERROR: subkeylist-record for key "
+                          "[%s] is invalid: Could not parse initial 4-byte "
+                          "counter. record data length is %u.\n",
+                          path, (unsigned int)value.dsize));
+                goto done;
+        }
 
         /*
-         * In this function, we only treat failing of the actual write to
-         * the db as a real error. All preliminary errors, at a stage when
-         * nothing has been written to the DB yet are treated as success
-         * to be committed (as an empty transaction).
-         *
-         * The reason is that this (disposable) call might be nested in other
-         * transactions. Doing a cancel here would destroy the possibility of
-         * a transaction_commit for transactions that we might be wrapped in.
+         * Note: the tdb_unpack check above implies that len <= value.dsize
          */
-
-        status = werror_to_ntstatus(regsubkey_ctr_init(talloc_tos(), &ctr));
-        if (!NT_STATUS_IS_OK(status)) {
-                /* don't treat this as an error */
-                status = NT_STATUS_OK;
-                goto done;
-        }
-
-        status = werror_to_ntstatus(regdb_fetch_keys_internal(db,
-                                                              sorted_ctx->key,
-                                                              ctr));
-        if (!NT_STATUS_IS_OK(status)) {
-                /* don't treat this as an error */
-                status = NT_STATUS_OK;
-                goto done;
-        }
-
-        num_subkeys = regsubkey_ctr_numkeys(ctr);
-        sorted_subkeys = talloc_array(ctr, char *, num_subkeys);
-        if (sorted_subkeys == NULL) {
-                /* don't treat this as an error */
-                goto done;
-        }
-
-        len = 4 + 4*num_subkeys;
-
-        for (i = 0; i < num_subkeys; i++) {
-                sorted_subkeys[i] = talloc_strdup_upper(sorted_subkeys,
-                                        regsubkey_ctr_specific_key(ctr, i));
-                if (sorted_subkeys[i] == NULL) {
-                        /* don't treat this as an error */
+        buflen = value.dsize - len;
+        buf = (const char *)value.dptr + len;
+
+        len = 0;
+
+        for (i = 0; i < num_items; i++) {
+                if (buflen == 0) {
+                        break;
+                }
+                len = strnlen(buf, buflen) + 1;
+                if (buflen < len) {
+                        DEBUG(1, ("regdb_key_exists: ERROR: subkeylist-record "
+                                  "for key [%s] is corrupt: %u items expected, "
+                                  "item number %u is not zero terminated.\n",
+                                  path, num_items, i+1));
                         goto done;
                 }
-                len += strlen(sorted_subkeys[i])+1;
-        }
-
-        TYPESAFE_QSORT(sorted_subkeys, num_subkeys, cmp_keynames);
-
-        buf = talloc_array(ctr, char, len);
-        if (buf == NULL) {
-                /* don't treat this as an error */
-                goto done;
-        }
-        p = buf + 4 + 4*num_subkeys;
-
-        SIVAL(buf, 0, num_subkeys);
-
-        for (i=0; i < num_subkeys; i++) {
-                ptrdiff_t offset = p - buf;
-                SIVAL(buf, 4 + 4*i, offset);
-                strlcpy(p, sorted_subkeys[i], len-offset);
-                p += strlen(sorted_subkeys[i]) + 1;
-        }
-
-        status = dbwrap_store_bystring(
-                db, sorted_ctx->sorted_keyname, make_tdb_data((uint8_t *)buf,
-                len),
-                TDB_REPLACE);
-
-done:
-        talloc_free(ctr);
-        return status;
-}
-
-static NTSTATUS create_sorted_subkeys_internal(const char *key,
-                                               const char *sorted_keyname)
-{
-        NTSTATUS status;
-        struct create_sorted_subkeys_context sorted_ctx;
-
-        sorted_ctx.key = key;
-        sorted_ctx.sorted_keyname = sorted_keyname;
-
-        status = dbwrap_trans_do(regdb,
-                                 create_sorted_subkeys_action,
-                                 &sorted_ctx);
-
-        return status;
-}
-
-static NTSTATUS create_sorted_subkeys(const char *key)
-{
-        char *sorted_subkeys_keyname;
-        NTSTATUS status;
-
-        sorted_subkeys_keyname = talloc_asprintf(talloc_tos(), "%s\\%s",
-                                                 REG_SORTED_SUBKEYS_PREFIX,
-                                                 key);
-        if (sorted_subkeys_keyname == NULL) {
-                status = NT_STATUS_NO_MEMORY;
-                goto done;
-        }
-
-        status = create_sorted_subkeys_internal(key, sorted_subkeys_keyname);
-
-done:
-        return status;
-}
-
-struct scan_subkey_state {
-        char *name;
-        bool scanned;
-        bool found;
-};
-
-static int parent_subkey_scanner(TDB_DATA key, TDB_DATA data,
-                                 void *private_data)
-{
-        struct scan_subkey_state *state =
-                (struct scan_subkey_state *)private_data;
-        uint32_t num_subkeys;
-        uint32_t l, u;
-
-        if (data.dsize < sizeof(uint32_t)) {
-                return -1;
-        }
-
-        state->scanned = true;
-        state->found = false;
-
-        tdb_unpack(data.dptr, data.dsize, "d", &num_subkeys);
-
-        l = 0;
-        u = num_subkeys;
-
-        while (l < u) {
-                uint32_t idx = (l+u)/2;
-                char *s = (char *)data.dptr + IVAL(data.dptr, 4 + 4*idx);
-                int comparison = strcmp(state->name, s);
-
-                if (comparison < 0) {
-                        u = idx;
-                } else if (comparison > 0) {
-                        l = idx + 1;
-                } else {
-                        state->found = true;
-                        return 0;
-                }
-        }
-        return 0;
-}
-
-static bool scan_parent_subkeys(struct db_context *db, const char *parent,
-                                const char *name)
-{
-        char *path = NULL;
-        char *key = NULL;
-        struct scan_subkey_state state = { 0, };
-        bool result = false;
-        int res;
-
-        state.name = NULL;
-
-        path = normalize_reg_path(talloc_tos(), parent);
-        if (path == NULL) {
-                goto fail;
-        }
-
-        key = talloc_asprintf(talloc_tos(), "%s\\%s",
-                              REG_SORTED_SUBKEYS_PREFIX, path);
-        if (key == NULL) {
-                goto fail;
-        }
-
-        state.name = talloc_strdup_upper(talloc_tos(), name);
-        if (state.name == NULL) {
-                goto fail;
-        }
-        state.scanned = false;
-
-        res = db->parse_record(db, string_term_tdb_data(key),
-                               parent_subkey_scanner, &state);
-
-        if (state.scanned) {
-                result = state.found;
-        } else {
-                NTSTATUS status;
-
-                res = db->transaction_start(db);
-                if (res != 0) {
-                        DEBUG(0, ("error starting transaction\n"));
-                        goto fail;
-                }
-
-                DEBUG(2, (__location__ " WARNING: recreating the sorted "
-                          "subkeys cache for key '%s' from scan_parent_subkeys "
-                          "this should not happen (too frequently)...\n",
-                          path));
-
-                status = create_sorted_subkeys_internal(path, key);
-                if (!NT_STATUS_IS_OK(status)) {
-                        res = db->transaction_cancel(db);
-                        if (res != 0) {
-                                smb_panic("Failed to cancel transaction.");
-                        }
-                        goto fail;
-                }
-
-                res = db->parse_record(db, string_term_tdb_data(key),
-                                       parent_subkey_scanner, &state);
-                if ((res == 0) && (state.scanned)) {
-                        result = state.found;
-                }
-
-                res = db->transaction_commit(db);
-                if (res != 0) {
-                        DEBUG(0, ("error committing transaction\n"));
-                        result = false;
-                }
-        }
-
- fail:
-        TALLOC_FREE(path);
-        TALLOC_FREE(state.name);
-        return result;
-}
-
-/**
- * Check for the existence of a key.
- *
- * Existence of a key is authoritatively defined by its
- * existence in the list of subkeys of its parent key.
- * The exeption of this are keys without a parent key,
- * i.e. the "base" keys (HKLM, HKCU, ...).
- */
-static bool regdb_key_exists(struct db_context *db, const char *key)
-{
-        TALLOC_CTX *mem_ctx = talloc_stackframe();
-        TDB_DATA value;
-        bool ret = false;
-        char *path, *p;
-
-        if (key == NULL) {
-                goto done;
-        }
-
-        path = normalize_reg_path(mem_ctx, key);
-        if (path == NULL) {
-                DEBUG(0, ("out of memory! (talloc failed)\n"));
-                goto done;
-        }
-
-        if (*path == '\0') {
-                goto done;
-        }
-
-        p = strrchr(path, '\\');
-        if (p == NULL) {
-                /* this is a base key */
-                value = regdb_fetch_key_internal(db, mem_ctx, path);
-                ret = (value.dptr != NULL);
-        } else {
-                *p = '\0';
-                ret = scan_parent_subkeys(db, path, p+1);
-        }
+
+                buf += len;
+                buflen -= len;
+        }
+
+        if (buflen > 0) {
+                DEBUG(1, ("regdb_key_exists: ERROR: subkeylist-record for key "
+                          "[%s] is corrupt: %u items expected and found, but "
+                          "the record contains additional %u bytes\n",
+                          path, num_items, buflen));
+                goto done;
+        }
+
+        if (i < num_items) {
+                DEBUG(1, ("regdb_key_exists: ERROR: subkeylist-record for key "
+                          "[%s] is corrupt: %u items expected, but only %u "
+                          "items found.\n",
+                          path, num_items, i+1));
+                goto done;
+        }
+
+        ret = true;
 
 done:
@@ -1610 +1726 @@
         WERROR werr;
         uint32_t num_items;
-        uint8 *buf;
-        uint32 buflen, len;
+        uint8_t *buf;
+        uint32_t buflen, len;
         int i;
         fstring subkeyname;
@@ -1631 +1747 @@
         count = 0;
         ZERO_STRUCT(value);
-        seqnum[0] = db->get_seqnum(db);
+        seqnum[0] = dbwrap_get_seqnum(db);
 
         do {
@@ -1637 +1753 @@
                 TALLOC_FREE(value.dptr);
                 value = regdb_fetch_key_internal(db, frame, key);
-                seqnum[count % 2] = db->get_seqnum(db);
+                seqnum[count % 2] = dbwrap_get_seqnum(db);
 
         } while (seqnum[0] != seqnum[1]);
@@ -1684 +1800 @@
 }
 
-int regdb_fetch_keys(const char *key, struct regsubkey_ctr *ctr)
+static int regdb_fetch_keys(const char *key, struct regsubkey_ctr *ctr)
 {
         WERROR werr;
@@ -1700 +1816 @@
  ***************************************************************************/
 
-static int regdb_unpack_values(struct regval_ctr *values, uint8 *buf, int buflen)
+static int regdb_unpack_values(struct regval_ctr *values, uint8_t *buf, int buflen)
 {
         int             len = 0;
-        uint32          type;
+        uint32_t        type;
         fstring valuename;
-        uint32          size;
-        uint8           *data_p;
-        uint32          num_values = 0;
+        uint32_t        size;
+        uint8_t         *data_p;
+        uint32_t        num_values = 0;
         int             i;
 
@@ -1742 +1858 @@
  ***************************************************************************/
 
-static int regdb_pack_values(struct regval_ctr *values, uint8 *buf, int buflen)
+static int regdb_pack_values(struct regval_ctr *values, uint8_t *buf, int buflen)
 {
         int             len = 0;
@@ -1803 +1919 @@
         ZERO_STRUCT(value);
         count = 0;
-        seqnum[0] = db->get_seqnum(db);
+        seqnum[0] = dbwrap_get_seqnum(db);
 
         do {
@@ -1809 +1925 @@
                 TALLOC_FREE(value.dptr);
                 value = regdb_fetch_key_internal(db, ctx, keystr);
-                seqnum[count % 2] = db->get_seqnum(db);
+                seqnum[count % 2] = dbwrap_get_seqnum(db);
         } while (seqnum[0] != seqnum[1]);
 
@@ -1836 +1952 @@
 }
 
-int regdb_fetch_values(const char* key, struct regval_ctr *values)
+static int regdb_fetch_values(const char* key, struct regval_ctr *values)
 {
         return regdb_fetch_values_internal(regdb, key, values);
 }
 
-static bool regdb_store_values_internal(struct db_context *db, const char *key,
-                                        struct regval_ctr *values)
+static NTSTATUS regdb_store_values_internal(struct db_context *db,
+                                            const char *key,
+                                            struct regval_ctr *values)
 {
         TDB_DATA old_data, data;
@@ -1849 +1966 @@
         int len;
         NTSTATUS status;
-        bool result = false;
         WERROR werr;
 
@@ -1855 +1971 @@
 
         if (!regdb_key_exists(db, key)) {
+                status = NT_STATUS_NOT_FOUND;
+                goto done;
+        }
+
+        if (regval_ctr_numvals(values) == 0) {
+                werr = regdb_delete_values(db, key);
+                if (!W_ERROR_IS_OK(werr)) {
+                        status = werror_to_ntstatus(werr);
+                        goto done;
+                }
+
+                /*
+                 * update the seqnum in the cache to prevent the next read
+                 * from going to disk
+                 */
+                werr = regval_ctr_set_seqnum(values, dbwrap_get_seqnum(db));
+                status = werror_to_ntstatus(werr);
                 goto done;
         }
@@ -1863 +1996 @@
         if (len <= 0) {
                 DEBUG(0,("regdb_store_values: unable to pack values. len <= 0\n"));
-                goto done;
-        }
-
-        data.dptr = TALLOC_ARRAY(ctx, uint8, len);
+                status = NT_STATUS_UNSUCCESSFUL;
+                goto done;
+        }
+
+        data.dptr = talloc_array(ctx, uint8_t, len);
         data.dsize = len;
 
@@ -1875 +2009 @@
         keystr = talloc_asprintf(ctx, "%s\\%s", REG_VALUE_PREFIX, key );
         if (!keystr) {
+                status = NT_STATUS_NO_MEMORY;
                 goto done;
         }
         keystr = normalize_reg_path(ctx, keystr);
         if (!keystr) {
-                goto done;
-        }
-
-        old_data = dbwrap_fetch_bystring(db, ctx, keystr);
-
-        if ((old_data.dptr != NULL)
+                status = NT_STATUS_NO_MEMORY;
+                goto done;
+        }
+
+        status = dbwrap_fetch_bystring(db, ctx, keystr, &old_data);
+
+        if (NT_STATUS_IS_OK(status)
+            && (old_data.dptr != NULL)
             && (old_data.dsize == data.dsize)
             && (memcmp(old_data.dptr, data.dptr, data.dsize) == 0))
         {
-                result = true;
+                status = NT_STATUS_OK;
                 goto done;
         }
@@ -1902 +2039 @@
          * from going to disk
          */
-        werr = regval_ctr_set_seqnum(values, db->get_seqnum(db));
-        result = W_ERROR_IS_OK(status);
+        werr = regval_ctr_set_seqnum(values, dbwrap_get_seqnum(db));
+        status = werror_to_ntstatus(werr);
 
 done:
         TALLOC_FREE(ctx);
-        return result;
-}
-
-bool regdb_store_values(const char *key, struct regval_ctr *values)
-{
-        return regdb_store_values_internal(regdb, key, values);
+        return status;
+}
+
+struct regdb_store_values_ctx {
+        const char *key;
+        struct regval_ctr *values;
+};
+
+static NTSTATUS regdb_store_values_action(struct db_context *db,
+                                          void *private_data)
+{
+        NTSTATUS status;
+        struct regdb_store_values_ctx *ctx =
+                (struct regdb_store_values_ctx *)private_data;
+
+        status = regdb_store_values_internal(db, ctx->key, ctx->values);
+
+        return status;
+}
+
+static bool regdb_store_values(const char *key, struct regval_ctr *values)
+{
+        WERROR werr;
+        struct regdb_store_values_ctx ctx;
+
+        ctx.key = key;
+        ctx.values = values;
+
+        werr = regdb_trans_do(regdb, regdb_store_values_action, &ctx);
+
+        return W_ERROR_IS_OK(werr);
 }
 
@@ -1943 +2105 @@
         }
 
-        data = dbwrap_fetch_bystring(regdb, tmp_ctx, tdbkey);
-        if (data.dptr == NULL) {
+        status = dbwrap_fetch_bystring(regdb, tmp_ctx, tdbkey, &data);
+        if (!NT_STATUS_IS_OK(status)) {
                 err = WERR_BADFILE;
                 goto done;
         }
 
-        status = unmarshall_sec_desc(mem_ctx, (uint8 *)data.dptr, data.dsize,
+        status = unmarshall_sec_desc(mem_ctx, (uint8_t *)data.dptr, data.dsize,
                                      psecdesc);
 
@@ -1963 +2125 @@
 }
 
+struct regdb_set_secdesc_ctx {
+        const char *key;
+        struct security_descriptor *secdesc;
+};
+
+static NTSTATUS regdb_set_secdesc_action(struct db_context *db,
+                                         void *private_data)
+{
+        char *tdbkey;
+        NTSTATUS status;
+        TDB_DATA tdbdata;
+        struct regdb_set_secdesc_ctx *ctx =
+                (struct regdb_set_secdesc_ctx *)private_data;
+        TALLOC_CTX *frame = talloc_stackframe();
+
+        tdbkey = talloc_asprintf(frame, "%s\\%s", REG_SECDESC_PREFIX, ctx->key);
+        if (tdbkey == NULL) {
+                status = NT_STATUS_NO_MEMORY;
+                goto done;
+        }
+
+        tdbkey = normalize_reg_path(frame, tdbkey);
+        if (tdbkey == NULL) {
+                status = NT_STATUS_NO_MEMORY;
+                goto done;
+        }
+
+        if (ctx->secdesc == NULL) {
+                /* assuming a delete */
+                status = dbwrap_delete_bystring(db, tdbkey);
+                goto done;
+        }
+
+        status = marshall_sec_desc(frame, ctx->secdesc, &tdbdata.dptr,
+                                   &tdbdata.dsize);
+        if (!NT_STATUS_IS_OK(status)) {
+                goto done;
+        }
+
+        status = dbwrap_store_bystring(db, tdbkey, tdbdata, 0);
+
+done:
+        TALLOC_FREE(frame);
+        return status;
+}
+
 static WERROR regdb_set_secdesc(const char *key,
                                 struct security_descriptor *secdesc)
 {
-        TALLOC_CTX *mem_ctx = talloc_stackframe();
-        char *tdbkey;
-        WERROR err = WERR_NOMEM;
-        TDB_DATA tdbdata;
+        WERROR err;
+        struct regdb_set_secdesc_ctx ctx;
 
         if (!regdb_key_exists(regdb, key)) {
@@ -1976 +2182 @@
         }
 
-        tdbkey = talloc_asprintf(mem_ctx, "%s\\%s", REG_SECDESC_PREFIX, key);
-        if (tdbkey == NULL) {
-                goto done;
-        }
-
-        tdbkey = normalize_reg_path(mem_ctx, tdbkey);
-        if (tdbkey == NULL) {
-                err = WERR_NOMEM;
-                goto done;
-        }
-
-        if (secdesc == NULL) {
-                /* assuming a delete */
-                err = ntstatus_to_werror(dbwrap_trans_delete_bystring(regdb,
-                                                                      tdbkey));
-                goto done;
-        }
-
-        err = ntstatus_to_werror(marshall_sec_desc(mem_ctx, secdesc,
-                                                   &tdbdata.dptr,
-                                                   &tdbdata.dsize));
-        W_ERROR_NOT_OK_GOTO_DONE(err);
-
-        err = ntstatus_to_werror(dbwrap_trans_store_bystring(regdb, tdbkey,
-                                                             tdbdata, 0));
-
- done:
-        TALLOC_FREE(mem_ctx);
+        ctx.key = key;
+        ctx.secdesc = secdesc;
+
+        err = regdb_trans_do(regdb, regdb_set_secdesc_action, &ctx);
+
+done:
         return err;
 }
 
-bool regdb_subkeys_need_update(struct regsubkey_ctr *subkeys)
+static bool regdb_subkeys_need_update(struct regsubkey_ctr *subkeys)
 {
         return (regdb_get_seqnum() != regsubkey_ctr_get_seqnum(subkeys));
 }
 
-bool regdb_values_need_update(struct regval_ctr *values)
+static bool regdb_values_need_update(struct regval_ctr *values)
 {
         return (regdb_get_seqnum() != regval_ctr_get_seqnum(values));

vendor/current/source3/registry/reg_backend_db.h

@@ -33 +33 @@
 WERROR regdb_transaction_cancel(void);
 int regdb_get_seqnum(void);
-bool regdb_store_keys(const char *key, struct regsubkey_ctr *ctr);
-int regdb_fetch_keys(const char *key, struct regsubkey_ctr *ctr);
-int regdb_fetch_values(const char* key, struct regval_ctr *values);
-bool regdb_store_values(const char *key, struct regval_ctr *values);
-bool regdb_subkeys_need_update(struct regsubkey_ctr *subkeys);
-bool regdb_values_need_update(struct regval_ctr *values);
 
 #endif /* _REG_BACKEND_DB_H */

vendor/current/source3/registry/reg_backend_hkpt_params.c

@@ -37 +37 @@
 static int hkpt_params_fetch_values(const char *key, struct regval_ctr *regvals)
 {
-        uint32 base_index;
-        uint32 buffer_size;
+        uint32_t base_index;
+        uint32_t buffer_size;
         char *buffer = NULL;
 
@@ -46 +46 @@
         base_index = reg_perfcount_get_base_index();
         buffer_size = reg_perfcount_get_counter_names(base_index, &buffer);
-        regval_ctr_addvalue(regvals, "Counters", REG_MULTI_SZ, (uint8 *)buffer,
+        regval_ctr_addvalue(regvals, "Counters", REG_MULTI_SZ, (uint8_t *)buffer,
                             buffer_size);
 
@@ -54 +54 @@
 
         buffer_size = reg_perfcount_get_counter_help(base_index, &buffer);
-        regval_ctr_addvalue(regvals, "Help", REG_MULTI_SZ, (uint8 *)buffer, buffer_size);
+        regval_ctr_addvalue(regvals, "Help", REG_MULTI_SZ, (uint8_t *)buffer, buffer_size);
         if(buffer_size > 0) {
                 SAFE_FREE(buffer);

vendor/current/source3/registry/reg_backend_netlogon_params.c

@@ -37 +37 @@
 static int netlogon_params_fetch_values(const char *key, struct regval_ctr *regvals)
 {
-        uint32 dwValue;
+        uint32_t dwValue;
 
         if (!pdb_get_account_policy(PDB_POLICY_REFUSE_MACHINE_PW_CHANGE, &dwValue)) {

vendor/current/source3/registry/reg_backend_printing.c

@@ -24 +24 @@
 #include "registry.h"
 #include "reg_util_internal.h"
-#include "reg_backend_db.h"
 
 #undef DBGC_CLASS
 #define DBGC_CLASS DBGC_REGISTRY
+
+extern struct registry_ops regdb_ops;
 
 /* registry paths used in the print_registry[] */
@@ -89 +90 @@
         if (printers_key == NULL) {
                 /* normalize on the 'HKLM\SOFTWARE\....\Print\Printers' key */
-                return regdb_fetch_keys(KEY_WINNT_PRINTERS, subkeys);
-        }
-
-        return regdb_fetch_keys(printers_key, subkeys);
+                return regdb_ops.fetch_subkeys(KEY_WINNT_PRINTERS, subkeys);
+        }
+
+        return regdb_ops.fetch_subkeys(printers_key, subkeys);
 }
 
@@ -106 +107 @@
         if (printers_key == NULL) {
                 /* normalize on the 'HKLM\SOFTWARE\....\Print\Printers' key */
-                return regdb_store_keys(KEY_WINNT_PRINTERS, subkeys);
-        }
-
-        return regdb_store_keys(printers_key, subkeys);
+                return regdb_ops.store_subkeys(KEY_WINNT_PRINTERS, subkeys);
+        }
+
+        return regdb_ops.store_subkeys(printers_key, subkeys);
 }
 
@@ -123 +124 @@
         if (printers_key == NULL) {
                 /* normalize on the 'HKLM\SOFTWARE\....\Print\Printers' key */
-                return regdb_fetch_values(KEY_WINNT_PRINTERS, values);
-        }
-
-        return regdb_fetch_values(printers_key, values);
+                return regdb_ops.fetch_values(KEY_WINNT_PRINTERS, values);
+        }
+
+        return regdb_ops.fetch_values(printers_key, values);
 }
 
@@ -140 +141 @@
         if (printers_key == NULL) {
                 /* normalize on the 'HKLM\SOFTWARE\....\Print\Printers' key */
-                return regdb_store_values(KEY_WINNT_PRINTERS, values);
-        }
-
-        return regdb_store_values(printers_key, values);
+                return regdb_ops.store_values(KEY_WINNT_PRINTERS, values);
+        }
+
+        return regdb_ops.store_values(printers_key, values);
 }
 

vendor/current/source3/registry/reg_backend_shares.c

@@ -39 +39 @@
 {
         const char *p;
-        uint16 key_len = strlen(KEY_SHARES);
+        uint16_t key_len = strlen(KEY_SHARES);
 
         /* 

vendor/current/source3/registry/reg_backend_smbconf.c

@@ -43 +43 @@
 }
 
-static WERROR smbconf_delete_subkey(const char *key, const char *subkey)
+static WERROR smbconf_delete_subkey(const char *key, const char *subkey, bool lazy)
 {
-        return regdb_ops.delete_subkey(key, subkey);
+        return regdb_ops.delete_subkey(key, subkey, lazy);
 }
 
@@ -58 +58 @@
 }
 
-static bool smbconf_reg_access_check(const char *keyname, uint32 requested,
-                                     uint32 *granted,
+static bool smbconf_reg_access_check(const char *keyname, uint32_t requested,
+                                     uint32_t *granted,
                                      const struct security_token *token)
 {

vendor/current/source3/registry/reg_cachehook.c

@@ -94 +94 @@
                    (void *)ops, key));
 
-        werr = pathtree_add(cache_tree, key, ops);
+        if (!pathtree_add(cache_tree, key, ops))
+                werr = WERR_NOMEM;
+        else
+                werr = WERR_OK;
 
 done:

vendor/current/source3/registry/reg_db.h

@@ -22 +22 @@
 
 #define REG_TDB_FLAGS   TDB_SEQNUM
+#define REG_DBWRAP_FLAGS DBWRAP_FLAG_NONE
 
-#define REGVER_V1       1       /* first db version with write support */
-#define REGVER_V2       2       /* version 2 with normalized keys */
+#define REGDB_VERSION_V1    1  /* first db version with write support */
+#define REGDB_VERSION_V2    2  /* version 2 with normalized keys */
+#define REGDB_VERSION_V3    3  /* different definition of key existence, */
+                               /* sorted subkeys cache removed. */
+
+#define REGDB_CODE_VERSION REGDB_VERSION_V3
 
 #define REG_VALUE_PREFIX    "SAMBA_REGVAL"

vendor/current/source3/registry/reg_dispatcher.c

@@ -25 +25 @@
 
 #include "includes.h"
+#include "system/passwd.h" /* uid_wrapper */
 #include "registry.h"
 #include "reg_dispatcher.h"
@@ -114 +115 @@
 }
 
-WERROR delete_reg_subkey(struct registry_key_handle *key, const char *subkey)
+WERROR delete_reg_subkey(struct registry_key_handle *key, const char *subkey, bool lazy)
 {
         if (key->ops && key->ops->delete_subkey) {
-                return key->ops->delete_subkey(key->name, subkey);
+                return key->ops->delete_subkey(key->name, subkey, lazy);
         }
 
@@ -161 +162 @@
  ***********************************************************************/
 
-bool regkey_access_check(struct registry_key_handle *key, uint32 requested,
-                         uint32 *granted,
+bool regkey_access_check(struct registry_key_handle *key, uint32_t requested,
+                         uint32_t *granted,
                          const struct security_token *token )
 {
@@ -170 +171 @@
 
         /* root free-pass, like we have on all other pipes like samr, lsa, etc. */
-        if (geteuid() == sec_initial_uid()) {
+        if (root_mode()) {
                 *granted = REG_KEY_ALL;
                 return true;
@@ -244 +245 @@
         }
 
-        return false;
+        return true;
 }
 
@@ -259 +260 @@
         }
 
-        return false;
-}
-
+        return true;
+}
+

vendor/current/source3/registry/reg_dispatcher.h

@@ -26 +26 @@
 bool store_reg_values(struct registry_key_handle *key, struct regval_ctr *val);
 WERROR create_reg_subkey(struct registry_key_handle *key, const char *subkey);
-WERROR delete_reg_subkey(struct registry_key_handle *key, const char *subkey);
+WERROR delete_reg_subkey(struct registry_key_handle *key, const char *subkey, bool lazy);
 int fetch_reg_keys(struct registry_key_handle *key,
                    struct regsubkey_ctr *subkey_ctr);
 int fetch_reg_values(struct registry_key_handle *key, struct regval_ctr *val);
-bool regkey_access_check(struct registry_key_handle *key, uint32 requested,
-                         uint32 *granted,
+bool regkey_access_check(struct registry_key_handle *key, uint32_t requested,
+                         uint32_t *granted,
                          const struct security_token *token);
 WERROR regkey_get_secdesc(TALLOC_CTX *mem_ctx, struct registry_key_handle *key,

vendor/current/source3/registry/reg_format.c

@@ -94 +94 @@
 {
         if (fmt->hive_fmt != FMT_HIVE_PRESERVE) {
-                const struct hive_info* hinfo = hive_info(hive, len);
+                const struct hive_info* hinfo = hive_info(hive);
                 if (hinfo == NULL) {
                         DEBUG(0, ("Unknown hive %*s", len, hive));
@@ -568 +568 @@
                             bool del)
 {
-        return reg_format_key(f, (const char**)&key->key->name, 1, del);
+        const char *knames[1];
+        knames[0] = key->key->name;
+        return reg_format_key(f, knames, 1, del);
 }
 

vendor/current/source3/registry/reg_import.c

@@ -29 +29 @@
 static const int TL = 2;
 
-struct reg_import
-{
+struct reg_import {
         struct reg_parse_callback reg_parse_callback;
         struct reg_import_callback call;
-        void* open_key;
+        void *open_key;
 };
 
-static int
-reg_parse_callback_key(struct reg_import* cb_private,
-                       const char* key[], size_t n,
-                       bool del);
-
-static int
-reg_parse_callback_val(struct reg_import* cb_private,
-                       const char* name, uint32_t type,
-                       const uint8_t* data, uint32_t len);
-
-static int
-reg_parse_callback_val_registry_value(struct reg_import* cb_private,
-                                      const char* name, uint32_t type,
-                                      const uint8_t* data, uint32_t len);
-
-static int
-reg_parse_callback_val_regval_blob(struct reg_import* cb_private,
-                                   const char* name, uint32_t type,
-                                   const uint8_t* data, uint32_t len);
-
-static int
-reg_parse_callback_val_del(struct reg_import* cb_private,
-                           const char* name);
-
-static int
-reg_parse_callback_comment(struct reg_import* cb_private,
-                           const char* txt);
+static int reg_parse_callback_key(struct reg_import *cb_private,
+                                  const char *key[], size_t n, bool del);
+
+static int reg_parse_callback_val(struct reg_import *cb_private,
+                                  const char *name, uint32_t type,
+                                  const uint8_t *data, uint32_t len);
+
+static int reg_parse_callback_val_registry_value(struct reg_import *cb_private,
+                                                 const char *name,
+                                                 uint32_t type,
+                                                 const uint8_t *data,
+                                                 uint32_t len);
+
+static int reg_parse_callback_val_regval_blob(struct reg_import *cb_private,
+                                              const char *name, uint32_t type,
+                                              const uint8_t *data,
+                                              uint32_t len);
+
+static int reg_parse_callback_val_del(struct reg_import *cb_private,
+                                      const char *name);
+
+static int reg_parse_callback_comment(struct reg_import *cb_private,
+                                      const char *txt);
 
 
 /*******************************************************************************/
 
-int reg_parse_callback_key(struct reg_import* p,
-                           const char* key[], size_t n, bool del)
+int reg_parse_callback_key(struct reg_import *p,
+                           const char *key[], size_t n, bool del)
 {
         WERROR werr = WERR_OK;
@@ -74 +69 @@
         DEBUG(TL, ("%s: %s\n", __FUNCTION__, key[0]));
 
-        if (p->open_key != NULL ) {
+        if (p->open_key != NULL) {
                 werr = p->call.closekey(p->call.data, p->open_key);
+                p->open_key = NULL;
                 if (!W_ERROR_IS_OK(werr)) {
                         DEBUG(0, ("closekey failed: %s\n", win_errstr(werr)));
@@ -91 +87 @@
                                   key[0], win_errstr(werr)));
                 }
-        }
-        else {
+        } else {
                 bool existing;
                 werr = p->call.createkey(p->call.data, NULL, key[0],
@@ -122 +117 @@
 
 /*----------------------------------------------------------------------------*/
-int reg_parse_callback_val(struct reg_import* p,
-                           const char* name, uint32_t type,
-                           const uint8_t* data, uint32_t len)
+int reg_parse_callback_val(struct reg_import *p,
+                           const char *name, uint32_t type,
+                           const uint8_t *data, uint32_t len)
 {
         WERROR werr = WERR_OK;
@@ -142 +137 @@
 
 /*----------------------------------------------------------------------------*/
-int reg_parse_callback_val_registry_value(struct reg_import* p,
-                                          const char* name, uint32_t type,
-                                          const uint8_t* data, uint32_t len)
+int reg_parse_callback_val_registry_value(struct reg_import *p,
+                                          const char *name, uint32_t type,
+                                          const uint8_t *data, uint32_t len)
 {
         WERROR werr = WERR_OK;
@@ -167 +162 @@
 
 /*----------------------------------------------------------------------------*/
-int reg_parse_callback_val_regval_blob(struct reg_import* p,
-                                       const char* name, uint32_t type,
-                                       const uint8_t* data, uint32_t len)
+int reg_parse_callback_val_regval_blob(struct reg_import *p,
+                                       const char *name, uint32_t type,
+                                       const uint8_t *data, uint32_t len)
 {
         WERROR werr = WERR_OK;
         void* mem_ctx = talloc_new(p);
-        struct regval_blob* v = NULL;
+        struct regval_blob *v = NULL;
 
         DEBUG(TL, ("%s(%x): >%s< = [%x]\n", __FUNCTION__, type, name, len));
@@ -200 +195 @@
 /*----------------------------------------------------------------------------*/
 
-int reg_parse_callback_val_del(struct reg_import* p,
-                               const char* name)
+int reg_parse_callback_val_del(struct reg_import *p,
+                               const char *name)
 {
         WERROR werr = WERR_OK;
@@ -217 +212 @@
 
 
-int reg_parse_callback_comment(struct reg_import* cb_private,
-                               const char* txt)
+int reg_parse_callback_comment(struct reg_import *cb_private,
+                               const char *txt)
 {
         DEBUG(TL, ("%s: %s\n", __FUNCTION__, txt));
@@ -225 +220 @@
 
 /******************************************************************************/
-static int nop(void* data)
+static int nop(void *data)
 {
         return 0;
@@ -231 +226 @@
 
 
-struct reg_parse_callback* reg_import_adapter(const void* talloc_ctx,
+struct reg_parse_callback *reg_import_adapter(TALLOC_CTX *talloc_ctx,
                                               struct reg_import_callback cb)
 {
-        struct reg_parse_callback* ret;
-        struct reg_import* p = talloc_zero(talloc_ctx, struct reg_import);
+        struct reg_parse_callback *ret;
+        struct reg_import *p = talloc_zero(talloc_ctx, struct reg_import);
         if (p == NULL) {
                 goto fail;
         }
-        if (cb.openkey == NULL ) {
+        if (cb.openkey == NULL) {
                 cb.openkey = (reg_import_callback_openkey_t)&nop;
         }
-        if (cb.closekey == NULL ) {
+        if (cb.closekey == NULL) {
                 cb.closekey = (reg_import_callback_closekey_t)&nop;
         }
-        if (cb.createkey == NULL ) {
+        if (cb.createkey == NULL) {
                 cb.createkey = (reg_import_callback_createkey_t)&nop;
         }
-        if (cb.deletekey == NULL ) {
+        if (cb.deletekey == NULL) {
                 cb.deletekey = (reg_import_callback_deletekey_t)&nop;
         }
-        if (cb.deleteval == NULL ) {
+        if (cb.deleteval == NULL) {
                 cb.deleteval = (reg_import_callback_deleteval_t)&nop;
         }
@@ -283 +278 @@
         }
 
-        assert((struct reg_parse_callback*)p == ret);
+        assert((struct reg_parse_callback *)p == ret);
         return ret;
 fail:

vendor/current/source3/registry/reg_import.h

@@ -195 +195 @@
  * @return a talloc'ed reg_import object, NULL on error
  */
-struct reg_parse_callback* reg_import_adapter(const void* talloc_ctx,
+struct reg_parse_callback* reg_import_adapter(TALLOC_CTX *talloc_ctx,
                                               struct reg_import_callback cb);
 #endif

vendor/current/source3/registry/reg_init_full.c

@@ -70 +70 @@
 /***********************************************************************
  Open the registry database and initialize the registry_hook cache
- with all available backens.
+ with all available backends.
  ***********************************************************************/
 

vendor/current/source3/registry/reg_objects.c

@@ -25 +25 @@
 #include "reg_objects.h"
 #include "util_tdb.h"
-#include "dbwrap.h"
+#include "dbwrap/dbwrap.h"
+#include "dbwrap/dbwrap_rbt.h"
 #include "../libcli/registry/util_reg.h"
 
@@ -63 +64 @@
 
  There is no longer a regval_ctr_intit() and regval_ctr_destroy()
- pair of functions.  Simply TALLOC_ZERO_P() and TALLOC_FREE() the
+ pair of functions.  Simply talloc_zero() and TALLOC_FREE() the
  object.
 
@@ -170 +171 @@
 {
         TDB_DATA data;
+        NTSTATUS status;
 
         if ((ctr == NULL) || (keyname == NULL)) {
@@ -175 +177 @@
         }
 
-        data = dbwrap_fetch_bystring_upper(ctr->subkeys_hash, ctr, keyname);
-        if (data.dptr == NULL) {
+        status = dbwrap_fetch_bystring_upper(ctr->subkeys_hash, ctr, keyname,
+                                             &data);
+        if (!NT_STATUS_IS_OK(status)) {
                 return WERR_NOT_FOUND;
         }
@@ -186 +189 @@
 
         if (idx != NULL) {
-                *idx = *(uint32_t *)data.dptr;
+                memcpy(idx, data.dptr, sizeof(*idx));
         }
 
@@ -212 +215 @@
         }
 
-        if (!(newkeys = TALLOC_REALLOC_ARRAY(ctr, ctr->subkeys, char *,
+        if (!(newkeys = talloc_realloc(ctr, ctr->subkeys, char *,
                                              ctr->num_subkeys+1))) {
                 return WERR_NOMEM;
@@ -302 +305 @@
 
 /***********************************************************************
- Retreive a specific key string
+ Retrieve a specific key string
  **********************************************************************/
 
@@ -343 +346 @@
 }
 
-/***********************************************************************
- allocate memory for and duplicate a struct regval_blob.
- This is malloc'd memory so the caller should free it when done
- **********************************************************************/
-
-struct regval_blob* dup_registry_value(struct regval_blob *val)
-{
-        struct regval_blob *copy = NULL;
-
-        if ( !val )
-                return NULL;
-
-        if ( !(copy = SMB_MALLOC_P( struct regval_blob)) ) {
-                DEBUG(0,("dup_registry_value: malloc() failed!\n"));
-                return NULL;
-        }
-
-        /* copy all the non-pointer initial data */
-
-        memcpy( copy, val, sizeof(struct regval_blob) );
-
-        copy->size = 0;
-        copy->data_p = NULL;
-
-        if ( val->data_p && val->size )
-        {
-                if ( !(copy->data_p = (uint8_t *)memdup( val->data_p,
-                                                       val->size )) ) {
-                        DEBUG(0,("dup_registry_value: memdup() failed for [%d] "
-                                 "bytes!\n", val->size));
-                        SAFE_FREE( copy );
-                        return NULL;
-                }
-                copy->size = val->size;
-        }
-
-        return copy;
-}
-
-/**********************************************************************
- free the memory allocated to a struct regval_blob
- *********************************************************************/
-
-void free_registry_value(struct regval_blob *val)
-{
-        if ( !val )
-                return;
-
-        SAFE_FREE( val->data_p );
-        SAFE_FREE( val );
-
-        return;
-}
-
 /**********************************************************************
  *********************************************************************/
@@ -430 +379 @@
 
 /***********************************************************************
- Retreive a pointer to a specific value.  Caller shoud dup the structure
+ Retrieve a pointer to a specific value.  Caller shoud dup the structure
  since this memory will go away when the ctr is free()'d
  **********************************************************************/
@@ -467 +416 @@
         int i;
 
-        for (i=0; i<ctr->num_values; i++) {
-                if (strequal(ctr->values[i]->valuename,value)) {
+        for (i = 0; i < ctr->num_values; i++) {
+                if (strequal(ctr->values[i]->valuename, value)) {
                         return ctr->values[i];
                 }
@@ -485 +434 @@
                                    const uint8_t *data_p, size_t size)
 {
-        struct regval_blob *regval = TALLOC_P(ctx, struct regval_blob);
+        struct regval_blob *regval = talloc(ctx, struct regval_blob);
 
         if (regval == NULL) {
@@ -494 +443 @@
         regval->type = type;
         if (size) {
-                regval->data_p = (uint8_t *)TALLOC_MEMDUP(regval, data_p, size);
+                regval->data_p = (uint8_t *)talloc_memdup(regval, data_p, size);
                 if (!regval->data_p) {
                         TALLOC_FREE(regval);
@@ -524 +473 @@
 
         if (  ctr->num_values == 0 ) {
-                ctr->values = TALLOC_P( ctr, struct regval_blob *);
+                ctr->values = talloc( ctr, struct regval_blob *);
         } else {
-                ctr->values = TALLOC_REALLOC_ARRAY(ctr, ctr->values,
+                ctr->values = talloc_realloc(ctr, ctr->values,
                                                    struct regval_blob *,
                                                    ctr->num_values+1);
@@ -664 +613 @@
         return WERR_OK;
 }
-
-/***********************************************************************
- return the data_p as a uint32_t
- **********************************************************************/
-
-uint32_t regval_dword(struct regval_blob *val)
-{
-        uint32_t data;
-
-        data = IVAL( regval_data_p(val), 0 );
-
-        return data;
-}
-
-/***********************************************************************
- return the data_p as a character string
- **********************************************************************/
-
-const char *regval_sz(struct regval_blob *val)
-{
-        const char *data = NULL;
-        DATA_BLOB blob = data_blob_const(regval_data_p(val), regval_size(val));
-
-        pull_reg_sz(talloc_tos(), &blob, &data);
-
-        return data;
-}

vendor/current/source3/registry/reg_objects.h

@@ -48 +48 @@
 WERROR regval_ctr_init(TALLOC_CTX *mem_ctx, struct regval_ctr **ctr);
 int regval_ctr_numvals(struct regval_ctr *ctr);
-struct regval_blob* dup_registry_value(struct regval_blob *val);
-void free_registry_value(struct regval_blob *val);
 uint8_t* regval_data_p(struct regval_blob *val);
 uint32_t regval_size(struct regval_blob *val);
@@ -72 +70 @@
 int regval_ctr_get_seqnum(struct regval_ctr *ctr);
 WERROR regval_ctr_set_seqnum(struct regval_ctr *ctr, int seqnum);
-uint32_t regval_dword(struct regval_blob *val);
-const char *regval_sz(struct regval_blob *val);
 
 

vendor/current/source3/registry/reg_parse.c

@@ -35 +35 @@
 
 #include <stdio.h>
-#include <unistd.h>
-#include <wchar.h>
 #include <talloc.h>
 #include <stdbool.h>
 #include <string.h>
-#include <sys/types.h>
 #include <regex.h>
 #include <assert.h>
@@ -164 +161 @@
                 if (convert_string_talloc(p->valblob, CH_UNIX, CH_UTF16LE,
                                           src, strlen(src)+1,
-                                          &dst, &dlen, true))
+                                          &dst, &dlen))
                 {
                         cbuf_swapptr(p->valblob, &dst, dlen);
@@ -623 +620 @@
 
         size_t l = MIN(len/2, 64);
-        uint16_t* u = (uint16_t*)line;
+        const uint16_t* u = (const uint16_t*)line;
         int i;
 
@@ -937 +934 @@
         fd = open(fname, O_RDONLY);
         if (fd < 0) {
-                DEBUG(0, ("reg_parse_file: open failed: %s\n", strerror(errno)));
+                DEBUG(0, ("reg_parse_file: open %s failed: %s\n", fname,
+                          strerror(errno)));
                 return -1;
         }

vendor/current/source3/registry/reg_parse_internal.c

@@ -115 +115 @@
 #endif
 
-#define HIVE_INFO_ENTRY(SHORT,LONG)                     \
-static const struct hive_info HIVE_INFO_##SHORT = {     \
-        .handle = LONG,                                 \
-        .short_name = #SHORT,                           \
-        .short_name_len = sizeof(#SHORT)-1,             \
-        .long_name = #LONG,                             \
-        .long_name_len = sizeof(#LONG)-1,               \
+#define HIVE_INFO_ENTRY(SHORT,LONG)             \
+const struct hive_info HIVE_INFO_##SHORT = {    \
+        .handle = LONG,                         \
+        .short_name = #SHORT,                   \
+        .short_name_len = sizeof(#SHORT)-1,     \
+        .long_name = #LONG,                     \
+        .long_name_len = sizeof(#LONG)-1,       \
 }
 
@@ -135 +135 @@
 #undef HIVE_INFO_ENTRY
 
-static const struct hive_info* HIVE_INFO[] = {
+const struct hive_info* HIVE_INFO[] = {
         &HIVE_INFO_HKLM, &HIVE_INFO_HKCU, &HIVE_INFO_HKCR, &HIVE_INFO_HKU,
         &HIVE_INFO_HKCC, &HIVE_INFO_HKDD, &HIVE_INFO_HKPD, &HIVE_INFO_HKPT,
@@ -141 +141 @@
 };
 
-const struct hive_info* hive_info(const char* name, int nlen)
-{
-        const struct hive_info** info;
-        char buf[32];
-        int s;
-
-        if (nlen >= sizeof(buf)) {
-                return NULL;
-        }
-        for (s=0; s<nlen; s++) {
-                buf[s] = toupper(name[s]);
-        }
-        buf[s] = '\0';
-
-        if ((s < 3) || (strncmp(buf, "HK", 2) != 0)) {
-                return NULL;
-        }
-
-        if (s <= 4) {
-                for(info = HIVE_INFO; *info; info++) {
-                        if (strcmp(buf+2, (*info)->short_name+2) == 0) {
-                                return *info;
+#define TOINT(A,B) ((int)(A) << 8) + (int)(B)
+
+bool srprs_hive(const char** ptr, const struct hive_info** result)
+{
+        const char* str = *ptr;
+        const struct hive_info* info = NULL;
+        bool long_hive = false;
+
+        if ((toupper(str[0]) != 'H') || (toupper(str[1]) != 'K')
+            || (str[2] == '\0') )
+        {
+                return false;
+        }
+
+        switch ( TOINT(toupper(str[2]), toupper(str[3])) ) {
+        case TOINT('E', 'Y'):
+                if (str[4] == '_') {
+                        int i;
+                        for (i=0; (info = HIVE_INFO[i]); i++) {
+                                if (strncmp(&str[5], &info->long_name[5],
+                                            info->long_name_len-5) == 0)
+                                {
+                                        long_hive = true;
+                                        break;
+                                }
                         }
                 }
-                return NULL;
-        }
-
-        if ((s < 10) || (strncmp(buf, "HKEY_", 5)) != 0) {
-                return NULL;
-        }
-
-        for(info = HIVE_INFO; *info; info++) {
-                if (strcmp(buf+5, (*info)->long_name+5) == 0) {
-                        return *info;
-                }
-        }
-        return NULL;
+                break;
+        case TOINT('L', 'M'):
+                info = &HIVE_INFO_HKLM;
+                break;
+        case TOINT('C', 'U'):
+                info = &HIVE_INFO_HKCU;
+                break;
+        case TOINT('C', 'R'):
+                info = &HIVE_INFO_HKCR;
+                break;
+        case TOINT('C', 'C'):
+                info = &HIVE_INFO_HKCC;
+                break;
+        case TOINT('D', 'D'):
+                info = &HIVE_INFO_HKDD;
+                break;
+        case TOINT('P', 'D'):
+                info = &HIVE_INFO_HKPD;
+                break;
+        case TOINT('P', 'T'):
+                info = &HIVE_INFO_HKPT;
+                break;
+        case TOINT('P', 'N'):
+                info = &HIVE_INFO_HKPN;
+                break;
+        default:
+                if (toupper(str[2]) == 'U') {
+                        info = &HIVE_INFO_HKU;
+                }
+                break;
+        }
+        if (info != NULL) {
+                if (result != NULL) {
+                        *result = info;
+                }
+                *ptr += long_hive ? info->long_name_len : info->short_name_len;
+                return true;
+        }
+        return false;
+}
+
+const struct hive_info* hive_info(const char* name)
+{
+        const struct hive_info* info = NULL;
+        srprs_hive(&name, &info);
+        return info;
 }
 
@@ -265 +301 @@
         charset_t ctype;
         int  len;
-        char seq[4];
+        uint8_t seq[4];
 } BOM[] = {
         {"UTF-8",    CH_UTF8,    3, {0xEF, 0xBB, 0xBF}},
@@ -314 +350 @@
         } else {
                 for (i=0; BOM[i].name; i++) {
-                        if (StrCaseCmp(BOM[i].name, charset) == 0) {
+                        if (strcasecmp_m(BOM[i].name, charset) == 0) {
                                 return fwrite(BOM[i].seq, 1, BOM[i].len, file);
                         }

vendor/current/source3/registry/reg_parse_internal.h

@@ -39 +39 @@
 #  define smb_iconv_t     iconv_t
 #  define smb_iconv(CD, IPTR, ILEN, OPTR, OLEN) \
-        iconv(CD, (char**)(IPTR), ILEN, OPTR, OLEN)
+        iconv(CD, discard_const_p(char*, (IPTR)), ILEN, OPTR, OLEN)
 #  define smb_iconv_open  iconv_open
 #  define smb_iconv_close iconv_close
@@ -57 +57 @@
 };
 
-const struct hive_info* hive_info(const char* name, int nlen);
+extern const struct hive_info HIVE_INFO_HKLM;
+extern const struct hive_info HIVE_INFO_HKCU;
+extern const struct hive_info HIVE_INFO_HKCR;
+extern const struct hive_info HIVE_INFO_HKU;
+extern const struct hive_info HIVE_INFO_HKCC;
+extern const struct hive_info HIVE_INFO_HKDD;
+extern const struct hive_info HIVE_INFO_HKPD;
+extern const struct hive_info HIVE_INFO_HKPT;
+extern const struct hive_info HIVE_INFO_HKPN;
+
+extern const struct hive_info* HIVE_INFO[];
+
+const struct hive_info* hive_info(const char* name);
+bool srprs_hive(const char** ptr, const struct hive_info** result);
+
+
 
 const char* get_charset(const char* c);

vendor/current/source3/registry/reg_parse_prs.c

@@ -49 +49 @@
  **/
 
-bool prs_init(prs_struct *ps, uint32 size, TALLOC_CTX *ctx, bool io)
+bool prs_init(prs_struct *ps, uint32_t size, TALLOC_CTX *ctx, bool io)
 {
         ZERO_STRUCTP(ps);
@@ -132 +132 @@
  ********************************************************************/
 
-bool prs_grow(prs_struct *ps, uint32 extra_space)
-{
-        uint32 new_size;
+bool prs_grow(prs_struct *ps, uint32_t extra_space)
+{
+        uint32_t new_size;
 
         ps->grow_size = MAX(ps->grow_size, ps->data_offset + extra_space);
@@ -210 +210 @@
  ********************************************************************/
 
-uint32 prs_data_size(prs_struct *ps)
+uint32_t prs_data_size(prs_struct *ps)
 {
         return ps->buffer_size;
@@ -219 +219 @@
  ********************************************************************/
 
-uint32 prs_offset(prs_struct *ps)
+uint32_t prs_offset(prs_struct *ps)
 {
         return ps->data_offset;
@@ -228 +228 @@
  ********************************************************************/
 
-bool prs_set_offset(prs_struct *ps, uint32 offset)
+bool prs_set_offset(prs_struct *ps, uint32_t offset)
 {
         if ((offset > ps->data_offset)
@@ -243 +243 @@
  ********************************************************************/
 
-bool prs_copy_data_in(prs_struct *dst, const char *src, uint32 len)
+bool prs_copy_data_in(prs_struct *dst, const char *src, uint32_t len)
 {
         if (len == 0)
@@ -264 +264 @@
 bool prs_align(prs_struct *ps)
 {
-        uint32 mod = ps->data_offset & (ps->align-1);
+        uint32_t mod = ps->data_offset & (ps->align-1);
 
         if (ps->align != 0 && mod != 0) {
-                uint32 extra_space = (ps->align - mod);
+                uint32_t extra_space = (ps->align - mod);
                 if(!prs_grow(ps, extra_space))
                         return False;
@@ -284 +284 @@
 {
         bool ret;
-        uint8 old_align = ps->align;
+        uint8_t old_align = ps->align;
 
         ps->align = 8;
@@ -297 +297 @@
  ********************************************************************/
 
-char *prs_mem_get(prs_struct *ps, uint32 extra_size)
+char *prs_mem_get(prs_struct *ps, uint32_t extra_size)
 {
         if(UNMARSHALLING(ps)) {
@@ -331 +331 @@
 
 /*******************************************************************
- Stream a uint8.
- ********************************************************************/
-
-bool prs_uint8(const char *name, prs_struct *ps, int depth, uint8 *data8)
-{
-        char *q = prs_mem_get(ps, 1);
-        if (q == NULL)
-                return False;
-
-        if (UNMARSHALLING(ps))
-                *data8 = CVAL(q,0);
-        else
-                SCVAL(q,0,*data8);
-
-        DEBUGADD(5,("%s%04x %s: %02x\n", tab_depth(5,depth), ps->data_offset, name, *data8));
-
-        ps->data_offset += 1;
-
-        return True;
-}
-
-/*******************************************************************
  Stream a uint16.
  ********************************************************************/
 
-bool prs_uint16(const char *name, prs_struct *ps, int depth, uint16 *data16)
-{
-        char *q = prs_mem_get(ps, sizeof(uint16));
+bool prs_uint16(const char *name, prs_struct *ps, int depth, uint16_t *data16)
+{
+        char *q = prs_mem_get(ps, sizeof(uint16_t));
         if (q == NULL)
                 return False;
@@ -376 +354 @@
         DEBUGADD(5,("%s%04x %s: %04x\n", tab_depth(5,depth), ps->data_offset, name, *data16));
 
-        ps->data_offset += sizeof(uint16);
+        ps->data_offset += sizeof(uint16_t);
 
         return True;
@@ -385 +363 @@
  ********************************************************************/
 
-bool prs_uint32(const char *name, prs_struct *ps, int depth, uint32 *data32)
-{
-        char *q = prs_mem_get(ps, sizeof(uint32));
+bool prs_uint32(const char *name, prs_struct *ps, int depth, uint32_t *data32)
+{
+        char *q = prs_mem_get(ps, sizeof(uint32_t));
         if (q == NULL)
                 return False;
@@ -405 +383 @@
         DEBUGADD(5,("%s%04x %s: %08x\n", tab_depth(5,depth), ps->data_offset, name, *data32));
 
-        ps->data_offset += sizeof(uint32);
+        ps->data_offset += sizeof(uint32_t);
 
         return True;
@@ -413 +391 @@
  Stream a uint64_struct
  ********************************************************************/
-bool prs_uint64(const char *name, prs_struct *ps, int depth, uint64 *data64)
+bool prs_uint64(const char *name, prs_struct *ps, int depth, uint64_t *data64)
 {
         if (UNMARSHALLING(ps)) {
-                uint32 high, low;
+                uint32_t high, low;
 
                 if (!prs_uint32(name, ps, depth+1, &low))
@@ -428 +406 @@
                 return True;
         } else {
-                uint32 high = (*data64) >> 32, low = (*data64) & 0xFFFFFFFF;
+                uint32_t high = (*data64) >> 32, low = (*data64) & 0xFFFFFFFF;
                 return prs_uint32(name, ps, depth+1, &low) &&
                            prs_uint32(name, ps, depth+1, &high);
@@ -438 +416 @@
  ********************************************************************/
 
-bool prs_uint8s(bool charmode, const char *name, prs_struct *ps, int depth, uint8 *data8s, int len)
+bool prs_uint8s(bool charmode, const char *name, prs_struct *ps, int depth, uint8_t *data8s, int len)
 {
         int i;

vendor/current/source3/registry/reg_parse_prs.h

@@ -34 +34 @@
          */
         bool bigendian_data;
-        uint8 align; /* data alignment */
+        uint8_t align; /* data alignment */
         bool is_dynamic; /* Do we own this memory or not ? */
-        uint32 data_offset; /* Current working offset into data. */
-        uint32 buffer_size; /* Current allocated size of the buffer. */
-        uint32 grow_size; /* size requested via prs_grow() calls */
+        uint32_t data_offset; /* Current working offset into data. */
+        uint32_t buffer_size; /* Current allocated size of the buffer. */
+        uint32_t grow_size; /* size requested via prs_grow() calls */
         /* The buffer itself. If "is_dynamic" is true this
          * MUST BE TALLOC'ed off mem_ctx. */
@@ -58 +58 @@
 
 void prs_debug(prs_struct *ps, int depth, const char *desc, const char *fn_name);
-bool prs_init(prs_struct *ps, uint32 size, TALLOC_CTX *ctx, bool io);
+bool prs_init(prs_struct *ps, uint32_t size, TALLOC_CTX *ctx, bool io);
 void prs_mem_free(prs_struct *ps);
 char *prs_alloc_mem_(prs_struct *ps, size_t size, unsigned int count);
 char *prs_alloc_mem(prs_struct *ps, size_t size, unsigned int count);
 TALLOC_CTX *prs_get_mem_context(prs_struct *ps);
-bool prs_grow(prs_struct *ps, uint32 extra_space);
+bool prs_grow(prs_struct *ps, uint32_t extra_space);
 char *prs_data_p(prs_struct *ps);
-uint32 prs_data_size(prs_struct *ps);
-uint32 prs_offset(prs_struct *ps);
-bool prs_set_offset(prs_struct *ps, uint32 offset);
-bool prs_copy_data_in(prs_struct *dst, const char *src, uint32 len);
+uint32_t prs_data_size(prs_struct *ps);
+uint32_t prs_offset(prs_struct *ps);
+bool prs_set_offset(prs_struct *ps, uint32_t offset);
+bool prs_copy_data_in(prs_struct *dst, const char *src, uint32_t len);
 bool prs_align(prs_struct *ps);
 bool prs_align_uint64(prs_struct *ps);
-char *prs_mem_get(prs_struct *ps, uint32 extra_size);
+char *prs_mem_get(prs_struct *ps, uint32_t extra_size);
 void prs_switch_type(prs_struct *ps, bool io);
-bool prs_uint8(const char *name, prs_struct *ps, int depth, uint8 *data8);
-bool prs_uint16(const char *name, prs_struct *ps, int depth, uint16 *data16);
-bool prs_uint32(const char *name, prs_struct *ps, int depth, uint32 *data32);
-bool prs_uint64(const char *name, prs_struct *ps, int depth, uint64 *data64);
-bool prs_uint8s(bool charmode, const char *name, prs_struct *ps, int depth, uint8 *data8s, int len);
+bool prs_uint16(const char *name, prs_struct *ps, int depth, uint16_t *data16);
+bool prs_uint32(const char *name, prs_struct *ps, int depth, uint32_t *data32);
+bool prs_uint64(const char *name, prs_struct *ps, int depth, uint64_t *data64);
+bool prs_uint8s(bool charmode, const char *name, prs_struct *ps, int depth, uint8_t *data8s, int len);
 
 #endif

vendor/current/source3/registry/reg_perfcount.c

@@ -42 +42 @@
 *********************************************************************/
 
+/* returns perfcount path for dbname allocated on talloc_tos */
 static char *counters_directory(const char *dbname)
 {
-        char *path = NULL;
+        char *dir_path = NULL;
+        char *db_subpath = NULL;
         char *ret = NULL;
-        TALLOC_CTX *ctx = talloc_tos();
-
-        path = state_path(PERFCOUNTDIR);
-        if (!directory_exist(path)) {
-                mkdir(path, 0755);
-        }
-
-        path = talloc_asprintf(ctx, "%s/%s", PERFCOUNTDIR, dbname);
-        if (!path) {
+
+        dir_path = state_path(PERFCOUNTDIR);
+        if (dir_path == NULL) {
                 return NULL;
         }
 
-        ret = talloc_strdup(ctx, state_path(path));
-        TALLOC_FREE(path);
+        if (!directory_create_or_exist(dir_path, 0755)) {
+                TALLOC_FREE(dir_path);
+                return NULL;
+        }
+
+        db_subpath = talloc_asprintf(dir_path, "%s/%s", PERFCOUNTDIR, dbname);
+        if (db_subpath == NULL) {
+                TALLOC_FREE(dir_path);
+                return NULL;
+        }
+
+        ret = state_path(db_subpath);
+        TALLOC_FREE(dir_path);
         return ret;
 }
@@ -66 +73 @@
 *********************************************************************/
 
-uint32 reg_perfcount_get_base_index(void)
-{
-        const char *fname = counters_directory( NAMES_DB );
+uint32_t reg_perfcount_get_base_index(void)
+{
+        char *fname;
         TDB_CONTEXT *names;
         TDB_DATA kbuf, dbuf;
         char key[] = "1";
-        uint32 retval = 0;
+        uint32_t retval = 0;
         char buf[PERFCOUNT_MAX_LEN];
 
+        fname = counters_directory(NAMES_DB);
+        if (fname == NULL) {
+                return 0;
+        }
+
         names = tdb_open_log(fname, 0, TDB_DEFAULT, O_RDONLY, 0444);
 
         if ( !names ) {
-                DEBUG(1, ("reg_perfcount_get_base_index: unable to open [%s].\n", fname));
+                DEBUG(2, ("reg_perfcount_get_base_index: unable to open [%s].\n", fname));
+                TALLOC_FREE(fname);
                 return 0;
-        }    
+        }
         /* needs to read the value of key "1" from the counter_names.tdb file, as that is
            where the total number of counters is stored. We're assuming no holes in the
@@ -101 +114 @@
                 DEBUG(1, ("reg_perfcount_get_base_index: failed to find key \'1\' in [%s].\n", fname));
                 tdb_close(names);
+                TALLOC_FREE(fname);
                 return 0;
         }
-        else
-        {
-                tdb_close(names);
-                memset(buf, 0, PERFCOUNT_MAX_LEN);
-                memcpy(buf, dbuf.dptr, dbuf.dsize);
-                retval = (uint32)atoi(buf);
-                SAFE_FREE(dbuf.dptr);
-                return retval;
-        }
-        return 0;
-}
-
-/*********************************************************************
-*********************************************************************/
-
-uint32 reg_perfcount_get_last_counter(uint32 base_index)
-{
-        uint32 retval;
+
+        tdb_close(names);
+        TALLOC_FREE(fname);
+        memset(buf, 0, PERFCOUNT_MAX_LEN);
+        memcpy(buf, dbuf.dptr, dbuf.dsize);
+        retval = (uint32_t)atoi(buf);
+        SAFE_FREE(dbuf.dptr);
+        return retval;
+}
+
+/*********************************************************************
+*********************************************************************/
+
+uint32_t reg_perfcount_get_last_counter(uint32_t base_index)
+{
+        uint32_t retval;
 
         if(base_index == 0)
@@ -133 +145 @@
 *********************************************************************/
 
-uint32 reg_perfcount_get_last_help(uint32 last_counter)
-{
-        uint32 retval;
+uint32_t reg_perfcount_get_last_help(uint32_t last_counter)
+{
+        uint32_t retval;
 
         if(last_counter == 0)
@@ -149 +161 @@
 *********************************************************************/
 
-static uint32 _reg_perfcount_multi_sz_from_tdb(TDB_CONTEXT *tdb, 
+static uint32_t _reg_perfcount_multi_sz_from_tdb(TDB_CONTEXT *tdb,
                                                int keyval,
                                                char **retbuf,
-                                               uint32 buffer_size)
+                                               uint32_t buffer_size)
 {
         TDB_DATA kbuf, dbuf;
         char temp[256];
         char *buf1 = *retbuf;
-        uint32 working_size = 0;
+        uint32_t working_size = 0;
         DATA_BLOB name_index, name;
+        bool ok;
 
         memset(temp, 0, sizeof(temp));
@@ -173 +186 @@
         }
         /* First encode the name_index */
-        working_size = (kbuf.dsize + 1)*sizeof(uint16);
+        working_size = (kbuf.dsize + 1)*sizeof(uint16_t);
         buf1 = (char *)SMB_REALLOC(buf1, buffer_size + working_size);
         if(!buf1) {
@@ -179 +192 @@
                 return buffer_size;
         }
-        push_reg_sz(talloc_tos(), &name_index, (const char *)kbuf.dptr);
+        ok = push_reg_sz(talloc_tos(), &name_index, (const char *)kbuf.dptr);
+        if (!ok) {
+                buffer_size = 0;
+                return buffer_size;
+        }
         memcpy(buf1+buffer_size, (char *)name_index.data, working_size);
         buffer_size += working_size;
         /* Now encode the actual name */
-        working_size = (dbuf.dsize + 1)*sizeof(uint16);
+        working_size = (dbuf.dsize + 1)*sizeof(uint16_t);
         buf1 = (char *)SMB_REALLOC(buf1, buffer_size + working_size);
         if(!buf1) {
@@ -192 +209 @@
         memcpy(temp, dbuf.dptr, dbuf.dsize);
         SAFE_FREE(dbuf.dptr);
-        push_reg_sz(talloc_tos(), &name, temp);
+        ok = push_reg_sz(talloc_tos(), &name, temp);
+        if (!ok) {
+                buffer_size = 0;
+                return buffer_size;
+        }
         memcpy(buf1+buffer_size, (char *)name.data, working_size);
         buffer_size += working_size;
@@ -204 +225 @@
 *********************************************************************/
 
-uint32 reg_perfcount_get_counter_help(uint32 base_index, char **retbuf)
+uint32_t reg_perfcount_get_counter_help(uint32_t base_index, char **retbuf)
 {
         char *buf1 = NULL;
-        uint32 buffer_size = 0;
+        uint32_t buffer_size = 0;
         TDB_CONTEXT *names;
-        const char *fname = counters_directory( NAMES_DB );
+        char *fname;
         int i;
 
-        if(base_index == 0)
+        if (base_index == 0) {
                 return 0;
+        }
+
+        fname = counters_directory(NAMES_DB);
+        if (fname == NULL) {
+                return 0;
+        }
 
         names = tdb_open_log(fname, 0, TDB_DEFAULT, O_RDONLY, 0444);
 
-        if(names == NULL)
-        {
+        if (names == NULL) {
                 DEBUG(1, ("reg_perfcount_get_counter_help: unable to open [%s].\n", fname));
+                TALLOC_FREE(fname);
                 return 0;
-        }    
+        }
+        TALLOC_FREE(fname);
 
         for(i = 1; i <= base_index; i++)
@@ -247 +275 @@
 *********************************************************************/
 
-uint32 reg_perfcount_get_counter_names(uint32 base_index, char **retbuf)
+uint32_t reg_perfcount_get_counter_names(uint32_t base_index, char **retbuf)
 {
         char *buf1 = NULL;
-        uint32 buffer_size = 0;
+        uint32_t buffer_size = 0;
         TDB_CONTEXT *names;
-        const char *fname = counters_directory( NAMES_DB );
+        char *fname;
         int i;
 
-        if(base_index == 0)
+        if (base_index == 0) {
                 return 0;
+        }
+
+        fname = counters_directory(NAMES_DB);
+        if (fname == NULL) {
+                return 0;
+        }
 
         names = tdb_open_log(fname, 0, TDB_DEFAULT, O_RDONLY, 0444);
 
-        if(names == NULL)
-        {
+        if (names == NULL) {
                 DEBUG(1, ("reg_perfcount_get_counter_names: unable to open [%s].\n", fname));
+                TALLOC_FREE(fname);
                 return 0;
-        }    
+        }
+        TALLOC_FREE(fname);
 
         buffer_size = _reg_perfcount_multi_sz_from_tdb(names, 1, retbuf, buffer_size);
@@ -342 +377 @@
 *********************************************************************/
 
-static uint32 _reg_perfcount_get_numinst(int objInd, TDB_CONTEXT *names)
+static uint32_t _reg_perfcount_get_numinst(int objInd, TDB_CONTEXT *names)
 {
         TDB_DATA key, data;
@@ -351 +386 @@
 
         if(data.dptr == NULL)
-                return (uint32)PERF_NO_INSTANCES;
+                return (uint32_t)PERF_NO_INSTANCES;
 
         memset(buf, 0, PERFCOUNT_MAX_LEN);
         memcpy(buf, data.dptr, data.dsize);
         SAFE_FREE(data.dptr);
-        return (uint32)atoi(buf);
+        return (uint32_t)atoi(buf);
 }
 
@@ -377 +412 @@
         struct PERF_OBJECT_TYPE *obj;
 
-        block->objects = (struct PERF_OBJECT_TYPE *)TALLOC_REALLOC_ARRAY(mem_ctx,
+        block->objects = (struct PERF_OBJECT_TYPE *)talloc_realloc(mem_ctx,
                                                                   block->objects,
                                                                   struct PERF_OBJECT_TYPE,
@@ -394 +429 @@
         block->objects[block->NumObjectTypes].counters = NULL;
         block->objects[block->NumObjectTypes].instances = NULL;
-        block->objects[block->NumObjectTypes].counter_data.ByteLength = sizeof(uint32);
+        block->objects[block->NumObjectTypes].counter_data.ByteLength = sizeof(uint32_t);
         block->objects[block->NumObjectTypes].counter_data.data = NULL;
         block->objects[block->NumObjectTypes].DetailLevel = PERF_DETAIL_NOVICE;
@@ -412 +447 @@
 {
         TDB_CONTEXT *counters;
-        const char *fname = counters_directory( DATA_DB );
+        char *fname;
+
+        fname = counters_directory(DATA_DB);
+        if (fname == NULL) {
+                return false;
+        }
 
         counters = tdb_open_log(fname, 0, TDB_DEFAULT, O_RDONLY, 0444);
 
-        if(counters == NULL)
-        {
+        if (counters == NULL) {
                 DEBUG(1, ("reg_perfcount_get_counter_data: unable to open [%s].\n", fname));
-                return False;
-        }    
+                TALLOC_FREE(fname);
+                return False;
+        }
+        TALLOC_FREE(fname);
 
         *data = tdb_fetch(counters, key);
@@ -432 +473 @@
 *********************************************************************/
 
-static uint32 _reg_perfcount_get_size_field(uint32 CounterType)
-{
-        uint32 retval;
+static uint32_t _reg_perfcount_get_size_field(uint32_t CounterType)
+{
+        uint32_t retval;
 
         retval = CounterType;
@@ -449 +490 @@
 *********************************************************************/
 
-static uint32 _reg_perfcount_compute_scale(int64_t data)
+static uint32_t _reg_perfcount_compute_scale(int64_t data)
 {
         int scale = 0;
@@ -465 +506 @@
         }
 
-        return (uint32)scale;
+        return (uint32_t)scale;
 }
 
@@ -482 +523 @@
         long int data32, dbuf[2];
         int64_t data64;
-        uint32 counter_size;
+        uint32_t counter_size;
 
         obj->counters[obj->NumCounters].DefaultScale = 0;
@@ -548 +589 @@
 
         obj->counter_data.ByteLength += dsize + padding;
-        obj->counter_data.data = TALLOC_REALLOC_ARRAY(mem_ctx,
+        obj->counter_data.data = talloc_realloc(mem_ctx,
                                                       obj->counter_data.data,
-                                                      uint8,
-                                                      obj->counter_data.ByteLength - sizeof(uint32));
+                                                      uint8_t,
+                                                      obj->counter_data.ByteLength - sizeof(uint32_t));
         if(obj->counter_data.data == NULL)
                 return False;
@@ -557 +598 @@
         {
                 memcpy((void *)(obj->counter_data.data + 
-                                (obj->counter_data.ByteLength - (sizeof(uint32) + dsize))), 
+                                (obj->counter_data.ByteLength - (sizeof(uint32_t) + dsize))),
                        (const void *)dbuf, dsize);
         }
@@ -564 +605 @@
                 /* Handling PERF_SIZE_VARIABLE_LEN */
                 memcpy((void *)(obj->counter_data.data +
-                                (obj->counter_data.ByteLength - (sizeof(uint32) + dsize))),
+                                (obj->counter_data.ByteLength - (sizeof(uint32_t) + dsize))),
                        (const void *)buf, dsize);
         }
@@ -636 +677 @@
                         return False;
                 }
-                obj->counters = (struct PERF_COUNTER_DEFINITION *)TALLOC_REALLOC_ARRAY(mem_ctx,
+                obj->counters = (struct PERF_COUNTER_DEFINITION *)talloc_realloc(mem_ctx,
                                                                                 obj->counters,
                                                                                 struct PERF_COUNTER_DEFINITION,
@@ -688 +729 @@
         }
         inst->counter_data.ByteLength = data.dsize + sizeof(inst->counter_data.ByteLength);
-        inst->counter_data.data = TALLOC_REALLOC_ARRAY(mem_ctx,
+        inst->counter_data.data = talloc_realloc(mem_ctx,
                                                        inst->counter_data.data,
-                                                       uint8,
+                                                       uint8_t,
                                                        data.dsize);
         if(inst->counter_data.data == NULL)
@@ -720 +761 @@
                         return False;
                 }
-                inst->data = TALLOC_REALLOC_ARRAY(mem_ctx,
+                inst->data = talloc_realloc(mem_ctx,
                                                   inst->data,
-                                                  uint8,
+                                                  uint8_t,
                                                   inst->NameLength);
                 if (inst->data == NULL) {
@@ -735 +776 @@
         inst->ParentObjectTitlePointer = 0;
         inst->UniqueID = PERF_NO_UNIQUE_ID;
-        inst->NameOffset = 6 * sizeof(uint32);
+        inst->NameOffset = 6 * sizeof(uint32_t);
 
         inst->ByteLength = inst->NameOffset + inst->NameLength;
@@ -742 +783 @@
         {
                 pad = 8 - pad;
-                inst->data = TALLOC_REALLOC_ARRAY(mem_ctx,
+                inst->data = talloc_realloc(mem_ctx,
                                                   inst->data,
-                                                  uint8,
+                                                  uint8_t,
                                                   inst->NameLength + pad);
                 memset(inst->data + inst->NameLength, 0, pad);
@@ -764 +805 @@
 
         if(obj->instances == NULL) {
-                obj->instances = TALLOC_REALLOC_ARRAY(mem_ctx,
+                obj->instances = talloc_realloc(mem_ctx,
                                                       obj->instances,
                                                       struct PERF_INSTANCE_DEFINITION,
@@ -857 +898 @@
         TDB_CONTEXT *counters;
         bool status = False;
-        const char *fname = counters_directory( DATA_DB );
+        char *fname;
+
+        fname = counters_directory(DATA_DB);
+        if (fname == NULL) {
+                return false;
+        }
 
         counters = tdb_open_log(fname, 0, TDB_DEFAULT, O_RDONLY, 0444);
 
-        if(counters == NULL)
-        {
+        if (counters == NULL) {
                 DEBUG(1, ("reg_perfcount_init_data_block_perf: unable to open [%s].\n", fname));
-                return False;
-        }    
+                TALLOC_FREE(fname);
+                return False;
+        }
+        TALLOC_FREE(fname);
 
         status = _reg_perfcount_get_64(&PerfFreq, names, 0, "PerfFreq");
@@ -920 +967 @@
 {
         smb_ucs2_t *temp = NULL;
+        TALLOC_CTX *tmp_ctx = talloc_new(mem_ctx);
         time_t tm;
-
-        if (rpcstr_push_talloc(mem_ctx, &temp, "PERF")==(size_t)-1) {
-                return false;
-        }
-        if (!temp) {
-                return false;
+        size_t sz;
+
+        sz = rpcstr_push_talloc(tmp_ctx, &temp, "PERF");
+        if ((sz == -1) || (temp == NULL)) {
+                goto err_out;
         }
         memcpy(block->Signature, temp, strlen_w(temp) *2);
@@ -943 +990 @@
         make_systemtime(&(block->SystemTime), gmtime(&tm));
         _reg_perfcount_init_data_block_perf(block, names);
-        memset(temp, 0, sizeof(temp));
-        rpcstr_push((void *)temp, global_myname(), sizeof(temp), STR_TERMINATE);
+
+        sz = rpcstr_push_talloc(tmp_ctx, &temp, lp_netbios_name());
+        if ((sz == -1) || (temp == NULL)) {
+                goto err_out;
+        }
         block->SystemNameLength = (strlen_w(temp) * 2) + 2;
-        block->data = TALLOC_ZERO_ARRAY(mem_ctx, uint8, block->SystemNameLength + (8 - (block->SystemNameLength % 8)));
+        block->data = talloc_zero_array(mem_ctx, uint8_t, block->SystemNameLength + (8 - (block->SystemNameLength % 8)));
         if (block->data == NULL) {
-                return False;
+                goto err_out;
         }
         memcpy(block->data, temp, block->SystemNameLength);
@@ -956 +1006 @@
            so that the PERF_OBJECT_TYPE struct comes out 64-bit aligned */
         block->HeaderLength += 8 - (block->HeaderLength % 8);
-
-        return True;
-}
-
-/*********************************************************************
-*********************************************************************/
-
-static uint32 _reg_perfcount_perf_data_block_fixup(struct PERF_DATA_BLOCK *block, TALLOC_CTX *mem_ctx)
+        talloc_free(tmp_ctx);
+
+        return true;
+
+err_out:
+        talloc_free(tmp_ctx);
+        return false;
+}
+
+/*********************************************************************
+*********************************************************************/
+
+static uint32_t _reg_perfcount_perf_data_block_fixup(struct PERF_DATA_BLOCK *block, TALLOC_CTX *mem_ctx)
 {
         int obj, cnt, inst, pad, i;
@@ -994 +1049 @@
                                 counter = &(object[obj].counters[object[obj].NumCounters - 1]);
                                 counter_data->ByteLength = counter->CounterOffset + counter->CounterSize + sizeof(counter_data->ByteLength);
-                                temp = TALLOC_REALLOC_ARRAY(mem_ctx,
+                                temp = talloc_realloc(mem_ctx,
                                                             temp, 
                                                             char, 
@@ -1015 +1070 @@
                                         pad = 8 - pad;
                                 }
-                                counter_data->data = TALLOC_REALLOC_ARRAY(mem_ctx,
+                                counter_data->data = talloc_realloc(mem_ctx,
                                                                          counter_data->data,
-                                                                         uint8,
+                                                                         uint8_t,
                                                                          counter_data->ByteLength - sizeof(counter_data->ByteLength) + pad);
                                 if (counter_data->data == NULL) {
@@ -1035 +1090 @@
                         {
                                 pad = 8 - pad;
-                                object[obj].counter_data.data = TALLOC_REALLOC_ARRAY(mem_ctx,
+                                object[obj].counter_data.data = talloc_realloc(mem_ctx,
                                                                                      object[obj].counter_data.data,
-                                                                                     uint8, 
+                                                                                     uint8_t,
                                                                                      object[obj].counter_data.ByteLength + pad);
                                 memset((void *)(object[obj].counter_data.data + object[obj].counter_data.ByteLength), 0, pad);
@@ -1057 +1112 @@
 *********************************************************************/
 
-static uint32 reg_perfcount_get_perf_data_block(uint32 base_index,
+static uint32_t reg_perfcount_get_perf_data_block(uint32_t base_index,
                                                 TALLOC_CTX *mem_ctx,
                                                 struct PERF_DATA_BLOCK *block,
@@ -1063 +1118 @@
                                                 bool bigendian_data)
 {
-        uint32 buffer_size = 0;
-        const char *fname = counters_directory( NAMES_DB );
+        uint32_t buffer_size = 0;
+        char *fname;
         TDB_CONTEXT *names;
         int retval = 0;
 
+        fname = counters_directory(NAMES_DB);
+        if (fname == NULL) {
+                return 0;
+        }
+
         names = tdb_open_log(fname, 0, TDB_DEFAULT, O_RDONLY, 0444);
 
@@ -1073 +1133 @@
         {
                 DEBUG(1, ("reg_perfcount_get_perf_data_block: unable to open [%s].\n", fname));
+                TALLOC_FREE(fname);
                 return 0;
         }
+        TALLOC_FREE(fname);
 
         if (!_reg_perfcount_init_data_block(block, mem_ctx, names, bigendian_data)) {
@@ -1082 +1144 @@
         }
 
-        reg_perfcount_get_last_counter(base_index);
-
-        if(object_ids == NULL)
-        {
-                /* we're getting a request for "Global" here */
-                retval = _reg_perfcount_assemble_global(block, mem_ctx, base_index, names);
-        }
-        else
-        {
-                /* we're getting a request for a specific set of PERF_OBJECT_TYPES */
-                retval = _reg_perfcount_assemble_global(block, mem_ctx, base_index, names);
-        }
+        retval = _reg_perfcount_assemble_global(block, mem_ctx, base_index, names);
+
         buffer_size = _reg_perfcount_perf_data_block_fixup(block, mem_ctx);
 
@@ -1243 +1295 @@
         if(!prs_uint32("ByteLength", ps, depth, &counter_data.ByteLength))
                 return False;
-        if(!prs_uint8s(False, "CounterData", ps, depth, counter_data.data, counter_data.ByteLength - sizeof(uint32)))
+        if(!prs_uint8s(False, "CounterData", ps, depth, counter_data.data, counter_data.ByteLength - sizeof(uint32_t)))
                 return False;
         if(!prs_align_uint64(ps))
@@ -1365 +1417 @@
 *********************************************************************/
 
-WERROR reg_perfcount_get_hkpd(prs_struct *ps, uint32 max_buf_size, uint32 *outbuf_len, const char *object_ids)
+WERROR reg_perfcount_get_hkpd(prs_struct *ps, uint32_t max_buf_size, uint32_t *outbuf_len, const char *object_ids)
 {
         /*
@@ -1376 +1428 @@
          */
         struct PERF_DATA_BLOCK block;
-        uint32 buffer_size, base_index; 
+        uint32_t buffer_size, base_index;
 
         buffer_size = 0;

vendor/current/source3/registry/reg_perfcount.h

@@ -25 +25 @@
 #include "reg_parse_prs.h"
 
-uint32 reg_perfcount_get_base_index(void);
-uint32 reg_perfcount_get_last_counter(uint32 base_index);
-uint32 reg_perfcount_get_last_help(uint32 last_counter);
-uint32 reg_perfcount_get_counter_help(uint32 base_index, char **retbuf);
-uint32 reg_perfcount_get_counter_names(uint32 base_index, char **retbuf);
-WERROR reg_perfcount_get_hkpd(prs_struct *ps, uint32 max_buf_size, uint32 *outbuf_len, const char *object_ids);
+uint32_t reg_perfcount_get_base_index(void);
+uint32_t reg_perfcount_get_last_counter(uint32_t base_index);
+uint32_t reg_perfcount_get_last_help(uint32_t last_counter);
+uint32_t reg_perfcount_get_counter_help(uint32_t base_index, char **retbuf);
+uint32_t reg_perfcount_get_counter_names(uint32_t base_index, char **retbuf);
+WERROR reg_perfcount_get_hkpd(prs_struct *ps, uint32_t max_buf_size, uint32_t *outbuf_len, const char *object_ids);
 
 #endif /* _REG_PERFCOUNT_H */

vendor/current/source3/registry/reg_util_internal.c

@@ -98 +98 @@
 
         /* skip leading '\' chars */
-        p = (char *)keyname;
-        while (*p == '\\') {
-                p++;
+        while (*keyname == '\\') {
+                keyname++;
         }
 
-        nkeyname = talloc_strdup(ctx, p);
+        nkeyname = talloc_strdup(ctx, keyname);
         if (nkeyname == NULL) {
                 return NULL;
@@ -115 +114 @@
         }
 
-        strupper_m(nkeyname);
+        if (!strupper_m(nkeyname)) {
+                TALLOC_FREE(nkeyname);
+                return NULL;
+        }
 
         return nkeyname;

vendor/current/source3/registry/reg_util_token.c

@@ -39 +39 @@
         }
 
-        token = TALLOC_ZERO_P(mem_ctx, struct security_token);
+        token = talloc_zero(mem_ctx, struct security_token);
         if (token == NULL) {
                 DEBUG(1, ("talloc failed\n"));

vendor/current/source3/registry/regfio.c

@@ -23 +23 @@
 #include "../librpc/gen_ndr/ndr_security.h"
 #include "../libcli/security/security_descriptor.h"
+#include "../libcli/security/secdesc.h"
 
 #undef DBGC_CLASS
@@ -45 +46 @@
 static bool smb_io_time(const char *desc, NTTIME *nttime, prs_struct *ps, int depth)
 {
-        uint32 low, high;
+        uint32_t low, high;
         if (nttime == NULL)
                 return False;
@@ -75 +76 @@
 *******************************************************************/
 
-static int write_block( REGF_FILE *file, prs_struct *ps, uint32 offset )
+static int write_block( REGF_FILE *file, prs_struct *ps, uint32_t offset )
 {
         int bytes_written, returned;
         char *buffer = prs_data_p( ps );
-        uint32 buffer_size = prs_data_size( ps );
+        uint32_t buffer_size = prs_data_size( ps );
         SMB_STRUCT_STAT sbuf;
 
@@ -113 +114 @@
 *******************************************************************/
 
-static int read_block( REGF_FILE *file, prs_struct *ps, uint32 file_offset, uint32 block_size )
+static int read_block( REGF_FILE *file, prs_struct *ps, uint32_t file_offset, uint32_t block_size )
 {
         int bytes_read, returned;
@@ -199 +200 @@
 
         if ( hbin->free_off != REGF_OFFSET_NONE ) {
-                uint32 header = 0xffffffff;
-
-                if ( !prs_set_offset( &hbin->ps, hbin->free_off-sizeof(uint32) ) )
+                uint32_t header = 0xffffffff;
+
+                if ( !prs_set_offset( &hbin->ps, hbin->free_off-sizeof(uint32_t) ) )
                         return False;
                 if ( !prs_uint32( "free_size", &hbin->ps, 0, &hbin->free_size ) )
@@ -224 +225 @@
 
         for ( p=file->block_list; p && p!=hbin; p=p->next )
-                ;;
+                ;
 
         if ( p == hbin ) {
@@ -246 +247 @@
         depth++;
         
-        if ( !prs_uint8s( True, "header", ps, depth, (uint8*)file->header, sizeof( file->header )) )
+        if ( !prs_uint8s( True, "header", ps, depth, (uint8_t *)file->header, sizeof( file->header )) )
                 return False;
         
@@ -303 +304 @@
 static bool prs_hbin_block( const char *desc, prs_struct *ps, int depth, REGF_HBIN *hbin )
 {
-        uint32 block_size2;
+        uint32_t block_size2;
 
         prs_debug(ps, depth, desc, "prs_regf_block");
         depth++;
         
-        if ( !prs_uint8s( True, "header", ps, depth, (uint8*)hbin->header, sizeof( hbin->header )) )
+        if ( !prs_uint8s( True, "header", ps, depth, (uint8_t*)hbin->header, sizeof( hbin->header )) )
                 return False;
 
@@ -338 +339 @@
 static bool prs_nk_rec( const char *desc, prs_struct *ps, int depth, REGF_NK_REC *nk )
 {
-        uint16 class_length, name_length;
-        uint32 start;
-        uint32 data_size, start_off, end_off;
-        uint32 unknown_off = REGF_OFFSET_NONE;
+        uint16_t class_length, name_length;
+        uint32_t start;
+        uint32_t data_size, start_off, end_off;
+        uint32_t unknown_off = REGF_OFFSET_NONE;
 
         nk->hbin_off = prs_offset( ps );
@@ -351 +352 @@
         /* back up and get the data_size */
         
-        if ( !prs_set_offset( ps, prs_offset(ps)-sizeof(uint32)) )
+        if ( !prs_set_offset( ps, prs_offset(ps)-sizeof(uint32_t)) )
                 return False;
         start_off = prs_offset( ps );
@@ -357 +358 @@
                 return False;
         
-        if ( !prs_uint8s( True, "header", ps, depth, (uint8*)nk->header, sizeof( nk->header )) )
+        if ( !prs_uint8s( True, "header", ps, depth, (uint8_t *)nk->header, sizeof( nk->header )) )
                 return False;
                 
@@ -418 +419 @@
                 }
 
-                if ( !prs_uint8s( True, "name", ps, depth, (uint8*)nk->keyname, name_length) )
+                if ( !prs_uint8s( True, "name", ps, depth, (uint8_t *)nk->keyname, name_length) )
                         return False;
 
@@ -442 +443 @@
 *******************************************************************/
 
-static uint32 regf_block_checksum( prs_struct *ps )
+static uint32_t regf_block_checksum( prs_struct *ps )
 {
         char *buffer = prs_data_p( ps );
-        uint32 checksum, x;
+        uint32_t checksum, x;
         int i;
 
@@ -466 +467 @@
 {
         prs_struct ps;
-        uint32 checksum;
+        uint32_t checksum;
         
         /* grab the first block from the file */
@@ -496 +497 @@
 {
         REGF_HBIN *hbin;
-        uint32 record_size, curr_off, block_size, header;
-        
-        if ( !(hbin = TALLOC_ZERO_P(file->mem_ctx, REGF_HBIN)) ) 
+        uint32_t record_size, curr_off, block_size, header;
+        
+        if ( !(hbin = talloc_zero(file->mem_ctx, REGF_HBIN)) ) 
                 return NULL;
         hbin->file_off = offset;
@@ -521 +522 @@
         /* remember that the record_size is in the 4 bytes preceeding the record itself */
 
-        if ( !prs_set_offset( &hbin->ps, file->data_offset+HBIN_HDR_SIZE-sizeof(uint32) ) )
-                return False;
+        if ( !prs_set_offset( &hbin->ps, file->data_offset+HBIN_HDR_SIZE-sizeof(uint32_t) ) )
+                return NULL;
 
         record_size = 0;
@@ -545 +546 @@
 
                 if ( !prs_set_offset( &hbin->ps, curr_off) )
-                        return False;
+                        return NULL;
 
                 if ( !prs_uint32( "rec_size", &hbin->ps, 0, &record_size ) )
-                        return False;
+                        return NULL;
                 if ( !prs_uint32( "header", &hbin->ps, 0, &header ) )
-                        return False;
+                        return NULL;
                 
                 SMB_ASSERT( record_size != 0 );
@@ -567 +568 @@
                    record header */
 
-                hbin->free_off = curr_off + sizeof(uint32);
+                hbin->free_off = curr_off + sizeof(uint32_t);
                 hbin->free_size = record_size;
         }
@@ -574 +575 @@
 
         if ( !prs_set_offset( &hbin->ps, file->data_offset+HBIN_HDR_SIZE )  )
-                return False;
+                return NULL;
         
         return hbin;
@@ -584 +585 @@
 *******************************************************************/
 
-static bool hbin_contains_offset( REGF_HBIN *hbin, uint32 offset )
+static bool hbin_contains_offset( REGF_HBIN *hbin, uint32_t offset )
 {
         if ( !hbin )
@@ -600 +601 @@
 *******************************************************************/
 
-static REGF_HBIN* lookup_hbin_block( REGF_FILE *file, uint32 offset )
+static REGF_HBIN* lookup_hbin_block( REGF_FILE *file, uint32_t offset )
 {
         REGF_HBIN *hbin = NULL;
-        uint32 block_off;
+        uint32_t block_off;
 
         /* start with the open list */
@@ -659 +660 @@
         int i;
         REGF_LF_REC *lf = &nk->subkeys;
-        uint32 data_size, start_off, end_off;
+        uint32_t data_size, start_off, end_off;
 
         prs_debug(&hbin->ps, depth, desc, "prs_lf_records");
@@ -676 +677 @@
         /* backup and get the data_size */
         
-        if ( !prs_set_offset( &hbin->ps, prs_offset(&hbin->ps)-sizeof(uint32)) )
+        if ( !prs_set_offset( &hbin->ps, prs_offset(&hbin->ps)-sizeof(uint32_t)) )
                 return False;
         start_off = prs_offset( &hbin->ps );
@@ -682 +683 @@
                 return False;
 
-        if ( !prs_uint8s( True, "header", &hbin->ps, depth, (uint8*)lf->header, sizeof( lf->header )) )
+        if ( !prs_uint8s( True, "header", &hbin->ps, depth, (uint8_t *)lf->header, sizeof( lf->header )) )
                 return False;
                 
@@ -722 +723 @@
 {
         prs_struct *ps = &hbin->ps;
-        uint16 tag = 0xFFFF;
-        uint32 data_size, start_off, end_off;
+        uint16_t tag = 0xFFFF;
+        uint32_t data_size, start_off, end_off;
 
 
@@ -734 +735 @@
         /* backup and get the data_size */
         
-        if ( !prs_set_offset( &hbin->ps, prs_offset(&hbin->ps)-sizeof(uint32)) )
+        if ( !prs_set_offset( &hbin->ps, prs_offset(&hbin->ps)-sizeof(uint32_t)) )
                 return False;
         start_off = prs_offset( &hbin->ps );
@@ -740 +741 @@
                 return False;
 
-        if ( !prs_uint8s( True, "header", ps, depth, (uint8*)sk->header, sizeof( sk->header )) )
+        if ( !prs_uint8s( True, "header", ps, depth, (uint8_t *)sk->header, sizeof( sk->header )) )
                 return False;
         if ( !prs_uint16( "tag", ps, depth, &tag))
@@ -768 +769 @@
                                 return False;
                 } else {
-                        blob = data_blob_const(prs_data_p(&hbin->ps),
-                                               prs_data_size(&hbin->ps));
+                        blob = data_blob_const(
+                                prs_data_p(&hbin->ps) + prs_offset(&hbin->ps),
+                                prs_data_size(&hbin->ps) - prs_offset(&hbin->ps)
+                               );
                         status = unmarshall_sec_desc(mem_ctx,
                                                      blob.data, blob.length,
@@ -798 +801 @@
 static bool hbin_prs_vk_rec( const char *desc, REGF_HBIN *hbin, int depth, REGF_VK_REC *vk, REGF_FILE *file )
 {
-        uint32 offset;
-        uint16 name_length;
+        uint32_t offset;
+        uint16_t name_length;
         prs_struct *ps = &hbin->ps;
-        uint32 data_size, start_off, end_off;
+        uint32_t data_size, start_off, end_off;
 
         prs_debug(ps, depth, desc, "prs_vk_rec");
@@ -808 +811 @@
         /* backup and get the data_size */
         
-        if ( !prs_set_offset( &hbin->ps, prs_offset(&hbin->ps)-sizeof(uint32)) )
+        if ( !prs_set_offset( &hbin->ps, prs_offset(&hbin->ps)-sizeof(uint32_t)) )
                 return False;
         start_off = prs_offset( &hbin->ps );
@@ -814 +817 @@
                 return False;
 
-        if ( !prs_uint8s( True, "header", ps, depth, (uint8*)vk->header, sizeof( vk->header )) )
+        if ( !prs_uint8s( True, "header", ps, depth, (uint8_t *)vk->header, sizeof( vk->header )) )
                 return False;
 
@@ -843 +846 @@
                                 return False;
                 }
-                if ( !prs_uint8s( True, "name", ps, depth, (uint8*)vk->valuename, name_length ) )
+                if ( !prs_uint8s( True, "name", ps, depth, (uint8_t *)vk->valuename, name_length ) )
                         return False;
         }
@@ -861 +864 @@
                 if ( !(vk->data_size & VK_DATA_IN_OFFSET) ) {
                         REGF_HBIN *hblock = hbin;
-                        uint32 data_rec_size;
+                        uint32_t data_rec_size;
 
                         if ( UNMARSHALLING(&hbin->ps) ) {
-                                if ( !(vk->data = PRS_ALLOC_MEM( ps, uint8, vk->data_size) ) )
+                                if ( !(vk->data = PRS_ALLOC_MEM( ps, uint8_t, vk->data_size) ) )
                                         return False;
                         }
@@ -873 +876 @@
                                         return False;
                         }
-                        if ( !(prs_set_offset( &hblock->ps, (vk->data_off+HBIN_HDR_SIZE-hblock->first_hbin_off)-sizeof(uint32) )) )
+                        if ( !(prs_set_offset( &hblock->ps, (vk->data_off+HBIN_HDR_SIZE-hblock->first_hbin_off)-sizeof(uint32_t) )) )
                                 return False;
 
                         if ( MARSHALLING(&hblock->ps) ) {
-                                data_rec_size = ( (vk->data_size+sizeof(uint32)) & 0xfffffff8 ) + 8;
+                                data_rec_size = ( (vk->data_size+sizeof(uint32_t)) & 0xfffffff8 ) + 8;
                                 data_rec_size = ( data_rec_size - 1 ) ^ 0xFFFFFFFF;
                         }
@@ -889 +892 @@
                 }
                 else {
-                        if ( !(vk->data = PRS_ALLOC_MEM( ps, uint8, 4 ) ) )
+                        if ( !(vk->data = PRS_ALLOC_MEM( ps, uint8_t, 4 ) ) )
                                 return False;
                         SIVAL( vk->data, 0, vk->data_off );
@@ -916 +919 @@
 {
         int i;
-        uint32 record_size;
+        uint32_t record_size;
 
         prs_debug(&hbin->ps, depth, desc, "prs_vk_records");
@@ -933 +936 @@
         /* convert the offset to something relative to this HBIN block */
         
-        if ( !prs_set_offset( &hbin->ps, nk->values_off+HBIN_HDR_SIZE-hbin->first_hbin_off-sizeof(uint32)) )
+        if ( !prs_set_offset( &hbin->ps, nk->values_off+HBIN_HDR_SIZE-hbin->first_hbin_off-sizeof(uint32_t)) )
                 return False;
 
         if ( MARSHALLING( &hbin->ps) ) { 
-                record_size = ( ( nk->num_values * sizeof(uint32) ) & 0xfffffff8 ) + 8;
+                record_size = ( ( nk->num_values * sizeof(uint32_t) ) & 0xfffffff8 ) + 8;
                 record_size = (record_size - 1) ^ 0xFFFFFFFF;
         }
@@ -951 +954 @@
         for ( i=0; i<nk->num_values; i++ ) {
                 REGF_HBIN *sub_hbin = hbin;
-                uint32 new_offset;
+                uint32_t new_offset;
         
                 if ( !hbin_contains_offset( hbin, nk->values[i].rec_off ) ) {
@@ -980 +983 @@
 *******************************************************************/
 
-static REGF_SK_REC* find_sk_record_by_offset( REGF_FILE *file, uint32 offset )
+static REGF_SK_REC* find_sk_record_by_offset( REGF_FILE *file, uint32_t offset )
 {
         REGF_SK_REC *p_sk;
@@ -1067 +1070 @@
                         sub_hbin = lookup_hbin_block( file, nk->sk_off );
                         if ( !sub_hbin ) {
-                                DEBUG(0,("hbin_prs_key: Failed to find HBIN block containing sk_offset [0x%x]\n", 
-                                        nk->subkeys_off));
+                                DEBUG(0,("hbin_prs_key: Failed to find HBIN block containing sk_off [0x%x]\n",
+                                        nk->sk_off));
                                 return False;
                         }
                 }
                 
-                if ( !(nk->sec_desc = TALLOC_ZERO_P( file->mem_ctx, REGF_SK_REC )) )
+                if ( !(nk->sec_desc = talloc_zero( file->mem_ctx, REGF_SK_REC )) )
                         return False;
                 nk->sec_desc->sk_off = nk->sk_off;
@@ -1093 +1096 @@
 static bool next_record( REGF_HBIN *hbin, const char *hdr, bool *eob )
 {
-        uint8 header[REC_HDR_SIZE];
-        uint32 record_size;
-        uint32 curr_off, block_size;
+        uint8_t header[REC_HDR_SIZE];
+        uint32_t record_size;
+        uint32_t curr_off, block_size;
         bool found = False;
         prs_struct *ps = &hbin->ps;
@@ -1106 +1109 @@
            and we need to backup to read the record size */
 
-        curr_off -= sizeof(uint32);
+        curr_off -= sizeof(uint32_t);
 
         block_size = prs_data_size( ps );
         record_size = 0;
-        memset( header, 0x0, sizeof(uint8)*REC_HDR_SIZE );
+        memset( header, 0x0, sizeof(uint8_t)*REC_HDR_SIZE );
         while ( !found ) {
 
@@ -1132 +1135 @@
                 if ( memcmp( header, hdr, REC_HDR_SIZE ) == 0 ) {
                         found = True;
-                        curr_off += sizeof(uint32);
+                        curr_off += sizeof(uint32_t);
                 }
         } 
@@ -1372 +1375 @@
         REGF_NK_REC *nk;
         REGF_HBIN   *hbin;
-        uint32      offset = REGF_BLOCKSIZE;
+        uint32_t      offset = REGF_BLOCKSIZE;
         bool        found = False;
         bool        eob;
@@ -1379 +1382 @@
                 return NULL;
                 
-        if ( !(nk = TALLOC_ZERO_P( file->mem_ctx, REGF_NK_REC )) ) {
+        if ( !(nk = talloc_zero( file->mem_ctx, REGF_NK_REC )) ) {
                 DEBUG(0,("regfio_rootkey: talloc() failed!\n"));
                 return NULL;
@@ -1427 +1430 @@
         REGF_NK_REC *subkey;
         REGF_HBIN   *hbin;
-        uint32      nk_offset;
+        uint32_t      nk_offset;
 
         /* see if there is anything left to report */
@@ -1447 +1450 @@
                 
         nk->subkey_index++;
-        if ( !(subkey = TALLOC_ZERO_P( file->mem_ctx, REGF_NK_REC )) )
+        if ( !(subkey = talloc_zero( file->mem_ctx, REGF_NK_REC )) )
                 return NULL;
                 
@@ -1460 +1463 @@
 *******************************************************************/
 
-static REGF_HBIN* regf_hbin_allocate( REGF_FILE *file, uint32 block_size )
+static REGF_HBIN* regf_hbin_allocate( REGF_FILE *file, uint32_t block_size )
 {
         REGF_HBIN *hbin;
         SMB_STRUCT_STAT sbuf;
 
-        if ( !(hbin = TALLOC_ZERO_P( file->mem_ctx, REGF_HBIN )) )
+        if ( !(hbin = talloc_zero( file->mem_ctx, REGF_HBIN )) )
                 return NULL;
 
@@ -1479 +1482 @@
 
         hbin->free_off       = HBIN_HEADER_REC_SIZE;
-        hbin->free_size      = block_size - hbin->free_off + sizeof(uint32);
+        hbin->free_size      = block_size - hbin->free_off + sizeof(uint32_t);
 
         hbin->block_size     = block_size;
@@ -1501 +1504 @@
 *******************************************************************/
 
-static void update_free_space( REGF_HBIN *hbin, uint32 size_used )
+static void update_free_space( REGF_HBIN *hbin, uint32_t size_used )
 {
         hbin->free_off  += size_used;
@@ -1516 +1519 @@
 *******************************************************************/
 
-static REGF_HBIN* find_free_space( REGF_FILE *file, uint32 size )
+static REGF_HBIN* find_free_space( REGF_FILE *file, uint32_t size )
 {
         REGF_HBIN *hbin, *p_hbin;
-        uint32 block_off;
+        uint32_t block_off;
         bool cached;
 
@@ -1575 +1578 @@
 
         if ( !hbin ) {
-                uint32 alloc_size;
+                uint32_t alloc_size;
 
                 /* allocate in multiples of REGF_ALLOC_BLOCK; make sure (size + hbin_header) fits */
@@ -1591 +1594 @@
         /* set the offset to be ready to write */
 
-        if ( !prs_set_offset( &hbin->ps, hbin->free_off-sizeof(uint32) ) )
+        if ( !prs_set_offset( &hbin->ps, hbin->free_off-sizeof(uint32_t) ) )
                 return NULL;
 
@@ -1599 +1602 @@
 
         if ( !prs_uint32("allocated_size", &hbin->ps, 0, &size) )
-                return False;
+                return NULL;
 
         update_free_space( hbin, size );
@@ -1609 +1612 @@
 *******************************************************************/
 
-static uint32 sk_record_data_size( struct security_descriptor * sd )
-{
-        uint32 size, size_mod8;
+static uint32_t sk_record_data_size( struct security_descriptor * sd )
+{
+        uint32_t size, size_mod8;
 
         size_mod8 = 0;
@@ -1617 +1620 @@
         /* the record size is sizeof(hdr) + name + static members + data_size_field */
 
-        size = sizeof(uint32)*5 + ndr_size_security_descriptor(sd, 0) + sizeof(uint32);
+        size = sizeof(uint32_t)*5 + ndr_size_security_descriptor(sd, 0) + sizeof(uint32_t);
 
         /* multiple of 8 */
@@ -1630 +1633 @@
 *******************************************************************/
 
-static uint32 vk_record_data_size( REGF_VK_REC *vk )
-{
-        uint32 size, size_mod8;
+static uint32_t vk_record_data_size( REGF_VK_REC *vk )
+{
+        uint32_t size, size_mod8;
 
         size_mod8 = 0;
@@ -1638 +1641 @@
         /* the record size is sizeof(hdr) + name + static members + data_size_field */
 
-        size = REC_HDR_SIZE + (sizeof(uint16)*3) + (sizeof(uint32)*3) + sizeof(uint32);
+        size = REC_HDR_SIZE + (sizeof(uint16_t)*3) + (sizeof(uint32_t)*3) + sizeof(uint32_t);
 
         if ( vk->valuename )
@@ -1654 +1657 @@
 *******************************************************************/
 
-static uint32 lf_record_data_size( uint32 num_keys )
-{
-        uint32 size, size_mod8;
+static uint32_t lf_record_data_size( uint32_t num_keys )
+{
+        uint32_t size, size_mod8;
 
         size_mod8 = 0;
 
-        /* the record size is sizeof(hdr) + num_keys + sizeof of hash_array + data_size_uint32 */
-
-        size = REC_HDR_SIZE + sizeof(uint16) + (sizeof(REGF_HASH_REC) * num_keys) + sizeof(uint32);
+        /* the record size is sizeof(hdr) + num_keys + sizeof of hash_array + data_size_uint32_t */
+
+        size = REC_HDR_SIZE + sizeof(uint16_t) + (sizeof(REGF_HASH_REC) * num_keys) + sizeof(uint32_t);
 
         /* multiple of 8 */
@@ -1675 +1678 @@
 *******************************************************************/
 
-static uint32 nk_record_data_size( REGF_NK_REC *nk )
-{
-        uint32 size, size_mod8;
+static uint32_t nk_record_data_size( REGF_NK_REC *nk )
+{
+        uint32_t size, size_mod8;
 
         size_mod8 = 0;
 
-        /* the record size is static + length_of_keyname + length_of_classname + data_size_uint32 */
-
-        size = 0x4c + strlen(nk->keyname) + sizeof(uint32);
+        /* the record size is static + length_of_keyname + length_of_classname + data_size_uint32_t */
+
+        size = 0x4c + strlen(nk->keyname) + sizeof(uint32_t);
 
         if ( nk->classname )
@@ -1717 +1720 @@
         vk->type      = regval_type( value );
 
-        if ( vk->data_size > sizeof(uint32) ) {
-                uint32 data_size = ( (vk->data_size+sizeof(uint32)) & 0xfffffff8 ) + 8;
-
-                vk->data = (uint8 *)TALLOC_MEMDUP( file->mem_ctx,
+        if ( vk->data_size > sizeof(uint32_t) ) {
+                uint32_t data_size = ( (vk->data_size+sizeof(uint32_t)) & 0xfffffff8 ) + 8;
+
+                vk->data = (uint8_t *)talloc_memdup( file->mem_ctx,
                                                    regval_data_p(value),
                                                    vk->data_size );
@@ -1739 +1742 @@
 
                 if ( vk->data_size != 0 ) 
-                        memcpy( &vk->data_off, regval_data_p(value), sizeof(uint32) );
+                        memcpy( &vk->data_off, regval_data_p(value), vk->data_size);
                 vk->data_size |= VK_DATA_IN_OFFSET;             
         }
@@ -1751 +1754 @@
 static int hashrec_cmp( REGF_HASH_REC *h1, REGF_HASH_REC *h2 )
 {
-        return StrCaseCmp( h1->fullname, h2->fullname );
+        return strcasecmp_m( h1->fullname, h2->fullname );
 }
 
@@ -1763 +1766 @@
         REGF_NK_REC *nk;
         REGF_HBIN *vlist_hbin = NULL;
-        uint32 size;
-
-        if ( !(nk = TALLOC_ZERO_P( file->mem_ctx, REGF_NK_REC )) )
+        uint32_t size;
+
+        if ( !(nk = talloc_zero( file->mem_ctx, REGF_NK_REC )) )
                 return NULL;
 
@@ -1804 +1807 @@
 
                 hash->nk_off = prs_offset( &nk->hbin->ps ) + nk->hbin->first_hbin_off - HBIN_HDR_SIZE;
-                memcpy( hash->keycheck, name, sizeof(uint32) );
+                memcpy(hash->keycheck, name, MIN(strlen(name),sizeof(uint32_t)));
                 hash->fullname = talloc_strdup( file->mem_ctx, name );
                 parent->subkey_index++;
@@ -1812 +1815 @@
 
                 if ( !hbin_prs_lf_records( "lf_rec", parent->subkeys.hbin, 0, parent ) )
-                        return False;
+                        return NULL;
         }
 
@@ -1819 +1822 @@
         nk->sk_off = REGF_OFFSET_NONE;
         if ( sec_desc ) {
-                uint32 sk_size = sk_record_data_size( sec_desc );
+                uint32_t sk_size = sk_record_data_size( sec_desc );
                 REGF_HBIN *sk_hbin;
 
@@ -1831 +1834 @@
                         }
 
-                        if ( !(nk->sec_desc = TALLOC_ZERO_P( file->mem_ctx, REGF_SK_REC )) )
+                        if ( !(nk->sec_desc = talloc_zero( file->mem_ctx, REGF_SK_REC )) )
                                 return NULL;
         
@@ -1848 +1851 @@
                         /* size value must be self-inclusive */
                         nk->sec_desc->size      = ndr_size_security_descriptor(sec_desc, 0)
-                                + sizeof(uint32);
-
-                        DLIST_ADD_END( file->sec_desc_list, nk->sec_desc, REGF_SK_REC *);
+                                + sizeof(uint32_t);
+
+                        DLIST_ADD_END( file->sec_desc_list, nk->sec_desc);
 
                         /* update the offsets for us and the previous sd in the list.
@@ -1883 +1886 @@
         nk->subkeys_off = REGF_OFFSET_NONE;
         if ( (nk->num_subkeys = regsubkey_ctr_numkeys( subkeys )) != 0 ) {
-                uint32 lf_size = lf_record_data_size( nk->num_subkeys );
-                uint32 namelen;
+                uint32_t lf_size = lf_record_data_size( nk->num_subkeys );
+                uint32_t namelen;
                 int i;
                 
@@ -1898 +1901 @@
                 nk->subkeys.num_keys = nk->num_subkeys;
                 if (nk->subkeys.num_keys) {
-                        if ( !(nk->subkeys.hashes = TALLOC_ZERO_ARRAY( file->mem_ctx, REGF_HASH_REC, nk->subkeys.num_keys )) )
+                        if ( !(nk->subkeys.hashes = talloc_zero_array( file->mem_ctx, REGF_HASH_REC, nk->subkeys.num_keys )) )
                                 return NULL;
                 } else {
@@ -1917 +1920 @@
         nk->values_off = REGF_OFFSET_NONE;
         if ( (nk->num_values = regval_ctr_numvals( values )) != 0 ) {
-                uint32 vlist_size = ( ( nk->num_values * sizeof(uint32) ) & 0xfffffff8 ) + 8;
+                uint32_t vlist_size = ( ( nk->num_values * sizeof(uint32_t) ) & 0xfffffff8 ) + 8;
                 int i;
                 
@@ -1926 +1929 @@
         
                 if (nk->num_values) {
-                        if ( !(nk->values = TALLOC_ARRAY( file->mem_ctx, REGF_VK_REC, nk->num_values )) )
+                        if ( !(nk->values = talloc_array( file->mem_ctx, REGF_VK_REC, nk->num_values )) )
                                 return NULL;
                 } else {
@@ -1935 +1938 @@
 
                 for ( i=0; i<nk->num_values; i++ ) {
-                        uint32 vk_size, namelen, datalen;
+                        uint32_t vk_size, namelen, datalen;
                         struct regval_blob *r;
 
@@ -1964 +1967 @@
         prs_set_offset( &nk->hbin->ps, nk->hbin_off );
         if ( !prs_nk_rec( "nk_rec", &nk->hbin->ps, 0, nk ) )
-                return False;
+                return NULL;
 
         if ( nk->num_values ) {
                 if ( !hbin_prs_vk_records( "vk_records", vlist_hbin, 0, nk, file ) )
-                        return False;
+                        return NULL;
         }
 

vendor/current/source3/registry/regfio.h

@@ -65 +65 @@
 typedef struct regf_hbin {
         struct regf_hbin *prev, *next;
-        uint32 file_off;                /* my offset in the registry file */
-        uint32 free_off;                /* offset to free space within the hbin record */
-        uint32 free_size;               /* amount of data left in the block */
+        uint32_t file_off;              /* my offset in the registry file */
+        uint32_t free_off;              /* offset to free space within the hbin record */
+        uint32_t free_size;             /* amount of data left in the block */
         int ref_count;                  /* how many active records are pointing to this block (not used currently) */
         
         char   header[HBIN_HDR_SIZE];   /* "hbin" */
-        uint32 first_hbin_off;          /* offset from first hbin block */
-        uint32 block_size;              /* block size of this blockually a multiple of 4096Kb) */
+        uint32_t first_hbin_off;                /* offset from first hbin block */
+        uint32_t block_size;            /* block size of this blockually a multiple of 4096Kb) */
 
         prs_struct ps;                  /* data */
@@ -82 +82 @@
 
 typedef struct {
-        uint32 nk_off;
-        uint8 keycheck[sizeof(uint32)];
+        uint32_t nk_off;
+        uint8_t keycheck[sizeof(uint32_t)];
         char *fullname;
 } REGF_HASH_REC;
@@ -89 +89 @@
 typedef struct {
         REGF_HBIN *hbin;        /* pointer to HBIN record (in memory) containing this nk record */
-        uint32 hbin_off;        /* offset from beginning of this hbin block */
-        uint32 rec_size;        /* ((start_offset - end_offset) & 0xfffffff8) */
-
-        char header[REC_HDR_SIZE];
-        uint16 num_keys;
+        uint32_t hbin_off;      /* offset from beginning of this hbin block */
+        uint32_t rec_size;      /* ((start_offset - end_offset) & 0xfffffff8) */
+
+        char header[REC_HDR_SIZE];
+        uint16_t num_keys;
         REGF_HASH_REC *hashes;
 } REGF_LF_REC;
@@ -101 +101 @@
 typedef struct {
         REGF_HBIN *hbin;        /* pointer to HBIN record (in memory) containing this nk record */
-        uint32 hbin_off;        /* offset from beginning of this hbin block */
-        uint32 rec_size;        /* ((start_offset - end_offset) & 0xfffffff8) */
-        uint32 rec_off;         /* offset stored in the value list */
+        uint32_t hbin_off;      /* offset from beginning of this hbin block */
+        uint32_t rec_size;      /* ((start_offset - end_offset) & 0xfffffff8) */
+        uint32_t rec_off;               /* offset stored in the value list */
         
         char header[REC_HDR_SIZE];
         char *valuename;
-        uint32 data_size;
-        uint32 data_off;
-        uint8  *data;
-        uint32 type;
-        uint16 flag;
+        uint32_t data_size;
+        uint32_t data_off;
+        uint8_t  *data;
+        uint32_t type;
+        uint16_t flag;
 } REGF_VK_REC;
 
@@ -121 +121 @@
         struct _regf_sk_rec *next, *prev;
         REGF_HBIN *hbin;        /* pointer to HBIN record (in memory) containing this nk record */
-        uint32 hbin_off;        /* offset from beginning of this hbin block */
-        uint32 rec_size;        /* ((start_offset - end_offset) & 0xfffffff8) */
-
-        uint32 sk_off;          /* offset parsed from NK record used as a key
+        uint32_t hbin_off;      /* offset from beginning of this hbin block */
+        uint32_t rec_size;      /* ((start_offset - end_offset) & 0xfffffff8) */
+
+        uint32_t sk_off;                /* offset parsed from NK record used as a key
                                    to lookup reference to this SK record */
 
         char header[REC_HDR_SIZE];
-        uint32 prev_sk_off;
-        uint32 next_sk_off;
-        uint32 ref_count;
-        uint32 size;
+        uint32_t prev_sk_off;
+        uint32_t next_sk_off;
+        uint32_t ref_count;
+        uint32_t size;
         struct security_descriptor *sec_desc;
 } REGF_SK_REC;
@@ -139 +139 @@
 typedef struct {
         REGF_HBIN *hbin;        /* pointer to HBIN record (in memory) containing this nk record */
-        uint32 hbin_off;        /* offset from beginning of this hbin block */
-        uint32 subkey_index;    /* index to next subkey record to return */
-        uint32 rec_size;        /* ((start_offset - end_offset) & 0xfffffff8) */
+        uint32_t hbin_off;      /* offset from beginning of this hbin block */
+        uint32_t subkey_index;  /* index to next subkey record to return */
+        uint32_t rec_size;      /* ((start_offset - end_offset) & 0xfffffff8) */
         
         /* header information */
         
         char header[REC_HDR_SIZE];
-        uint16 key_type;
+        uint16_t key_type;
         NTTIME mtime;
-        uint32 parent_off;      /* back pointer in registry hive */
-        uint32 classname_off;   
+        uint32_t parent_off;    /* back pointer in registry hive */
+        uint32_t classname_off;
         char *classname;
         char *keyname;
@@ -155 +155 @@
         /* max lengths */
 
-        uint32 max_bytes_subkeyname;            /* max subkey name * 2 */
-        uint32 max_bytes_subkeyclassname;       /* max subkey classname length (as if) */
-        uint32 max_bytes_valuename;             /* max valuename * 2 */
-        uint32 max_bytes_value;                 /* max value data size */
+        uint32_t max_bytes_subkeyname;          /* max subkey name * 2 */
+        uint32_t max_bytes_subkeyclassname;     /* max subkey classname length (as if) */
+        uint32_t max_bytes_valuename;           /* max valuename * 2 */
+        uint32_t max_bytes_value;                       /* max value data size */
 
         /* unknowns */
 
-        uint32 unk_index;                       /* nigel says run time index ? */
+        uint32_t unk_index;                     /* nigel says run time index ? */
         
         /* children */
         
-        uint32 num_subkeys;
-        uint32 subkeys_off;     /* hash records that point to NK records */     
-        uint32 num_values;
-        uint32 values_off;      /* value lists which point to VK records */
-        uint32 sk_off;          /* offset to SK record */
+        uint32_t num_subkeys;
+        uint32_t subkeys_off;   /* hash records that point to NK records */
+        uint32_t num_values;
+        uint32_t values_off;    /* value lists which point to VK records */
+        uint32_t sk_off;                /* offset to SK record */
         
         /* link in the other records here */
@@ -193 +193 @@
 
         char   header[REGF_HDR_SIZE];   /* "regf" */
-        uint32 data_offset;             /* offset to record in the first (or any?) hbin block */
-        uint32 last_block;              /* offset to last hbin block in file */
-        uint32 checksum;                /* XOR of bytes 0x0000 - 0x01FB */
+        uint32_t data_offset;           /* offset to record in the first (or any?) hbin block */
+        uint32_t last_block;            /* offset to last hbin block in file */
+        uint32_t checksum;              /* XOR of bytes 0x0000 - 0x01FB */
         NTTIME mtime;
         
@@ -202 +202 @@
         /* unknowns used to simply writing */
         
-        uint32 unknown1;
-        uint32 unknown2;
-        uint32 unknown3;
-        uint32 unknown4;
-        uint32 unknown5;
-        uint32 unknown6;
+        uint32_t unknown1;
+        uint32_t unknown2;
+        uint32_t unknown3;
+        uint32_t unknown4;
+        uint32_t unknown5;
+        uint32_t unknown6;
         
 } REGF_FILE;