Changeset 745 for trunk/server/source3/registry

trunk/server

Property svn:mergeinfo changed
/vendor/current merged: 581,587,591,594,597,600,615,618,740

trunk/server/source3/registry/reg_api.c

-              r590
+              r745
  *  Virtual Windows Registry Layer
  *  Copyright (C) Volker Lendecke 2006
  *  Copyright (C) Michael Adam 2007-2008
+ *  Copyright (C) Michael Adam 2007-2010
+ *
  *  This program is free software; you can redistribute it and/or modify
 …
  * 0x1b         winreg_OpenHKCC
  * 0x1c         winreg_OpenHKDD
  * 0x1d         winreg_QueryMultipleValues
+ * 0x1d         winreg_QueryMultipleValues              reg_querymultiplevalues
  * 0x1e         winreg_InitiateSystemShutdownEx
  * 0x1f         winreg_SaveKeyEx
  * 0x20         winreg_OpenHKPT
  * 0x21         winreg_OpenHKPN
  * 0x22         winreg_QueryMultipleValues2
+ * 0x22         winreg_QueryMultipleValues2             reg_querymultiplevalues
+ *
  */
 #include "includes.h"
+#include "regfio.h"
+#include "registry.h"
+#include "reg_api.h"
+#include "reg_cachehook.h"
+#include "reg_backend_db.h"
+#include "reg_dispatcher.h"
+#include "reg_objects.h"
+#include "../librpc/gen_ndr/ndr_security.h"
 #undef DBGC_CLASS
 …
 static WERROR fill_value_cache(struct registry_key *key)
+{
+        WERROR werr;
         if (key->values != NULL) {
                 if (!reg_values_need_update(key->key, key->values)) {
 …
+        }
         if (!(key->values = TALLOC_ZERO_P(key, struct regval_ctr))) {
                 return WERR_NOMEM;
+        }
+        werr = regval_ctr_init(key, &(key->values));
+        W_ERROR_NOT_OK_RETURN(werr);
         if (fetch_reg_values(key->key, key->values) == -1) {
                 TALLOC_FREE(key->values);
 …
                                    struct registry_key *parent,
                                    const char *name,
                                    const struct nt_user_token *token,
+                                   const struct security_token *token,
                                    uint32 access_desired,
                                    struct registry_key **pregkey)
 …
         key = regkey->key;
         talloc_set_destructor(key, regkey_destructor);
         /* initialization */
         key->type = REG_KEY_GENERIC;
 …
         if( StrnCaseCmp(key->name, KEY_HKPD, strlen(KEY_HKPD)) == 0 )
                 key->type = REG_KEY_HKPD;
         /* Look up the table of registry I/O operations */
 …
         *pregkey = regkey;
         result = WERR_OK;
 done:
         if ( !W_ERROR_IS_OK(result) ) {
 …
 WERROR reg_openhive(TALLOC_CTX *mem_ctx, const char *hive,
                     uint32 desired_access,
                     const struct nt_user_token *token,
+                    const struct security_token *token,
                     struct registry_key **pkey)
+{
 …
+{
         struct registry_value *val;
+        struct regval_blob *blob;
         WERROR err;
 …
+        }
         if (idx >= key->values->num_values) {
+        if (idx >= regval_ctr_numvals(key->values)) {
                 return WERR_NO_MORE_ITEMS;
+        }
+        err = registry_pull_value(mem_ctx, &val,
+                                  key->values->values[idx]->type,
+                                  key->values->values[idx]->data_p,
+                                  key->values->values[idx]->size,
+                                  key->values->values[idx]->size);
+        if (!W_ERROR_IS_OK(err)) {
+                return err;
+        }
+        blob = regval_ctr_specific_value(key->values, idx);
+        val = talloc_zero(mem_ctx, struct registry_value);
+        if (val == NULL) {
+                return WERR_NOMEM;
+        }
+        val->type = regval_type(blob);
+        val->data = data_blob_talloc(mem_ctx, regval_data_p(blob), regval_size(blob));
         if (pname
             && !(*pname = talloc_strdup(
                          mem_ctx, key->values->values[idx]->valuename))) {
                 SAFE_FREE(val);
+                         mem_ctx, regval_name(blob)))) {
+                TALLOC_FREE(val);
                 return WERR_NOMEM;
+        }
 …
+        }
+        for (i=0; i<key->values->num_values; i++) {
+                if (strequal(key->values->values[i]->valuename, name)) {
+        for (i=0; i < regval_ctr_numvals(key->values); i++) {
+                struct regval_blob *blob;
+                blob = regval_ctr_specific_value(key->values, i);
+                if (strequal(regval_name(blob), name)) {
                         return reg_enumvalue(mem_ctx, key, i, NULL, pval);
+                }
 …
         return WERR_BADFILE;
+}
+WERROR reg_querymultiplevalues(TALLOC_CTX *mem_ctx,
+                               struct registry_key *key,
+                               uint32_t num_names,
+                               const char **names,
+                               uint32_t *pnum_vals,
+                               struct registry_value **pvals)
+{
+        WERROR err;
+        uint32_t i, n, found = 0;
+        struct registry_value *vals;
+        if (num_names == 0) {
+                return WERR_OK;
+        }
+        if (!(key->key->access_granted & KEY_QUERY_VALUE)) {
+                return WERR_ACCESS_DENIED;
+        }
+        if (!(W_ERROR_IS_OK(err = fill_value_cache(key)))) {
+                return err;
+        }
+        vals = talloc_zero_array(mem_ctx, struct registry_value, num_names);
+        if (vals == NULL) {
+                return WERR_NOMEM;
+        }
+        for (n=0; n < num_names; n++) {
+                for (i=0; i < regval_ctr_numvals(key->values); i++) {
+                        struct regval_blob *blob;
+                        blob = regval_ctr_specific_value(key->values, i);
+                        if (strequal(regval_name(blob), names[n])) {
+                                struct registry_value *v;
+                                err = reg_enumvalue(mem_ctx, key, i, NULL, &v);
+                                if (!W_ERROR_IS_OK(err)) {
+                                        return err;
+                                }
+                                vals[n] = *v;
+                                found++;
+                        }
+                }
+        }
+        *pvals = vals;
+        *pnum_vals = found;
+        return WERR_OK;
+}
 …
         max_len = 0;
         max_size = 0;
+        for (i=0; i<key->values->num_values; i++) {
+                max_len = MAX(max_len,
+                              strlen(key->values->values[i]->valuename));
+                max_size = MAX(max_size, key->values->values[i]->size);
+        }
+        *num_values = key->values->num_values;
+        for (i=0; i < regval_ctr_numvals(key->values); i++) {
+                struct regval_blob *blob;
+                blob = regval_ctr_specific_value(key->values, i);
+                max_len = MAX(max_len, strlen(regval_name(blob)));
+                max_size = MAX(max_size, regval_size(blob));
+        }
+        *num_values = regval_ctr_numvals(key->values);
         *max_valnamelen = max_len;
         *max_valbufsize = max_size;
 …
+        }
         *secdescsize = ndr_size_security_descriptor(secdesc, NULL, 0);
+        *secdescsize = ndr_size_security_descriptor(secdesc, 0);
         TALLOC_FREE(mem_ctx);
 …
         WERROR err;
-        /*
-         * We must refuse to handle subkey-paths containing
-         * a '/' character because at a lower level, after
-         * normalization, '/' is treated as a key separator
-         * just like '\\'.
-         */
-        if (strchr(subkeypath, '/') != NULL) {
-                return WERR_INVALID_PARAM;
+        }
         if (!(mem_ctx = talloc_new(ctx))) return WERR_NOMEM;
 …
                     const struct registry_value *val)
+{
         WERROR err;
         DATA_BLOB value_data;
+        struct regval_blob *existing;
+        WERROR err;
         int res;
 …
+        }
+        err = registry_push_value(key, val, &value_data);
+        if (!W_ERROR_IS_OK(err)) {
+                return err;
+        existing = regval_ctr_getvalue(key->values, name);
+        if ((existing != NULL) &&
+            (regval_size(existing) == val->data.length) &&
+            (memcmp(regval_data_p(existing), val->data.data,
+                    val->data.length) == 0)) {
+                return WERR_OK;
+        }
         res = regval_ctr_addvalue(key->values, name, val->type,
+                                  (char *)value_data.data, value_data.length);
+        TALLOC_FREE(value_data.data);
+                                  val->data.data, val->data.length);
         if (res == 0) {
 …
 static WERROR reg_value_exists(struct registry_key *key, const char *name)
+{
         int i;
         for (i=0; i<key->values->num_values; i++) {
+                if (strequal(key->values->values[i]->valuename, name)) {
                         return WERR_OK;
+                }
+        }
         return WERR_BADFILE;
+        struct regval_blob *blob;
+        blob = regval_ctr_getvalue(key->values, name);
+        if (blob == NULL) {
+                return WERR_BADFILE;
+        } else {
+                return WERR_OK;
+        }
+}
 …
+}
-/*******************************************************************
- Note: topkeypat is the *full* path that this *key will be
- loaded into (including the name of the key)
- ********************************************************************/
-static WERROR reg_load_tree(REGF_FILE *regfile, const char *topkeypath,
-                            REGF_NK_REC *key)
+{
-        REGF_NK_REC *subkey;
-        struct registry_key_handle registry_key;
-        struct regval_ctr *values;
-        struct regsubkey_ctr *subkeys;
-        int i;
-        char *path = NULL;
-        WERROR result = WERR_OK;
-        /* initialize the struct registry_key_handle structure */
-        registry_key.ops = reghook_cache_find(topkeypath);
-        if (!registry_key.ops) {
-                DEBUG(0, ("reg_load_tree: Failed to assign registry_ops "
-                          "to [%s]\n", topkeypath));
-                return WERR_BADFILE;
+        }
-        registry_key.name = talloc_strdup(regfile->mem_ctx, topkeypath);
-        if (!registry_key.name) {
-                DEBUG(0, ("reg_load_tree: Talloc failed for reg_key.name!\n"));
-                return WERR_NOMEM;
+        }
-        /* now start parsing the values and subkeys */
-        result = regsubkey_ctr_init(regfile->mem_ctx, &subkeys);
-        W_ERROR_NOT_OK_RETURN(result);
-        values = TALLOC_ZERO_P(subkeys, struct regval_ctr);
-        if (values == NULL) {
-                return WERR_NOMEM;
+        }
-        /* copy values into the struct regval_ctr */
-        for (i=0; i<key->num_values; i++) {
-                regval_ctr_addvalue(values, key->values[i].valuename,
-                                    key->values[i].type,
-                                    (char*)key->values[i].data,
-                                    (key->values[i].data_size & ~VK_DATA_IN_OFFSET));
+        }
-        /* copy subkeys into the struct regsubkey_ctr */
-        key->subkey_index = 0;
-        while ((subkey = regfio_fetch_subkey( regfile, key ))) {
-                result = regsubkey_ctr_addkey(subkeys, subkey->keyname);
-                if (!W_ERROR_IS_OK(result)) {
-                        TALLOC_FREE(subkeys);
-                        return result;
+                }
+        }
-        /* write this key and values out */
-        if (!store_reg_values(&registry_key, values)
-            || !store_reg_keys(&registry_key, subkeys))
+        {
-                DEBUG(0,("reg_load_tree: Failed to load %s!\n", topkeypath));
-                result = WERR_REG_IO_FAILURE;
+        }
-        TALLOC_FREE(subkeys);
-        if (!W_ERROR_IS_OK(result)) {
-                return result;
+        }
-        /* now continue to load each subkey registry tree */
-        key->subkey_index = 0;
-        while ((subkey = regfio_fetch_subkey(regfile, key))) {
-                path = talloc_asprintf(regfile->mem_ctx,
-                                       "%s\\%s",
-                                       topkeypath,
-                                       subkey->keyname);
-                if (path == NULL) {
-                        return WERR_NOMEM;
+                }
-                result = reg_load_tree(regfile, path, subkey);
-                if (!W_ERROR_IS_OK(result)) {
-                        break;
+                }
+        }
-        return result;
+}
-/*******************************************************************
- ********************************************************************/
-static WERROR restore_registry_key(struct registry_key_handle *krecord,
-                                   const char *fname)
+{
-        REGF_FILE *regfile;
-        REGF_NK_REC *rootkey;
-        WERROR result;
-        /* open the registry file....fail if the file already exists */
-        regfile = regfio_open(fname, (O_RDONLY), 0);
-        if (regfile == NULL) {
-                DEBUG(0, ("restore_registry_key: failed to open \"%s\" (%s)\n",
-                          fname, strerror(errno)));
-                return ntstatus_to_werror(map_nt_error_from_unix(errno));
+        }
-        /* get the rootkey from the regf file and then load the tree
-           via recursive calls */
-        if (!(rootkey = regfio_rootkey(regfile))) {
-                regfio_close(regfile);
-                return WERR_REG_FILE_INVALID;
+        }
-        result = reg_load_tree(regfile, krecord->name, rootkey);
-        /* cleanup */
-        regfio_close(regfile);
-        return result;
+}
-WERROR reg_restorekey(struct registry_key *key, const char *fname)
+{
-        return restore_registry_key(key->key, fname);
+}
-/********************************************************************
-********************************************************************/
-static WERROR reg_write_tree(REGF_FILE *regfile, const char *keypath,
-                             REGF_NK_REC *parent)
+{
-        REGF_NK_REC *key;
-        struct regval_ctr *values;
-        struct regsubkey_ctr *subkeys;
-        int i, num_subkeys;
-        char *key_tmp = NULL;
-        char *keyname, *parentpath;
-        char *subkeypath = NULL;
-        char *subkeyname;
-        struct registry_key_handle registry_key;
-        WERROR result = WERR_OK;
-        SEC_DESC *sec_desc = NULL;
-        if (!regfile) {
-                return WERR_GENERAL_FAILURE;
+        }
-        if (!keypath) {
-                return WERR_OBJECT_PATH_INVALID;
+        }
-        /* split up the registry key path */
-        key_tmp = talloc_strdup(regfile->mem_ctx, keypath);
-        if (!key_tmp) {
-                return WERR_NOMEM;
+        }
-        if (!reg_split_key(key_tmp, &parentpath, &keyname)) {
-                return WERR_OBJECT_PATH_INVALID;
+        }
-        if (!keyname) {
-                keyname = parentpath;
+        }
-        /* we need a registry_key_handle object here to enumerate subkeys and values */
-        ZERO_STRUCT(registry_key);
-        registry_key.name = talloc_strdup(regfile->mem_ctx, keypath);
-        if (registry_key.name == NULL) {
-                return WERR_NOMEM;
+        }
-        registry_key.ops = reghook_cache_find(registry_key.name);
-        if (registry_key.ops == NULL) {
-                return WERR_BADFILE;
+        }
-        /* lookup the values and subkeys */
-        result = regsubkey_ctr_init(regfile->mem_ctx, &subkeys);
-        W_ERROR_NOT_OK_RETURN(result);
-        values = TALLOC_ZERO_P(subkeys, struct regval_ctr);
-        if (values == NULL) {
-                return WERR_NOMEM;
+        }
-        fetch_reg_keys(&registry_key, subkeys);
-        fetch_reg_values(&registry_key, values);
-        result = regkey_get_secdesc(regfile->mem_ctx, &registry_key, &sec_desc);
-        if (!W_ERROR_IS_OK(result)) {
-                goto done;
+        }
-        /* write out this key */
-        key = regfio_write_key(regfile, keyname, values, subkeys, sec_desc,
-                               parent);
-        if (key == NULL) {
-                result = WERR_CAN_NOT_COMPLETE;
-                goto done;
+        }
-        /* write each one of the subkeys out */
-        num_subkeys = regsubkey_ctr_numkeys(subkeys);
-        for (i=0; i<num_subkeys; i++) {
-                subkeyname = regsubkey_ctr_specific_key(subkeys, i);
-                subkeypath = talloc_asprintf(regfile->mem_ctx, "%s\\%s",
-                                             keypath, subkeyname);
-                if (subkeypath == NULL) {
-                        result = WERR_NOMEM;
-                        goto done;
+                }
-                result = reg_write_tree(regfile, subkeypath, key);
-                if (!W_ERROR_IS_OK(result))
-                        goto done;
+        }
-        DEBUG(6, ("reg_write_tree: wrote key [%s]\n", keypath));
-done:
-        TALLOC_FREE(subkeys);
-        TALLOC_FREE(registry_key.name);
-        return result;
+}
-static WERROR backup_registry_key(struct registry_key_handle *krecord,
-                                  const char *fname)
+{
-        REGF_FILE *regfile;
-        WERROR result;
-        /* open the registry file....fail if the file already exists */
-        regfile = regfio_open(fname, (O_RDWR|O_CREAT|O_EXCL),
-                              (S_IRUSR|S_IWUSR));
-        if (regfile == NULL) {
-                DEBUG(0,("backup_registry_key: failed to open \"%s\" (%s)\n",
-                         fname, strerror(errno) ));
-                return ntstatus_to_werror(map_nt_error_from_unix(errno));
+        }
-        /* write the registry tree to the file  */
-        result = reg_write_tree(regfile, krecord->name, NULL);
-        /* cleanup */
-        regfio_close(regfile);
-        return result;
+}
-WERROR reg_savekey(struct registry_key *key, const char *fname)
+{
-        return backup_registry_key(key->key, fname);
+}
 /**********************************************************************
  * Higher level utility functions
 …
+        }
+        for (i=0; i<key->values->num_values; i++) {
+                regval_ctr_delvalue(key->values, key->values->values[i]->valuename);
+        for (i=0; i < regval_ctr_numvals(key->values); i++) {
+                struct regval_blob *blob;
+                blob = regval_ctr_specific_value(key->values, i);
+                regval_ctr_delvalue(key->values, regval_name(blob));
+        }
 …
+        }
-        return WERR_OK;
+}
-/*
- * Utility function to open a complete registry path including the hive prefix.
- */
-WERROR reg_open_path(TALLOC_CTX *mem_ctx, const char *orig_path,
-                     uint32 desired_access, const struct nt_user_token *token,
-                     struct registry_key **pkey)
+{
-        struct registry_key *hive, *key;
-        char *path, *p;
-        WERROR err;
-        if (!(path = SMB_STRDUP(orig_path))) {
-                return WERR_NOMEM;
+        }
-        p = strchr(path, '\\');
-        if ((p == NULL) || (p[1] == '\0')) {
-                /*
-                 * No key behind the hive, just return the hive
-                 */
-                err = reg_openhive(mem_ctx, path, desired_access, token,
-                                   &hive);
-                if (!W_ERROR_IS_OK(err)) {
-                        SAFE_FREE(path);
-                        return err;
+                }
-                SAFE_FREE(path);
-                *pkey = hive;
-                return WERR_OK;
+        }
-        *p = '\0';
-        err = reg_openhive(mem_ctx, path, KEY_ENUMERATE_SUB_KEYS, token,
-                           &hive);
-        if (!W_ERROR_IS_OK(err)) {
-                SAFE_FREE(path);
-                return err;
+        }
-        err = reg_openkey(mem_ctx, hive, p+1, desired_access, &key);
-        TALLOC_FREE(hive);
-        SAFE_FREE(path);
-        if (!W_ERROR_IS_OK(err)) {
-                return err;
+        }
-        *pkey = key;
         return WERR_OK;
+}
 …
  * key that has subkeys.
  */
+static WERROR reg_deletekey_recursive_internal(TALLOC_CTX *ctx,
+                                               struct registry_key *parent,
+static WERROR reg_deletekey_recursive_internal(struct registry_key *parent,
                                                const char *path,
                                                bool del_key)
+{
-        TALLOC_CTX *mem_ctx = NULL;
         WERROR werr = WERR_OK;
         struct registry_key *key;
         char *subkey_name = NULL;
         uint32 i;
+        mem_ctx = talloc_new(ctx);
+        if (mem_ctx == NULL) {
+                werr = WERR_NOMEM;
+                goto done;
+        }
+        TALLOC_CTX *mem_ctx = talloc_stackframe();
         /* recurse through subkeys first */
 …
         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(mem_ctx, key,
+                                        subkey_name,
+                                        true);
+                werr = reg_deletekey_recursive_internal(key, subkey_name, true);
                 W_ERROR_NOT_OK_GOTO_DONE(werr);
+        }
 …
+}
+static WERROR reg_deletekey_recursive_trans(TALLOC_CTX *ctx,
+                                            struct registry_key *parent,
+static WERROR reg_deletekey_recursive_trans(struct registry_key *parent,
                                             const char *path,
                                             bool del_key)
 …
+        }
         werr = reg_deletekey_recursive_internal(ctx, parent, path, del_key);
+        werr = reg_deletekey_recursive_internal(parent, path, del_key);
         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)));
+                werr = regdb_transaction_cancel();
+                if (!W_ERROR_IS_OK(werr)) {
+                werr2 = regdb_transaction_cancel();
+                if (!W_ERROR_IS_OK(werr2)) {
                         DEBUG(0, ("reg_deletekey_recursive_trans: "
                                   "error cancelling transaction: %s\n",
+                                  win_errstr(werr)));
+                                  win_errstr(werr2)));
+                        /*
+                         * return the original werr or the
+                         * error from cancelling the transaction?
+                         */
+                }
         } else {
 …
+}
+WERROR reg_deletekey_recursive(TALLOC_CTX *ctx,
+                               struct registry_key *parent,
+WERROR reg_deletekey_recursive(struct registry_key *parent,
                                const char *path)
+{
+        return reg_deletekey_recursive_trans(ctx, parent, path, true);
+}
+WERROR reg_deletesubkeys_recursive(TALLOC_CTX *ctx,
+                                   struct registry_key *parent,
+        return reg_deletekey_recursive_trans(parent, path, true);
+}
+WERROR reg_deletesubkeys_recursive(struct registry_key *parent,
                                    const char *path)
+{
+        return reg_deletekey_recursive_trans(ctx, parent, path, false);
+}
+#if 0
+/* these two functions are unused. */
+/**
+ * Utility function to create a registry key without opening the hive
+ * before. Assumes the hive already exists.
+ */
+WERROR reg_create_path(TALLOC_CTX *mem_ctx, const char *orig_path,
+                       uint32 desired_access,
+                       const struct nt_user_token *token,
+                       enum winreg_CreateAction *paction,
+                       struct registry_key **pkey)
+{
+        struct registry_key *hive;
+        char *path, *p;
+        WERROR err;
+        if (!(path = SMB_STRDUP(orig_path))) {
+                return WERR_NOMEM;
+        }
+        p = strchr(path, '\\');
+        if ((p == NULL) || (p[1] == '\0')) {
+                /*
+                 * No key behind the hive, just return the hive
+                 */
+                err = reg_openhive(mem_ctx, path, desired_access, token,
+                                   &hive);
+                if (!W_ERROR_IS_OK(err)) {
+                        SAFE_FREE(path);
+                        return err;
+                }
+                SAFE_FREE(path);
+                *pkey = hive;
+                *paction = REG_OPENED_EXISTING_KEY;
+                return WERR_OK;
+        }
+        *p = '\0';
+        err = reg_openhive(mem_ctx, path,
+                           (strchr(p+1, '\\') != NULL) ?
+                           KEY_ENUMERATE_SUB_KEYS : KEY_CREATE_SUB_KEY,
+                           token, &hive);
+        if (!W_ERROR_IS_OK(err)) {
+                SAFE_FREE(path);
+                return err;
+        }
+        err = reg_createkey(mem_ctx, hive, p+1, desired_access, pkey, paction);
+        SAFE_FREE(path);
+        TALLOC_FREE(hive);
+        return err;
+}
+/*
+ * Utility function to create a registry key without opening the hive
+ * before. Will not delete a hive.
+ */
+WERROR reg_delete_path(const struct nt_user_token *token,
+                       const char *orig_path)
+{
+        struct registry_key *hive;
+        char *path, *p;
+        WERROR err;
+        if (!(path = SMB_STRDUP(orig_path))) {
+                return WERR_NOMEM;
+        }
+        p = strchr(path, '\\');
+        if ((p == NULL) || (p[1] == '\0')) {
+                SAFE_FREE(path);
+                return WERR_INVALID_PARAM;
+        }
+        *p = '\0';
+        err = reg_openhive(NULL, path,
+                           (strchr(p+1, '\\') != NULL) ?
+                           KEY_ENUMERATE_SUB_KEYS : KEY_CREATE_SUB_KEY,
+                           token, &hive);
+        if (!W_ERROR_IS_OK(err)) {
+                SAFE_FREE(path);
+                return err;
+        }
+        err = reg_deletekey(hive, p+1);
+        SAFE_FREE(path);
+        TALLOC_FREE(hive);
+        return err;
+}
+#endif /* #if 0 */
+        return reg_deletekey_recursive_trans(parent, path, false);
+}

trunk/server/source3/registry/reg_backend_current_version.c

-              r414
+              r745
 #include "includes.h"
+#include "registry.h"
+#include "reg_util_internal.h"
+#include "reg_objects.h"
 #undef DBGC_CLASS
 …
 extern struct registry_ops regdb_ops;
 #define KEY_CURRENT_VERSION_NORM "HKLM/SOFTWARE/MICROSOFT/WINDOWS NT/CURRENTVERSION"
+#define KEY_CURRENT_VERSION_NORM "HKLM\\SOFTWARE\\MICROSOFT\\WINDOWS NT\\CURRENTVERSION"
 static int current_version_fetch_values(const char *key, struct regval_ctr *values)

trunk/server/source3/registry/reg_backend_db.c

-              r429
+              r745
 #include "includes.h"
+#include "system/filesys.h"
+#include "registry.h"
+#include "reg_db.h"
+#include "reg_util_internal.h"
+#include "reg_backend_db.h"
+#include "reg_objects.h"
+#include "nt_printing.h"
+#include "util_tdb.h"
+#include "dbwrap.h"
 #undef DBGC_CLASS
 …
                                         struct regval_ctr *values);
+static NTSTATUS create_sorted_subkeys(const char *key);
 /* List the deepest path into the registry.  All part components will be created.*/
 …
         KEY_PRINTING_PORTS,
         KEY_PRINTING,
+        KEY_PRINTING "\\Forms",
+        KEY_PRINTING "\\Printers",
+        KEY_PRINTING "\\Environments\\Windows NT x86\\Print Processors\\winprint",
         KEY_SHARES,
         KEY_EVENTLOG,
 …
         KEY_GP_USER_POLICY,
         KEY_GP_USER_WIN_POLICY,
         KEY_WINLOGON_GPEXT_PATH,
+        "HKLM\\Software\\Microsoft\\Windows NT\\CurrentVersion\\Winlogon\\GPExtensions",
         "HKLM\\SYSTEM\\CurrentControlSet\\Control\\Print\\Monitors",
         KEY_PROD_OPTIONS,
 …
                 "DefaultSpoolDirectory", REG_SZ, { "C:\\Windows\\System32\\Spool\\Printers" } },
         { KEY_EVENTLOG,
                 "DisplayName", REG_SZ, { "Event Log" } },
+                "DisplayName", REG_SZ, { "Event Log" } },
         { KEY_EVENTLOG,
                 "ErrorControl", REG_DWORD, { (char*)0x00000001 } },
 …
         case REG_DWORD:
                 regval_ctr_addvalue(ctr, value->valuename, REG_DWORD,
                                     (char*)&value->data.dw_value,
+                                    (uint8_t *)&value->data.dw_value,
                                     sizeof(uint32));
                 break;
 …
         for (i=0; builtin_registry_values[i].path != NULL; i++) {
+                values = TALLOC_ZERO_P(frame, struct regval_ctr);
+                if (values == NULL) {
+                        status = NT_STATUS_NO_MEMORY;
+                WERROR werr;
+                werr = regval_ctr_init(frame, &values);
+                if (!W_ERROR_IS_OK(werr)) {
+                        status = werror_to_ntstatus(werr);
                         goto done;
+                }
 …
         for (i=0; builtin_registry_values[i].path != NULL; i++) {
+                values = TALLOC_ZERO_P(frame, struct regval_ctr);
+                if (values == NULL) {
+                        werr = WERR_NOMEM;
+                        goto done;
+                }
+                werr = regval_ctr_init(frame, &values);
+                W_ERROR_NOT_OK_GOTO_DONE(werr);
                 regdb_fetch_values_internal(regdb,
 …
+}
+static int regdb_normalize_keynames_fn(struct db_record *rec,
+                                       void *private_data)
+{
+        TALLOC_CTX *mem_ctx = talloc_tos();
+        const char *keyname;
+        NTSTATUS status;
+        if (rec->key.dptr == NULL || rec->key.dsize == 0) {
+                return 0;
+        }
+        keyname = strchr((const char *) rec->key.dptr, '/');
+        if (keyname) {
+                struct db_record new_rec;
+                keyname = talloc_string_sub(mem_ctx,
+                                            (const char *) rec->key.dptr,
+                                            "/",
+                                            "\\");
+                DEBUG(2, ("regdb_normalize_keynames_fn: Convert %s to %s\n",
+                          (const char *) rec->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);
+                if (!NT_STATUS_IS_OK(status)) {
+                        DEBUG(0,("regdb_normalize_keynames_fn: "
+                                 "tdb_delete for [%s] failed!\n",
+                                 rec->key.dptr));
+                        return 1;
+                }
+                status = rec->store(&new_rec, new_rec.value, TDB_REPLACE);
+                if (!NT_STATUS_IS_OK(status)) {
+                        DEBUG(0,("regdb_normalize_keynames_fn: "
+                                 "failed to store new record for [%s]!\n",
+                                 keyname));
+                        return 1;
+                }
+        }
+        return 0;
+}
+static WERROR regdb_store_regdb_version(uint32_t version)
+{
+        NTSTATUS status;
+        const char *version_keyname = "INFO/version";
+        if (!regdb) {
+                return WERR_CAN_NOT_COMPLETE;
+        }
+        status = dbwrap_trans_store_int32(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)));
+                return ntstatus_to_werror(status);
+        } else {
+                DEBUG(10, ("regdb_store_regdb_version: stored %s = %d\n",
+                          version_keyname, version));
+                return WERR_OK;
+        }
+}
+static WERROR regdb_upgrade_v1_to_v2(void)
+{
+        TALLOC_CTX *mem_ctx;
+        int rc;
+        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);
+        return werr;
+}
 /***********************************************************************
  Open the registry database
  ***********************************************************************/
 WERROR regdb_init(void)
+{
         const char *vstring = "INFO/version";
         uint32 vers_id;
+        uint32 vers_id, expected_version;
         WERROR werr;
         if (regdb) {
                 DEBUG(10, ("regdb_init: incrementing refcount (%d)\n",
                           regdb_refcount));
+                DEBUG(10, ("regdb_init: incrementing refcount (%d->%d)\n",
+                           regdb_refcount, regdb_refcount+1));
                 regdb_refcount++;
                 return WERR_OK;
 …
                         return werr;
+                }
                 DEBUG(10,("regdb_init: Successfully created registry tdb\n"));
+        }
         regdb_refcount = 1;
+        DEBUG(10, ("regdb_init: registry db openend. refcount reset (%d)\n",
+                   regdb_refcount));
+        expected_version = REGVER_V2;
         vers_id = dbwrap_fetch_int32(regdb, vstring);
+        if ( vers_id != REGVER_V1 ) {
+                NTSTATUS status;
+                /* any upgrade code here if needed */
+                DEBUG(10, ("regdb_init: got %s = %d != %d\n", vstring,
+                           vers_id, REGVER_V1));
+                status = dbwrap_trans_store_int32(regdb, vstring, REGVER_V1);
+                if (!NT_STATUS_IS_OK(status)) {
+                        DEBUG(1, ("regdb_init: error storing %s = %d: %s\n",
+                                  vstring, REGVER_V1, nt_errstr(status)));
+                        return ntstatus_to_werror(status);
+                } else {
+                        DEBUG(10, ("regdb_init: stored %s = %d\n",
+                                  vstring, REGVER_V1));
+                }
+        }
+        if (vers_id == -1) {
+                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 "
+                          "(code version = %d), refusing initialization\n",
+                          vers_id, expected_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 (!W_ERROR_IS_OK(werr)) {
+                        regdb->transaction_cancel(regdb);
+                        return werr;
+                }
+                if (regdb->transaction_commit(regdb) != 0) {
+                        return WERR_REG_IO_FAILURE;
+                }
+                vers_id = REGVER_V2;
+        }
+        /* future upgrade code should go here */
         return WERR_OK;
 …
         if ( regdb ) {
+                DEBUG(10,("regdb_open: incrementing refcount (%d)\n", regdb_refcount));
+                DEBUG(10, ("regdb_open: incrementing refcount (%d->%d)\n",
+                           regdb_refcount, regdb_refcount+1));
                 regdb_refcount++;
                 return WERR_OK;
+        }
         become_root();
 …
         if ( !regdb ) {
                 result = ntstatus_to_werror( map_nt_error_from_unix( errno ) );
                 DEBUG(0,("regdb_open: Failed to open %s! (%s)\n",
+                DEBUG(0,("regdb_open: Failed to open %s! (%s)\n",
                         state_path("registry.tdb"), strerror(errno) ));
+        }
 …
         regdb_refcount = 1;
+        DEBUG(10,("regdb_open: refcount reset (%d)\n", regdb_refcount));
+        DEBUG(10, ("regdb_open: registry db opened. refcount reset (%d)\n",
+                   regdb_refcount));
         return result;
 …
         regdb_refcount--;
+        DEBUG(10,("regdb_close: decrementing refcount (%d)\n", regdb_refcount));
+        DEBUG(10, ("regdb_close: decrementing refcount (%d->%d)\n",
+                   regdb_refcount+1, regdb_refcount));
         if ( regdb_refcount > 0 )
 …
                 path = discard_const_p(char, keyname);
         } else {
                 path = talloc_asprintf(mem_ctx, "%s/%s", prefix, keyname);
+                path = talloc_asprintf(mem_ctx, "%s\\%s", prefix, keyname);
                 if (path == NULL) {
                         goto done;
 …
         werr = regdb_delete_values(db, keyname);
         if (!W_ERROR_IS_OK(werr)) {
                 DEBUG(1, (__location__ " Deleting %s/%s failed: %s\n",
+                DEBUG(1, (__location__ " Deleting %s\\%s failed: %s\n",
                           REG_VALUE_PREFIX, keyname, win_errstr(werr)));
                 goto done;
 …
         werr = regdb_delete_secdesc(db, keyname);
         if (!W_ERROR_IS_OK(werr)) {
                 DEBUG(1, (__location__ " Deleting %s/%s failed: %s\n",
+                DEBUG(1, (__location__ " Deleting %s\\%s failed: %s\n",
                           REG_SECDESC_PREFIX, keyname, win_errstr(werr)));
                 goto done;
 …
         /*
+         * Delete a sorted subkey cache for regdb_key_exists, will be
+         * recreated automatically
+         * recreate the sorted subkey cache for regdb_key_exists()
          */
+        keyname = talloc_asprintf(ctx, "%s/%s", REG_SORTED_SUBKEYS_PREFIX,
+                                  keyname);
+        if (keyname == NULL) {
+                werr = WERR_NOMEM;
+                goto done;
+        }
+        werr = ntstatus_to_werror(dbwrap_delete_bystring(db, keyname));
+        /* don't treat WERR_NOT_FOUND as an error here */
+        if (W_ERROR_EQUAL(werr, WERR_NOT_FOUND)) {
+                werr = WERR_OK;
+        }
+        werr = ntstatus_to_werror(create_sorted_subkeys(keyname));
 done:
 …
+                }
                 path = talloc_asprintf(mem_ctx, "%s/%s", store_ctx->key,
+                path = talloc_asprintf(mem_ctx, "%s\\%s", store_ctx->key,
                                        oldkeyname);
                 if (!path) {
 …
         for (i=0; i<num_subkeys; i++) {
                 path = talloc_asprintf(mem_ctx, "%s/%s", store_ctx->key,
+                path = talloc_asprintf(mem_ctx, "%s\\%s", store_ctx->key,
                                 regsubkey_ctr_specific_key(store_ctx->ctr, i));
                 if (!path) {
 …
+        }
         path = talloc_asprintf(mem_ctx, "%s/%s", key, subkey);
+        path = talloc_asprintf(mem_ctx, "%s\\%s", key, subkey);
         if (path == NULL) {
                 werr = WERR_NOMEM;
 …
 /**
  * check whether a given key name represents a base key,
  * i.e one without a subkey separator ('/' or '\').
+ * i.e one without a subkey separator ('\').
  */
 static bool regdb_key_is_base_key(const char *key)
 …
+        }
         ret = (strrchr(path, '/') == NULL);
+        ret = (strrchr(path, '\\') == NULL);
 done:
 …
  */
 static int cmp_keynames(const void *p1, const void *p2)
+{
         return StrCaseCmp(*((char **)p1), *((char **)p2));
+static int cmp_keynames(char **p1, char **p2)
+{
+        return StrCaseCmp(*p1, *p2);
+}
 …
+        }
         qsort(sorted_subkeys, num_subkeys, sizeof(char *), cmp_keynames);
+        TYPESAFE_QSORT(sorted_subkeys, num_subkeys, cmp_keynames);
         buf = talloc_array(ctr, char, len);
 …
+}
+static bool create_sorted_subkeys(const char *key, const char *sorted_keyname)
+static NTSTATUS create_sorted_subkeys_internal(const char *key,
+                                               const char *sorted_keyname)
+{
         NTSTATUS status;
 …
                                  &sorted_ctx);
+        return NT_STATUS_IS_OK(status);
+        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;
+}
 …
+        }
         key = talloc_asprintf(talloc_tos(), "%s/%s",
+        key = talloc_asprintf(talloc_tos(), "%s\\%s",
                               REG_SORTED_SUBKEYS_PREFIX, path);
         if (key == NULL) {
 …
                 result = state.found;
         } else {
+                NTSTATUS status;
                 res = db->transaction_start(db);
                 if (res != 0) {
                         DEBUG(0, ("error starting transacion\n"));
+                        DEBUG(0, ("error starting transaction\n"));
                         goto fail;
+                }
+                if (!create_sorted_subkeys(path, key)) {
+                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) {
 …
+        }
         p = strrchr(path, '/');
+        p = strrchr(path, '\\');
         if (p == NULL) {
                 /* this is a base key */
 …
         DEBUG(11,("regdb_fetch_keys: Enter key => [%s]\n", key ? key : "NULL"));
-        frame = talloc_stackframe();
         if (!regdb_key_exists(db, key)) {
 …
                                   &data_p);
+                /* add the new value. Paranoid protective code -- make sure data_p is valid */
+                if (*valuename && size && data_p) {
+                        regval_ctr_addvalue(values, valuename, type,
+                                        (const char *)data_p, size);
+                }
+                regval_ctr_addvalue(values, valuename, type,
+                                (uint8_t *)data_p, size);
                 SAFE_FREE(data_p); /* 'B' option to tdb_unpack does a malloc() */
 …
         int ret = 0;
         TDB_DATA value;
+        WERROR werr;
         DEBUG(10,("regdb_fetch_values: Looking for value of key [%s] \n", key));
 …
+        }
         keystr = talloc_asprintf(ctx, "%s/%s", REG_VALUE_PREFIX, key);
+        keystr = talloc_asprintf(ctx, "%s\\%s", REG_VALUE_PREFIX, key);
         if (!keystr) {
                 goto done;
+        }
+        values->seqnum = db->get_seqnum(db);
+        werr = regval_ctr_set_seqnum(values, db->get_seqnum(db));
+        W_ERROR_NOT_OK_GOTO_DONE(werr);
         value = regdb_fetch_key_internal(db, ctx, keystr);
 …
         SMB_ASSERT( len == data.dsize );
         keystr = talloc_asprintf(ctx, "%s/%s", REG_VALUE_PREFIX, key );
+        keystr = talloc_asprintf(ctx, "%s\\%s", REG_VALUE_PREFIX, key );
         if (!keystr) {
                 goto done;
 …
+        }
         tdbkey = talloc_asprintf(tmp_ctx, "%s/%s", REG_SECDESC_PREFIX, key);
+        tdbkey = talloc_asprintf(tmp_ctx, "%s\\%s", REG_SECDESC_PREFIX, key);
         if (tdbkey == NULL) {
                 err = WERR_NOMEM;
                 goto done;
+        }
+        normalize_dbkey(tdbkey);
+        tdbkey = normalize_reg_path(tmp_ctx, tdbkey);
+        if (tdbkey == NULL) {
+                err = WERR_NOMEM;
+                goto done;
+        }
         data = dbwrap_fetch_bystring(regdb, tmp_ctx, tdbkey);
 …
+        }
         tdbkey = talloc_asprintf(mem_ctx, "%s/%s", REG_SECDESC_PREFIX, key);
+        tdbkey = talloc_asprintf(mem_ctx, "%s\\%s", REG_SECDESC_PREFIX, key);
         if (tdbkey == NULL) {
                 goto done;
+        }
+        normalize_dbkey(tdbkey);
+        tdbkey = normalize_reg_path(mem_ctx, tdbkey);
+        if (tdbkey == NULL) {
+                err = WERR_NOMEM;
+                goto done;
+        }
         if (secdesc == NULL) {
 …
 bool regdb_values_need_update(struct regval_ctr *values)
+{
         return (regdb_get_seqnum() != values->seqnum);
+}
 /*
+        return (regdb_get_seqnum() != regval_ctr_get_seqnum(values));
+}
+/*
  * Table of function pointers for default access
  */
 struct registry_ops regdb_ops = {
         .fetch_subkeys = regdb_fetch_keys,

trunk/server/source3/registry/reg_backend_hkpt_params.c

-              r414
+              r745
 #include "includes.h"
+#include "registry.h"
+#include "reg_perfcount.h"
+#include "reg_objects.h"
 #undef DBGC_CLASS
 …
         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, buffer,
+        regval_ctr_addvalue(regvals, "Counters", REG_MULTI_SZ, (uint8 *)buffer,
                             buffer_size);
 …
         buffer_size = reg_perfcount_get_counter_help(base_index, &buffer);
         regval_ctr_addvalue(regvals, "Help", REG_MULTI_SZ, buffer, buffer_size);
+        regval_ctr_addvalue(regvals, "Help", REG_MULTI_SZ, (uint8 *)buffer, buffer_size);
         if(buffer_size > 0) {
                 SAFE_FREE(buffer);

trunk/server/source3/registry/reg_backend_netlogon_params.c

-              r414
+              r745
 #include "includes.h"
+#include "registry.h"
+#include "reg_objects.h"
+#include "passdb.h"
 #undef DBGC_CLASS
 …
         regval_ctr_addvalue(regvals, "RefusePasswordChange", REG_DWORD,
                             (char*)&dwValue, sizeof(dwValue));
+                            (uint8_t *)&dwValue, sizeof(dwValue));
         return regval_ctr_numvals(regvals);

trunk/server/source3/registry/reg_backend_perflib.c

-              r414
+              r745
 #include "includes.h"
+#include "registry.h"
+#include "reg_util_internal.h"
+#include "reg_perfcount.h"
+#include "reg_objects.h"
 #undef DBGC_CLASS
 …
 extern struct registry_ops regdb_ops;
 #define KEY_PERFLIB_NORM        "HKLM/SOFTWARE/MICROSOFT/WINDOWS NT/CURRENTVERSION/PERFLIB"
 #define KEY_PERFLIB_009_NORM    "HKLM/SOFTWARE/MICROSOFT/WINDOWS NT/CURRENTVERSION/PERFLIB/009"
+#define KEY_PERFLIB_NORM        "HKLM\\SOFTWARE\\MICROSOFT\\WINDOWS NT\\CURRENTVERSION\\PERFLIB"
+#define KEY_PERFLIB_009_NORM    "HKLM\\SOFTWARE\\MICROSOFT\\WINDOWS NT\\CURRENTVERSION\\PERFLIB\\009"
 static int perflib_params(struct regval_ctr *regvals)
 …
         base_index = reg_perfcount_get_base_index();
         regval_ctr_addvalue(regvals, "Base Index", REG_DWORD, (char *)&base_index, sizeof(base_index));
+        regval_ctr_addvalue(regvals, "Base Index", REG_DWORD, (uint8_t *)&base_index, sizeof(base_index));
         last_counter = reg_perfcount_get_last_counter(base_index);
         regval_ctr_addvalue(regvals, "Last Counter", REG_DWORD, (char *)&last_counter, sizeof(last_counter));
+        regval_ctr_addvalue(regvals, "Last Counter", REG_DWORD, (uint8_t *)&last_counter, sizeof(last_counter));
         last_help = reg_perfcount_get_last_help(last_counter);
         regval_ctr_addvalue(regvals, "Last Help", REG_DWORD, (char *)&last_help, sizeof(last_help));
         regval_ctr_addvalue(regvals, "Version", REG_DWORD, (char *)&version, sizeof(version));
+        regval_ctr_addvalue(regvals, "Last Help", REG_DWORD, (uint8_t *)&last_help, sizeof(last_help));
+        regval_ctr_addvalue(regvals, "Version", REG_DWORD, (uint8_t *)&version, sizeof(version));
         return regval_ctr_numvals( regvals );
 …
         base_index = reg_perfcount_get_base_index();
         buffer_size = reg_perfcount_get_counter_names(base_index, &buffer);
         regval_ctr_addvalue(regvals, "Counter", REG_MULTI_SZ, buffer, buffer_size);
+        regval_ctr_addvalue(regvals, "Counter", REG_MULTI_SZ, (uint8_t *)buffer, buffer_size);
         if(buffer_size > 0)
                 SAFE_FREE(buffer);
         buffer_size = reg_perfcount_get_counter_help(base_index, &buffer);
         regval_ctr_addvalue(regvals, "Help", REG_MULTI_SZ, buffer, buffer_size);
+        regval_ctr_addvalue(regvals, "Help", REG_MULTI_SZ, (uint8_t *)buffer, buffer_size);
         if(buffer_size > 0)
                 SAFE_FREE(buffer);

trunk/server/source3/registry/reg_backend_printing.c

-              r414
+              r745
  *  Virtual Windows Registry Layer
  *  Copyright (C) Gerald Carter                     2002-2005
+ *  Copyright (c) Andreas Schneider <asn@samba.org> 2010
+ *
  *  This program is free software; you can redistribute it and/or modify
 …
 #include "includes.h"
+#include "registry.h"
+#include "reg_util_internal.h"
+#include "reg_backend_db.h"
 #undef DBGC_CLASS
 #define DBGC_CLASS DBGC_REGISTRY
+/* registrt paths used in the print_registry[] */
+#define KEY_MONITORS            "HKLM/SYSTEM/CURRENTCONTROLSET/CONTROL/PRINT/MONITORS"
+#define KEY_FORMS               "HKLM/SYSTEM/CURRENTCONTROLSET/CONTROL/PRINT/FORMS"
+#define KEY_CONTROL_PRINTERS    "HKLM/SYSTEM/CURRENTCONTROLSET/CONTROL/PRINT/PRINTERS"
+#define KEY_ENVIRONMENTS        "HKLM/SYSTEM/CURRENTCONTROLSET/CONTROL/PRINT/ENVIRONMENTS"
+#define KEY_CONTROL_PRINT       "HKLM/SYSTEM/CURRENTCONTROLSET/CONTROL/PRINT"
+#define KEY_WINNT_PRINTERS      "HKLM/SOFTWARE/MICROSOFT/WINDOWS NT/CURRENTVERSION/PRINT/PRINTERS"
+#define KEY_WINNT_PRINT         "HKLM/SOFTWARE/MICROSOFT/WINDOWS NT/CURRENTVERSION/PRINT"
+#define KEY_PORTS               "HKLM/SOFTWARE/MICROSOFT/WINDOWS NT/CURRENTVERSION/PORTS"
+/* registry paths used in the print_registry[] */
+#define KEY_CONTROL_PRINTERS    "HKLM\\SYSTEM\\CURRENTCONTROLSET\\CONTROL\\PRINT\\PRINTERS"
+#define KEY_WINNT_PRINTERS      "HKLM\\SOFTWARE\\MICROSOFT\\WINDOWS NT\\CURRENTVERSION\\PRINT\\PRINTERS"
 /* callback table for various registry paths below the ones we service in this module */
 …
 /*********************************************************************
  *********************************************************************
- ** Utility Functions
- *********************************************************************
- *********************************************************************/
-/***********************************************************************
- simple function to prune a pathname down to the basename of a file
- **********************************************************************/
-static const char *dos_basename(const char *path)
+{
-        const char *p;
-        if (!(p = strrchr( path, '\\'))) {
-                p = path;
-        } else {
-                p++;
+        }
-        return p;
+}
-/*********************************************************************
- *********************************************************************
- ** "HKLM/SYSTEM/CURRENTCONTROLSET/CONTROL/PRINT/FORMS"
- *********************************************************************
- *********************************************************************/
-static int key_forms_fetch_keys(const char *key, struct regsubkey_ctr *subkeys)
+{
-        char *p = reg_remaining_path(talloc_tos(), key + strlen(KEY_FORMS));
-        /* no keys below Forms */
-        if (p) {
-                return -1;
+        }
-        return 0;
+}
-/**********************************************************************
- *********************************************************************/
-static int key_forms_fetch_values(const char *key, struct regval_ctr *values)
+{
-        uint32          data[8];
-        int             i, num_values, form_index = 1;
-        nt_forms_struct *forms_list = NULL;
-        nt_forms_struct *form;
-        DEBUG(10,("print_values_forms: key=>[%s]\n", key ? key : "NULL" ));
-        num_values = get_ntforms( &forms_list );
-        DEBUG(10,("hive_forms_fetch_values: [%d] user defined forms returned\n",
-                num_values));
-        /* handle user defined forms */
-        for ( i=0; i<num_values; i++ ) {
-                form = &forms_list[i];
-                data[0] = form->width;
-                data[1] = form->length;
-                data[2] = form->left;
-                data[3] = form->top;
-                data[4] = form->right;
-                data[5] = form->bottom;
-                data[6] = form_index++;
-                data[7] = form->flag;
-                regval_ctr_addvalue( values, form->name, REG_BINARY, (char*)data, sizeof(data) );
+        }
-        SAFE_FREE( forms_list );
-        forms_list = NULL;
-        /* handle built-on forms */
-        num_values = get_builtin_ntforms( &forms_list );
-        DEBUG(10,("print_subpath_values_forms: [%d] built-in forms returned\n",
-                num_values));
-        for ( i=0; i<num_values; i++ ) {
-                form = &forms_list[i];
-                data[0] = form->width;
-                data[1] = form->length;
-                data[2] = form->left;
-                data[3] = form->top;
-                data[4] = form->right;
-                data[5] = form->bottom;
-                data[6] = form_index++;
-                data[7] = form->flag;
-                regval_ctr_addvalue(values, form->name, REG_BINARY, (char*)data, sizeof(data) );
+        }
-        SAFE_FREE(forms_list);
-        return regval_ctr_numvals(values);
+}
-/*********************************************************************
- *********************************************************************
  ** "HKLM/SYSTEM/CURRENTCONTROLSET/CONTROL/PRINT/PRINTERS"
  ** "HKLM/SOFTWARE/MICROSOFT/WINDOWS NT/CURRENTVERSION/PRINT/PRINTERS"
 …
  *********************************************************************/
+static char *create_printer_registry_path(TALLOC_CTX *mem_ctx, const char *key) {
+        char *path;
+        char *subkey = NULL;
+        path = talloc_strdup(mem_ctx, key);
+        if (path == NULL) {
+                return NULL;
+        }
+        path = normalize_reg_path(mem_ctx, path);
+        if (path == NULL) {
+                return NULL;
+        }
+        if (strncmp(path, KEY_CONTROL_PRINTERS, strlen(KEY_CONTROL_PRINTERS)) == 0) {
+                subkey = reg_remaining_path(mem_ctx, key + strlen(KEY_CONTROL_PRINTERS));
+                if (subkey == NULL) {
+                        return NULL;
+                }
+                return talloc_asprintf(mem_ctx, "%s\\%s", KEY_WINNT_PRINTERS, subkey);
+        }
+        return NULL;
+}
 /*********************************************************************
- strip off prefix for printers key.  DOes return a pointer to static
- memory.
- *********************************************************************/
-static char *strip_printers_prefix(const char *key)
+{
-        char *subkeypath = NULL;
-        char *path = NULL;
-        TALLOC_CTX *ctx = talloc_tos();
-        path = talloc_strdup(ctx, key);
-        if (!path) {
-                return NULL;
+        }
-        path = normalize_reg_path(ctx, path);
-        if (!path) {
-                return NULL;
+        }
-        /* normalizing the path does not change length, just key delimiters and case */
-        if (strncmp(path, KEY_WINNT_PRINTERS, strlen(KEY_WINNT_PRINTERS)) == 0) {
-                subkeypath = reg_remaining_path(ctx, key + strlen(KEY_WINNT_PRINTERS));
-        } else {
-                subkeypath = reg_remaining_path(ctx, key + strlen(KEY_CONTROL_PRINTERS));
+        }
-        TALLOC_FREE(path);
-        return subkeypath;
+}
-/*********************************************************************
  *********************************************************************/
 static int key_printers_fetch_keys( const char *key, struct regsubkey_ctr *subkeys )
+{
+        int n_services = lp_numservices();
+        int snum;
+        fstring sname;
+        int i;
+        int num_subkeys = 0;
+        char *printers_key;
+        char *printername, *printerdatakey;
+        NT_PRINTER_INFO_LEVEL *printer = NULL;
+        fstring *subkey_names = NULL;
+        DEBUG(10,("key_printers_fetch_keys: key=>[%s]\n", key ? key : "NULL" ));
+        printers_key = strip_printers_prefix( key );
+        if ( !printers_key ) {
+                /* enumerate all printers */
+                for (snum=0; snum<n_services; snum++) {
+                        if ( !(lp_snum_ok(snum) && lp_print_ok(snum) ) )
+                                continue;
+                        /* don't report the [printers] share */
+                        if ( strequal( lp_servicename(snum), PRINTERS_NAME ) )
+                                continue;
+                        fstrcpy( sname, lp_servicename(snum) );
+                        regsubkey_ctr_addkey( subkeys, sname );
+                }
+                num_subkeys = regsubkey_ctr_numkeys( subkeys );
+                goto done;
+        }
+        /* get information for a specific printer */
+        if (!reg_split_path( printers_key, &printername, &printerdatakey )) {
+                return -1;
+        }
+        /* validate the printer name */
+        for (snum=0; snum<n_services; snum++) {
+                if ( !lp_snum_ok(snum) || !lp_print_ok(snum) )
+                        continue;
+                if (strequal( lp_servicename(snum), printername ) )
+                        break;
+        }
+        if ( snum>=n_services
+                || !W_ERROR_IS_OK( get_a_printer(NULL, &printer, 2, printername) ) )
+        {
+                return -1;
+        }
+        num_subkeys = get_printer_subkeys( printer->info_2->data, printerdatakey?printerdatakey:"", &subkey_names );
+        for ( i=0; i<num_subkeys; i++ )
+                regsubkey_ctr_addkey( subkeys, subkey_names[i] );
+        free_a_printer( &printer, 2 );
+        /* no other subkeys below here */
+done:
+        SAFE_FREE( subkey_names );
+        return num_subkeys;
+}
+/**********************************************************************
+ Take a list of names and call add_printer_hook() if necessary
+ Note that we do this a little differently from Windows since the
+ keyname is the sharename and not the printer name.
+ *********************************************************************/
+static bool add_printers_by_registry( struct regsubkey_ctr *subkeys )
+{
+        int i, num_keys, snum;
+        char *printername;
+        NT_PRINTER_INFO_LEVEL_2 info2;
+        NT_PRINTER_INFO_LEVEL printer;
+        ZERO_STRUCT( info2 );
+        printer.info_2 = &info2;
+        num_keys = regsubkey_ctr_numkeys( subkeys );
+        become_root();
+        for ( i=0; i<num_keys; i++ ) {
+                printername = regsubkey_ctr_specific_key( subkeys, i );
+                snum = find_service( printername );
+                /* just verify a valied snum for now */
+                if ( snum == -1 ) {
+                        fstrcpy( info2.printername, printername );
+                        fstrcpy( info2.sharename, printername );
+                        if ( !add_printer_hook(talloc_tos(), NULL, &printer ) ) {
+                                DEBUG(0,("add_printers_by_registry: Failed to add printer [%s]\n",
+                                        printername));
+                        }
+                }
+        }
+        unbecome_root();
+        return True;
+        TALLOC_CTX *ctx = talloc_tos();
+        char *printers_key;
+        printers_key = create_printer_registry_path(ctx, key);
+        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);
+}
 …
 static bool key_printers_store_keys( const char *key, struct regsubkey_ctr *subkeys )
+{
+        char *printers_key;
+        char *printername, *printerdatakey;
+        NT_PRINTER_INFO_LEVEL *printer = NULL;
+        int i, num_subkeys, num_existing_keys;
+        char *subkeyname;
+        fstring *existing_subkeys = NULL;
+        printers_key = strip_printers_prefix( key );
+        if ( !printers_key ) {
+                /* have to deal with some new or deleted printer */
+                return add_printers_by_registry( subkeys );
+        }
+        if (!reg_split_path( printers_key, &printername, &printerdatakey )) {
+                return False;
+        }
+        /* lookup the printer */
+        if ( !W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, printername)) ) {
+                DEBUG(0,("key_printers_store_keys: Tried to store subkey for bad printername %s\n",
+                        printername));
+                return False;
+        }
+        /* get the top level printer keys */
+        num_existing_keys = get_printer_subkeys( printer->info_2->data, "", &existing_subkeys );
+        for ( i=0; i<num_existing_keys; i++ ) {
+                /* remove the key if it has been deleted */
+                if ( !regsubkey_ctr_key_exists( subkeys, existing_subkeys[i] ) ) {
+                        DEBUG(5,("key_printers_store_keys: deleting key %s\n",
+                                existing_subkeys[i]));
+                        delete_printer_key( printer->info_2->data, existing_subkeys[i] );
+                }
+        }
+        num_subkeys = regsubkey_ctr_numkeys( subkeys );
+        for ( i=0; i<num_subkeys; i++ ) {
+                subkeyname = regsubkey_ctr_specific_key(subkeys, i);
+                /* add any missing printer keys */
+                if ( lookup_printerkey(printer->info_2->data, subkeyname) == -1 ) {
+                        DEBUG(5,("key_printers_store_keys: adding key %s\n",
+                                existing_subkeys[i]));
+                        if ( add_new_printer_key( printer->info_2->data, subkeyname ) == -1 ) {
+                                SAFE_FREE( existing_subkeys );
+                                return False;
+                        }
+                }
+        }
+        /* write back to disk */
+        mod_a_printer( printer, 2 );
+        /* cleanup */
+        free_a_printer( &printer, 2 );
+        SAFE_FREE( existing_subkeys );
+        return True;
+}
+/**********************************************************************
+ *********************************************************************/
+static void fill_in_printer_values(NT_PRINTER_INFO_LEVEL_2 *info2, struct regval_ctr *values)
+{
+        struct spoolss_DeviceMode *devmode;
+        char            *p;
+        uint32 printer_status = PRINTER_STATUS_OK;
+        regval_ctr_addvalue( values, "Attributes",       REG_DWORD, (char*)&info2->attributes,       sizeof(info2->attributes) );
+        regval_ctr_addvalue( values, "Priority",         REG_DWORD, (char*)&info2->priority,         sizeof(info2->attributes) );
+        regval_ctr_addvalue( values, "ChangeID",         REG_DWORD, (char*)&info2->changeid,         sizeof(info2->changeid) );
+        regval_ctr_addvalue( values, "Default Priority", REG_DWORD, (char*)&info2->default_priority, sizeof(info2->default_priority) );
+        /* lie and say everything is ok since we don't want to call print_queue_length() to get the real status */
+        regval_ctr_addvalue( values, "Status",           REG_DWORD, (char*)&printer_status,          sizeof(info2->status) );
+        regval_ctr_addvalue( values, "StartTime",        REG_DWORD, (char*)&info2->starttime,        sizeof(info2->starttime) );
+        regval_ctr_addvalue( values, "UntilTime",        REG_DWORD, (char*)&info2->untiltime,        sizeof(info2->untiltime) );
+        /* strip the \\server\ from this string */
+        if ( !(p = strrchr( info2->printername, '\\' ) ) )
+                p = info2->printername;
+        else
+                p++;
+        regval_ctr_addvalue_sz(values, "Name", p);
+        regval_ctr_addvalue_sz(values, "Location", info2->location);
+        regval_ctr_addvalue_sz(values, "Description", info2->comment);
+        regval_ctr_addvalue_sz(values, "Parameters", info2->parameters);
+        regval_ctr_addvalue_sz(values, "Port", info2->portname);
+        regval_ctr_addvalue_sz(values, "Share Name", info2->sharename);
+        regval_ctr_addvalue_sz(values, "Printer Driver", info2->drivername);
+        regval_ctr_addvalue_sz(values, "Separator File", info2->sepfile);
+        regval_ctr_addvalue_sz(values, "Print Processor", "WinPrint");
+        regval_ctr_addvalue_sz(values, "Datatype", "RAW");
+        /* stream the device mode */
+        devmode = construct_dev_mode(values,info2->sharename);
+        if (devmode) {
+                DATA_BLOB blob;
+                enum ndr_err_code ndr_err;
+                ndr_err = ndr_push_struct_blob(&blob, values, NULL, devmode,
+                                (ndr_push_flags_fn_t)ndr_push_spoolss_DeviceMode);
+                if (NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+                        regval_ctr_addvalue(values, "Default Devmode", REG_BINARY,
+                                            (const char *)blob.data, blob.length);
+                }
+        }
+        /* stream the printer security descriptor */
+        if (info2->secdesc_buf &&
+            info2->secdesc_buf->sd &&
+            info2->secdesc_buf->sd_size)
+        {
+                NTSTATUS status;
+                DATA_BLOB blob;
+                status = marshall_sec_desc(values, info2->secdesc_buf->sd,
+                                           &blob.data, &blob.length);
+                if (NT_STATUS_IS_OK(status)) {
+                        regval_ctr_addvalue(values, "Security", REG_BINARY,
+                                            (const char *)blob.data, blob.length);
+                }
+        }
+        return;
+        TALLOC_CTX *ctx = talloc_tos();
+        char *printers_key;
+        printers_key = create_printer_registry_path(ctx, key);
+        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);
+}
 …
 static int key_printers_fetch_values(const char *key, struct regval_ctr *values)
+{
+        int             num_values;
+        char            *printers_key;
+        char            *printername, *printerdatakey;
+        NT_PRINTER_INFO_LEVEL   *printer = NULL;
+        NT_PRINTER_DATA *p_data;
+        int             i, key_index;
+        printers_key = strip_printers_prefix( key );
+        /* top level key values stored in the registry has no values */
+        if ( !printers_key ) {
+                /* normalize to the 'HKLM\SOFTWARE\...\Print\Printers' key */
+                return regdb_fetch_values( KEY_WINNT_PRINTERS, values );
+        }
+        /* lookup the printer object */
+        if (!reg_split_path( printers_key, &printername, &printerdatakey )) {
+                return -1;
+        }
+        if ( !W_ERROR_IS_OK( get_a_printer(NULL, &printer, 2, printername) ) )
+                goto done;
+        if ( !printerdatakey ) {
+                fill_in_printer_values( printer->info_2, values );
+                goto done;
+        }
+        /* iterate over all printer data keys and fill the regval container */
+        p_data = printer->info_2->data;
+        if ( (key_index = lookup_printerkey( p_data, printerdatakey )) == -1  ) {
+                /* failure....should never happen if the client has a valid open handle first */
+                DEBUG(10,("key_printers_fetch_values: Unknown keyname [%s]\n", printerdatakey));
+                free_a_printer( &printer, 2 );
+                return -1;
+        }
+        num_values = regval_ctr_numvals( p_data->keys[key_index].values );
+        for ( i=0; i<num_values; i++ )
+                regval_ctr_copyvalue( values, regval_ctr_specific_value(p_data->keys[key_index].values, i) );
+done:
+        if ( printer )
+                free_a_printer( &printer, 2 );
+        return regval_ctr_numvals( values );
+}
+/**********************************************************************
+ *********************************************************************/
+#define REG_IDX_ATTRIBUTES              1
+#define REG_IDX_PRIORITY                2
+#define REG_IDX_DEFAULT_PRIORITY        3
+#define REG_IDX_CHANGEID                4
+#define REG_IDX_STATUS                  5
+#define REG_IDX_STARTTIME               6
+#define REG_IDX_NAME                    7
+#define REG_IDX_LOCATION                8
+#define REG_IDX_DESCRIPTION             9
+#define REG_IDX_PARAMETERS              10
+#define REG_IDX_PORT                    12
+#define REG_IDX_SHARENAME               13
+#define REG_IDX_DRIVER                  14
+#define REG_IDX_SEP_FILE                15
+#define REG_IDX_PRINTPROC               16
+#define REG_IDX_DATATYPE                17
+#define REG_IDX_DEVMODE                 18
+#define REG_IDX_SECDESC                 19
+#define REG_IDX_UNTILTIME               20
+struct {
+        const char *name;
+        int index;
+} printer_values_map[] = {
+        { "Attributes",         REG_IDX_ATTRIBUTES },
+        { "Priority",           REG_IDX_PRIORITY },
+        { "Default Priority",   REG_IDX_DEFAULT_PRIORITY },
+        { "ChangeID",           REG_IDX_CHANGEID },
+        { "Status",             REG_IDX_STATUS },
+        { "StartTime",          REG_IDX_STARTTIME },
+        { "UntilTime",          REG_IDX_UNTILTIME },
+        { "Name",               REG_IDX_NAME },
+        { "Location",           REG_IDX_LOCATION },
+        { "Description",        REG_IDX_DESCRIPTION },
+        { "Parameters",         REG_IDX_PARAMETERS },
+        { "Port",               REG_IDX_PORT },
+        { "Share Name",         REG_IDX_SHARENAME },
+        { "Printer Driver",     REG_IDX_DRIVER },
+        { "Separator File",     REG_IDX_SEP_FILE },
+        { "Print Processor",    REG_IDX_PRINTPROC },
+        { "Datatype",           REG_IDX_DATATYPE },
+        { "Default Devmode",    REG_IDX_DEVMODE },
+        { "Security",           REG_IDX_SECDESC },
+        { NULL, -1 }
+};
+static int find_valuename_index( const char *valuename )
+{
+        int i;
+        for ( i=0; printer_values_map[i].name; i++ ) {
+                if ( strequal( valuename, printer_values_map[i].name ) )
+                        return printer_values_map[i].index;
+        }
+        return -1;
+}
+/**********************************************************************
+ *********************************************************************/
+static void pull_reg_sz_fstring(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob, fstring s)
+{
+        const char *str;
+        pull_reg_sz(mem_ctx, blob, &str);
+        fstrcpy(s, str);
+}
+static void convert_values_to_printer_info_2(TALLOC_CTX *mem_ctx,
+                                             NT_PRINTER_INFO_LEVEL_2 *printer2,
+                                             struct regval_ctr *values)
+{
+        int num_values = regval_ctr_numvals( values );
+        uint32 value_index;
+        struct regval_blob *val;
+        int i;
+        for ( i=0; i<num_values; i++ ) {
+                DATA_BLOB blob;
+                val = regval_ctr_specific_value( values, i );
+                value_index = find_valuename_index( regval_name( val ) );
+                blob = data_blob_const(regval_data_p(val), regval_size(val));
+                switch( value_index ) {
+                        case REG_IDX_ATTRIBUTES:
+                                printer2->attributes = (uint32)(*regval_data_p(val));
+                                break;
+                        case REG_IDX_PRIORITY:
+                                printer2->priority = (uint32)(*regval_data_p(val));
+                                break;
+                        case REG_IDX_DEFAULT_PRIORITY:
+                                printer2->default_priority = (uint32)(*regval_data_p(val));
+                                break;
+                        case REG_IDX_CHANGEID:
+                                printer2->changeid = (uint32)(*regval_data_p(val));
+                                break;
+                        case REG_IDX_STARTTIME:
+                                printer2->starttime = (uint32)(*regval_data_p(val));
+                                break;
+                        case REG_IDX_UNTILTIME:
+                                printer2->untiltime = (uint32)(*regval_data_p(val));
+                                break;
+                        case REG_IDX_NAME:
+                                pull_reg_sz_fstring(mem_ctx, &blob, printer2->printername);
+                                break;
+                        case REG_IDX_LOCATION:
+                                pull_reg_sz_fstring(mem_ctx, &blob, printer2->location);
+                                break;
+                        case REG_IDX_DESCRIPTION:
+                                pull_reg_sz_fstring(mem_ctx, &blob, printer2->comment);
+                                break;
+                        case REG_IDX_PARAMETERS:
+                                pull_reg_sz_fstring(mem_ctx, &blob, printer2->parameters);
+                                break;
+                        case REG_IDX_PORT:
+                                pull_reg_sz_fstring(mem_ctx, &blob, printer2->portname);
+                                break;
+                        case REG_IDX_SHARENAME:
+                                pull_reg_sz_fstring(mem_ctx, &blob, printer2->sharename);
+                                break;
+                        case REG_IDX_DRIVER:
+                                pull_reg_sz_fstring(mem_ctx, &blob, printer2->drivername);
+                                break;
+                        case REG_IDX_SEP_FILE:
+                                pull_reg_sz_fstring(mem_ctx, &blob, printer2->sepfile);
+                                break;
+                        case REG_IDX_PRINTPROC:
+                                pull_reg_sz_fstring(mem_ctx, &blob, printer2->printprocessor);
+                                break;
+                        case REG_IDX_DATATYPE:
+                                pull_reg_sz_fstring(mem_ctx, &blob, printer2->datatype);
+                                break;
+                        case REG_IDX_DEVMODE:
+                                break;
+                        case REG_IDX_SECDESC:
+                                break;
+                        default:
+                                /* unsupported value...throw away */
+                                DEBUG(8,("convert_values_to_printer_info_2: Unsupported registry value [%s]\n",
+                                        regval_name( val ) ));
+                }
+        }
+        return;
+}
+        TALLOC_CTX *ctx = talloc_tos();
+        char *printers_key;
+        printers_key = create_printer_registry_path(ctx, key);
+        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);
+}
 /**********************************************************************
 …
 static bool key_printers_store_values(const char *key, struct regval_ctr *values)
+{
+        char *printers_key;
+        char *printername, *keyname;
+        NT_PRINTER_INFO_LEVEL   *printer = NULL;
+        WERROR result;
+        TALLOC_CTX *mem_ctx = talloc_init("key_printers_store_values");
+        printers_key = strip_printers_prefix( key );
+        /* values in the top level key get stored in the registry */
+        if ( !printers_key ) {
+                /* normalize on the 'HKLM\SOFTWARE\....\Print\Printers' key */
+                return regdb_store_values( KEY_WINNT_PRINTERS, values );
+        }
+        if (!reg_split_path( printers_key, &printername, &keyname )) {
+                return False;
+        }
+        if ( !W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, printername) ) )
+                return False;
+        /* deal with setting values directly under the printername */
+        if ( !keyname ) {
+                convert_values_to_printer_info_2(mem_ctx, printer->info_2, values );
+        }
+        else {
+                int num_values = regval_ctr_numvals( values );
+                int i;
+                struct regval_blob *val;
+                delete_printer_key( printer->info_2->data, keyname );
+                /* deal with any subkeys */
+                for ( i=0; i<num_values; i++ ) {
+                        val = regval_ctr_specific_value( values, i );
+                        result = set_printer_dataex( printer, keyname,
+                                regval_name( val ),
+                                regval_type( val ),
+                                regval_data_p( val ),
+                                regval_size( val ) );
+                        if ( !W_ERROR_IS_OK(result) ) {
+                                DEBUG(0,("key_printers_store_values: failed to set printer data [%s]!\n",
+                                        keyname));
+                                free_a_printer( &printer, 2 );
+                                talloc_destroy(mem_ctx);
+                                return False;
+                        }
+                }
+        }
+        result = mod_a_printer( printer, 2 );
+        free_a_printer( &printer, 2 );
+        talloc_destroy(mem_ctx);
+        return W_ERROR_IS_OK(result);
+}
+/*********************************************************************
+ *********************************************************************
+ ** "HKLM/SYSTEM/CURRENTCONTROLSET/CONTROL/PRINT/ENVIRONMENTS"
+ *********************************************************************
+ *********************************************************************/
+static int key_driver_fetch_keys( const char *key, struct regsubkey_ctr *subkeys )
+{
+        const char *environments[] = {
+                "Windows 4.0",
+                "Windows NT x86",
+                "Windows NT R4000",
+                "Windows NT Alpha_AXP",
+                "Windows NT PowerPC",
+                "Windows IA64",
+                "Windows x64",
+                NULL };
+        fstring *drivers = NULL;
+        int i, env_index, num_drivers;
+        char *keystr, *base, *subkeypath;
+        char *key2 = NULL;
+        int num_subkeys = -1;
+        int version;
+        TALLOC_CTX *ctx = talloc_tos();
+        DEBUG(10,("key_driver_fetch_keys key=>[%s]\n", key ? key : "NULL" ));
+        keystr = reg_remaining_path(ctx, key + strlen(KEY_ENVIRONMENTS) );
+        /* list all possible architectures */
+        if ( !keystr ) {
+                for ( num_subkeys=0; environments[num_subkeys]; num_subkeys++ )
+                        regsubkey_ctr_addkey( subkeys,  environments[num_subkeys] );
+                return num_subkeys;
+        }
+        /* we are dealing with a subkey of "Environments */
+        key2 = talloc_strdup(ctx, keystr);
+        if (!key2) {
+                return -1;
+        }
+        keystr = key2;
+        if (!reg_split_path(keystr, &base, &subkeypath )) {
+                return -1;
+        }
+        /* sanity check */
+        for ( env_index=0; environments[env_index]; env_index++ ) {
+                if ( strequal( environments[env_index], base ) )
+                        break;
+        }
+        if ( !environments[env_index] )
+                return -1;
+        /* ...\Print\Environements\...\ */
+        if ( !subkeypath ) {
+                regsubkey_ctr_addkey( subkeys, "Drivers" );
+                regsubkey_ctr_addkey( subkeys, "Print Processors" );
+                return 2;
+        }
+        /* more of the key path to process */
+        keystr = subkeypath;
+        if (!reg_split_path( keystr, &base, &subkeypath )) {
+                return -1;
+        }
+        /* ...\Print\Environements\...\Drivers\ */
+        if ( !subkeypath ) {
+                if ( strequal(base, "Drivers") ) {
+                        switch ( env_index ) {
+                                case 0: /* Win9x */
+                                        regsubkey_ctr_addkey( subkeys, "Version-0" );
+                                        break;
+                                default: /* Windows NT based systems */
+                                        regsubkey_ctr_addkey( subkeys, "Version-2" );
+                                        regsubkey_ctr_addkey( subkeys, "Version-3" );
+                                        break;
+                        }
+                        return regsubkey_ctr_numkeys( subkeys );
+                } else if ( strequal(base, "Print Processors") ) {
+                        if ( env_index == 1 || env_index == 5 || env_index == 6 )
+                        return regsubkey_ctr_numkeys( subkeys );
+                } else
+                        return -1;      /* bad path */
+        }
+        /* we finally get to enumerate the drivers */
+        /* only one possible subkey below PrintProc key */
+        if ( strequal(base, "Print Processors") ) {
+                keystr = subkeypath;
+                if (!reg_split_path( keystr, &base, &subkeypath )) {
+                        return -1;
+                }
+                /* no subkeys below this point */
+                if ( subkeypath )
+                        return -1;
+                /* only allow one keyname here -- 'winprint' */
+                return strequal( base, "winprint" ) ? 0 : -1;
+        }
+        /* only dealing with drivers from here on out */
+        keystr = subkeypath;
+        if (!reg_split_path( keystr, &base, &subkeypath )) {
+                return -1;
+        }
+        version = atoi(&base[strlen(base)-1]);
+        switch (env_index) {
+        case 0:
+                if ( version != 0 )
+                        return -1;
+                break;
+        default:
+                if ( version != 2 && version != 3 )
+                        return -1;
+                break;
+        }
+        if ( !subkeypath ) {
+                num_drivers = get_ntdrivers( &drivers, environments[env_index], version );
+                for ( i=0; i<num_drivers; i++ )
+                        regsubkey_ctr_addkey( subkeys, drivers[i] );
+                return regsubkey_ctr_numkeys( subkeys );
+        }
+        /* if anything else left, just say if has no subkeys */
+        DEBUG(1,("key_driver_fetch_keys unhandled key [%s] (subkey == %s)\n",
+                key, subkeypath ));
+        return 0;
+}
+/**********************************************************************
+ *********************************************************************/
+static void fill_in_driver_values(const struct spoolss_DriverInfo8 *r,
+                                  struct regval_ctr *values)
+{
+        char *buffer = NULL;
+        int buffer_size = 0;
+        int i, length;
+        const char *filename;
+        DATA_BLOB data;
+        filename = dos_basename(r->driver_path);
+        regval_ctr_addvalue_sz(values, "Driver", filename);
+        filename = dos_basename(r->config_file);
+        regval_ctr_addvalue_sz(values, "Configuration File", filename);
+        filename = dos_basename(r->data_file);
+        regval_ctr_addvalue_sz(values, "Data File", filename);
+        filename = dos_basename(r->help_file);
+        regval_ctr_addvalue_sz(values, "Help File", filename);
+        regval_ctr_addvalue_sz(values, "Data Type", r->default_datatype);
+        regval_ctr_addvalue( values, "Version", REG_DWORD, (char*)&r->version,
+                sizeof(r->version) );
+        if (r->dependent_files) {
+                /* place the list of dependent files in a single
+                   character buffer, separating each file name by
+                   a NULL */
+                for (i=0; r->dependent_files[i] && strcmp(r->dependent_files[i], ""); i++) {
+                        /* strip the path to only the file's base name */
+                        filename = dos_basename(r->dependent_files[i]);
+                        length = strlen(filename);
+                        buffer = (char *)SMB_REALLOC( buffer, buffer_size + (length + 1)*sizeof(uint16) );
+                        if ( !buffer ) {
+                                break;
+                        }
+                        push_reg_sz(talloc_tos(), &data, filename);
+                        memcpy( buffer+buffer_size, (char*)data.data, data.length);
+                        buffer_size += (length + 1)*sizeof(uint16);
+                }
+                /* terminated by double NULL.  Add the final one here */
+                buffer = (char *)SMB_REALLOC( buffer, buffer_size + 2 );
+                if ( !buffer ) {
+                        buffer_size = 0;
+                } else {
+                        buffer[buffer_size++] = '\0';
+                        buffer[buffer_size++] = '\0';
+                }
+        }
+        regval_ctr_addvalue( values, "Dependent Files",    REG_MULTI_SZ, buffer, buffer_size );
+        SAFE_FREE( buffer );
+        return;
+}
+/**********************************************************************
+ *********************************************************************/
+static int driver_arch_fetch_values(char *key, struct regval_ctr *values)
+{
+        char            *keystr, *base, *subkeypath;
+        fstring         arch_environment;
+        fstring         driver;
+        int             version;
+        struct spoolss_DriverInfo8 *driver_ctr;
+        WERROR          w_result;
+        if (!reg_split_path( key, &base, &subkeypath )) {
+                return -1;
+        }
+        /* no values in 'Environments\Drivers\Windows NT x86' */
+        if ( !subkeypath )
+                return 0;
+        /* We have the Architecture string and some subkey name:
+           Currently we only support
+           * Drivers
+           * Print Processors
+           Anything else is an error.
+           */
+        fstrcpy( arch_environment, base );
+        keystr = subkeypath;
+        if (!reg_split_path( keystr, &base, &subkeypath )) {
+                return -1;
+        }
+        if ( strequal(base, "Print Processors") )
+                return 0;
+        /* only Drivers key can be left */
+        if ( !strequal(base, "Drivers") )
+                return -1;
+        if ( !subkeypath )
+                return 0;
+        /* We know that we have Architechure\Drivers with some subkey name
+           The subkey name has to be Version-XX */
+        keystr = subkeypath;
+        if (!reg_split_path( keystr, &base, &subkeypath )) {
+                return -1;
+        }
+        if ( !subkeypath )
+                return 0;
+        version = atoi(&base[strlen(base)-1]);
+        /* BEGIN PRINTER DRIVER NAME BLOCK */
+        keystr = subkeypath;
+        if (!reg_split_path( keystr, &base, &subkeypath )) {
+                return -1;
+        }
+        /* don't go any deeper for now */
+        fstrcpy( driver, base );
+        w_result = get_a_printer_driver(talloc_tos(), &driver_ctr, driver, arch_environment, version);
+        if ( !W_ERROR_IS_OK(w_result) )
+                return -1;
+        fill_in_driver_values(driver_ctr, values);
+        free_a_printer_driver(driver_ctr);
+        /* END PRINTER DRIVER NAME BLOCK */
+        DEBUG(8,("key_driver_fetch_values: Exit\n"));
+        return regval_ctr_numvals( values );
+}
+/**********************************************************************
+ *********************************************************************/
+static int key_driver_fetch_values(const char *key, struct regval_ctr *values)
+{
+        char *keystr = NULL;
+        char *subkey = NULL;
+        TALLOC_CTX *ctx = talloc_tos();
+        DEBUG(8,("key_driver_fetch_values: Enter key => [%s]\n", key ? key : "NULL"));
+        /* no values in the Environments key */
+        if (!(keystr = reg_remaining_path(ctx, key + strlen(KEY_ENVIRONMENTS))))
+                return 0;
+        subkey = talloc_strdup(ctx, keystr);
+        if (!subkey) {
+                return 0;
+        }
+        /* pass off to handle subkeys */
+        return driver_arch_fetch_values( subkey, values );
+}
+/*********************************************************************
+ *********************************************************************
+ ** "HKLM/SYSTEM/CURRENTCONTROLSET/CONTROL/PRINT"
+ *********************************************************************
+ *********************************************************************/
+static int key_print_fetch_keys( const char *key, struct regsubkey_ctr *subkeys )
+{
+        int key_len = strlen(key);
+        /* no keys below 'Print' handled here */
+        if ( (key_len != strlen(KEY_CONTROL_PRINT)) && (key_len != strlen(KEY_WINNT_PRINT)) )
+                return -1;
+        regsubkey_ctr_addkey( subkeys, "Environments" );
+        regsubkey_ctr_addkey( subkeys, "Monitors" );
+        regsubkey_ctr_addkey( subkeys, "Forms" );
+        regsubkey_ctr_addkey( subkeys, "Printers" );
+        return regsubkey_ctr_numkeys( subkeys );
+        TALLOC_CTX *ctx = talloc_tos();
+        char *printers_key;
+        printers_key = create_printer_registry_path(ctx, key);
+        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);
+}
 …
 static struct reg_dyn_tree print_registry[] = {
-/* just pass the monitor onto the registry tdb */
-{ KEY_MONITORS,
-        &regdb_fetch_keys,
-        &regdb_store_keys,
-        &regdb_fetch_values,
-        &regdb_store_values },
-{ KEY_FORMS,
-        &key_forms_fetch_keys,
-        NULL,
-        &key_forms_fetch_values,
-        NULL },
 { KEY_CONTROL_PRINTERS,
         &key_printers_fetch_keys,
 …
         &key_printers_fetch_values,
         &key_printers_store_values },
-{ KEY_ENVIRONMENTS,
-        &key_driver_fetch_keys,
-        NULL,
-        &key_driver_fetch_values,
-        NULL },
-{ KEY_CONTROL_PRINT,
-        &key_print_fetch_keys,
-        NULL,
-        NULL,
-        NULL },
-{ KEY_WINNT_PRINTERS,
-        &key_printers_fetch_keys,
-        &key_printers_store_keys,
-        &key_printers_fetch_values,
-        &key_printers_store_values },
-{ KEY_PORTS,
-        &regdb_fetch_keys,
-        &regdb_store_keys,
-        &regdb_fetch_values,
-        &regdb_store_values },
 { NULL, NULL, NULL, NULL, NULL }

trunk/server/source3/registry/reg_backend_prod_options.c

r414	r745
26	26
27	27	#include "includes.h"
	28	#include "registry.h"
	29	#include "reg_objects.h"
28	30
29	31	#undef DBGC_CLASS

trunk/server/source3/registry/reg_backend_shares.c

-              r414
+              r745
 #include "includes.h"
+#include "registry.h"
+#include "reg_objects.h"
 #undef DBGC_CLASS
 …
 /**********************************************************************
  It is safe to assume that every registry path passed into on of
  the exported functions here begins with KEY_PRINTING else
+ It is safe to assume that every registry path passed into one of
+ the exported functions here begins with KEY_SHARES else
  these functions would have never been called.  This is a small utility
  function to strip the beginning of the path and make a copy that the
+ function to strip the beginning of the path and make a copy that the
  caller can modify.  Note that the caller is responsible for releasing
  the memory allocated here.
 …
         const char *p;
         uint16 key_len = strlen(KEY_SHARES);
         /*
          * sanity check...this really should never be True.
 …
          * the path buffer in the extreme case.
          */
         if ( strlen(path) < key_len ) {
                 DEBUG(0,("trim_reg_path: Registry path too short! [%s]\n", path));
                 return NULL;
+        }
         p = path + strlen( KEY_SHARES );
         if ( *p == '\\' )
                 p++;
         if ( *p )
                 return SMB_STRDUP(p);
 …
  Caller is responsible for freeing memory to **subkeys
  *********************************************************************/
 static int shares_subkey_info( const char *key, struct regsubkey_ctr *subkey_ctr )
+{
 …
         bool            top_level = False;
         int             num_subkeys = 0;
         DEBUG(10,("printing_subkey_info: key=>[%s]\n", key));
+        DEBUG(10, ("shares_subkey_info: key=>[%s]\n", key));
         path = trim_reg_path( key );
         /* check to see if we are dealing with the top level key */
         if ( !path )
                 top_level = True;
         if ( top_level ) {
                 num_subkeys = 1;
 …
                 num_subkeys = handle_share_subpath( path, subkey_ctr, NULL );
 #endif
         SAFE_FREE( path );
         return num_subkeys;
+}
 …
         bool            top_level = False;
         int             num_values = 0;
         DEBUG(10,("printing_value_info: key=>[%s]\n", key));
+        DEBUG(10, ("shares_value_info: key=>[%s]\n", key));
         path = trim_reg_path( key );
         /* check to see if we are dealing with the top level key */
         if ( !path )
                 top_level = True;
         /* fill in values from the getprinterdata_printer_server() */
         if ( top_level )
 …
                 num_values = handle_printing_subpath( path, NULL, val );
 #endif
         SAFE_FREE(path);
         return num_values;
+}
 …
 /**********************************************************************
  Stub function which always returns failure since we don't want
  people storing printing information directly via regostry calls
+ people storing share information directly via registry calls
  (for now at least)
  *********************************************************************/
 …
 /**********************************************************************
  Stub function which always returns failure since we don't want
  people storing printing information directly via regostry calls
+ people storing share information directly via registry calls
  (for now at least)
  *********************************************************************/

trunk/server/source3/registry/reg_backend_smbconf.c

-              r414
+              r745
 #include "includes.h"
+#include "registry.h"
+#include "lib/privileges.h"
 #undef DBGC_CLASS
 …
 static bool smbconf_reg_access_check(const char *keyname, uint32 requested,
                                      uint32 *granted,
                                      const struct nt_user_token *token)
+                                     const struct security_token *token)
+{
         if (!(user_has_privileges(token, &se_disk_operators))) {
+        if (!security_token_has_privilege(token, SEC_PRIV_DISK_OPERATOR)) {
                 return False;
+        }

trunk/server/source3/registry/reg_backend_tcpip_params.c

r414	r745
26	26
27	27	#include "includes.h"
	28	#include "registry.h"
	29	#include "reg_objects.h"
28	30
29	31	#undef DBGC_CLASS

trunk/server/source3/registry/reg_cachehook.c

-              r414
+              r745
  *  Virtual Windows Registry Layer
  *  Copyright (C) Gerald Carter                     2002.
+ *  Copyright (C) Michael Adam                      2008
+ *
  *  This program is free software; you can redistribute it and/or modify
 …
 #include "includes.h"
 #include "adt_tree.h"
+#include "registry.h"
+#include "reg_cachehook.h"
 #undef DBGC_CLASS
 #define DBGC_CLASS DBGC_REGISTRY
 static SORTED_TREE *cache_tree = NULL;
+static struct sorted_tree *cache_tree = NULL;
 extern struct registry_ops regdb_ops;           /* these are the default */
 …
         if (tmp_path == NULL) {
                 DEBUG(0, ("talloc_asprintf failed!\n"));
-                return WERR_NOMEM;
+        }
-        tmp_path = talloc_string_sub(mem_ctx, tmp_path, "\\", "/");
-        if (tmp_path == NULL) {
-                DEBUG(0, ("talloc_string_sub_failed!\n"));
                 return WERR_NOMEM;
+        }
 …
+        }
         cache_tree = pathtree_init(&regdb_ops, NULL);
+        cache_tree = pathtree_init(&regdb_ops);
         if (cache_tree == NULL) {
                 return WERR_NOMEM;
 …
 /**********************************************************************
  Add a new registry hook to the cache.  Note that the keyname
  is not in the exact format that a SORTED_TREE expects.
+ is not in the exact format that a struct sorted_tree expects.
  *********************************************************************/

trunk/server/source3/registry/reg_dispatcher.c

-              r414
+              r745
 #include "includes.h"
+#include "registry.h"
+#include "reg_dispatcher.h"
+#include "../libcli/security/security.h"
 #undef DBGC_CLASS
 …
 ********************************************************************/
 static WERROR construct_registry_sd(TALLOC_CTX *ctx, SEC_DESC **psd)
+{
         SEC_ACE ace[3];
+static WERROR construct_registry_sd(TALLOC_CTX *ctx, struct security_descriptor **psd)
+{
+        struct security_ace ace[3];
         size_t i = 0;
         SEC_DESC *sd;
         SEC_ACL *theacl;
+        struct security_descriptor *sd;
+        struct security_acl *theacl;
         size_t sd_size;
 …
+        }
         sd = make_sec_desc(ctx, SEC_DESC_REVISION, SEC_DESC_SELF_RELATIVE,
+        sd = make_sec_desc(ctx, SD_REVISION, SEC_DESC_SELF_RELATIVE,
                            &global_sid_Builtin_Administrators,
                            &global_sid_System, NULL, theacl,
 …
 bool regkey_access_check(struct registry_key_handle *key, uint32 requested,
                          uint32 *granted,
                          const struct nt_user_token *token )
+{
         SEC_DESC *sec_desc;
+                         const struct security_token *token )
+{
+        struct security_descriptor *sec_desc;
         NTSTATUS status;
         WERROR err;
+        /* root free-pass, like we have on all other pipes like samr, lsa, etc. */
+        if (geteuid() == sec_initial_uid()) {
+                *granted = REG_KEY_ALL;
+                return true;
+        }
         /* use the default security check if the backend has not defined its

trunk/server/source3/registry/reg_init_basic.c

-              r414
+              r745
 #include "includes.h"
+#include "registry.h"
+#include "reg_init_basic.h"
+#include "reg_cachehook.h"
+#include "reg_backend_db.h"
 #undef DBGC_CLASS

trunk/server/source3/registry/reg_init_full.c

-              r414
+              r745
 #include "includes.h"
+#include "registry.h"
+#include "reg_cachehook.h"
+#include "reg_backend_db.h"
+#include "reg_init_basic.h"
+#include "reg_init_full.h"
 #undef DBGC_CLASS
 …
 /* #define REG_TDB_ONLY         1 */
+struct registry_hook {
+        const char      *keyname;       /* full path to name of key */
+        struct registry_ops     *ops;   /* registry function hooks */
+};
 struct registry_hook reg_hooks[] = {
 #ifndef REG_TDB_ONLY
   { KEY_PRINTING,               &printing_ops },
   { KEY_PRINTING_2K,            &printing_ops },
   { KEY_PRINTING_PORTS,         &printing_ops },
+  { KEY_PRINTING "\\Printers",  &printing_ops },
+  { KEY_PRINTING_2K,            &regdb_ops },
+  { KEY_PRINTING_PORTS,         &regdb_ops },
   { KEY_SHARES,                 &shares_reg_ops },
   { KEY_SMBCONF,                &smbconf_reg_ops },
 …
                 reghook_dump_cache(20);
-        /* add any keys for other services */
-        svcctl_init_keys();
-        eventlog_init_keys();
-        perfcount_init_keys();
 fail:
         /* close and let each smbd open up as necessary */

trunk/server/source3/registry/reg_init_smbconf.c

-              r414
+              r745
 #include "includes.h"
+#include "registry.h"
+#include "reg_cachehook.h"
+#include "reg_backend_db.h"
+#include "reg_init_basic.h"
+#include "reg_init_smbconf.h"
 #undef DBGC_CLASS
 …
 extern struct registry_ops smbconf_reg_ops;
-/*
- * create a fake token just with enough rights to
- * locally access the registry:
+ *
- * - builtin administrators sid
- * - disk operators privilege
- */
-NTSTATUS registry_create_admin_token(TALLOC_CTX *mem_ctx,
-                                     NT_USER_TOKEN **ptoken)
+{
-        NTSTATUS status;
-        NT_USER_TOKEN *token = NULL;
-        if (ptoken == NULL) {
-                return NT_STATUS_INVALID_PARAMETER;
+        }
-        token = TALLOC_ZERO_P(mem_ctx, NT_USER_TOKEN);
-        if (token == NULL) {
-                DEBUG(1, ("talloc failed\n"));
-                status = NT_STATUS_NO_MEMORY;
-                goto done;
+        }
-        token->privileges = se_disk_operators;
-        status = add_sid_to_array(token, &global_sid_Builtin_Administrators,
-                                  &token->user_sids, &token->num_sids);
-        if (!NT_STATUS_IS_OK(status)) {
-                DEBUG(1, ("Error adding builtin administrators sid "
-                          "to fake token.\n"));
-                goto done;
+        }
-        *ptoken = token;
-done:
-        return status;
+}
 /*

trunk/server/source3/registry/reg_objects.c

-              r414
+              r745
  *  Virtual Windows Registry Layer
  *  Copyright (C) Gerald Carter                     2002-2005
+ *  Copyright (C) Michael Adam                      2007-2010
+ *
  *  This program is free software; you can redistribute it and/or modify
 …
 #include "includes.h"
+#include "registry.h"
+#include "reg_objects.h"
+#include "util_tdb.h"
+#include "dbwrap.h"
+#include "../libcli/registry/util_reg.h"
 #undef DBGC_CLASS
 #define DBGC_CLASS DBGC_REGISTRY
+/* low level structure to contain registry values */
+struct regval_blob {
+        fstring         valuename;
+        uint32_t        type;
+        /* this should be encapsulated in an RPC_DATA_BLOB */
+        uint32_t        size;   /* in bytes */
+        uint8_t         *data_p;
+};
+/* container for registry values */
+struct regval_ctr {
+        uint32_t num_values;
+        struct regval_blob **values;
+        int seqnum;
+};
 struct regsubkey_ctr {
 …
 static WERROR regsubkey_ctr_hash_keyname(struct regsubkey_ctr *ctr,
                                          const char *keyname,
                                          uint32 idx)
+                                         uint32_t idx)
+{
         WERROR werr;
 …
         werr = ntstatus_to_werror(dbwrap_store_bystring_upper(ctr->subkeys_hash,
                                                 keyname,
                                                 make_tdb_data((uint8 *)&idx,
+                                                make_tdb_data((uint8_t *)&idx,
                                                               sizeof(idx)),
                                                 TDB_REPLACE));
 …
 static WERROR regsubkey_ctr_index_for_keyname(struct regsubkey_ctr *ctr,
                                               const char *keyname,
                                               uint32 *idx)
+                                              uint32_t *idx)
+{
         TDB_DATA data;
 …
         if (idx != NULL) {
                 *idx = *(uint32 *)data.dptr;
+                *idx = *(uint32_t *)data.dptr;
+        }
 …
+{
         WERROR werr;
         uint32 idx, j;
+        uint32_t idx, j;
         if (keyname == NULL) {
 …
  */
+/**
+ * allocate a regval_ctr structure.
+ */
+WERROR regval_ctr_init(TALLOC_CTX *mem_ctx, struct regval_ctr **ctr)
+{
+        if (ctr == NULL) {
+                return WERR_INVALID_PARAM;
+        }
+        *ctr = talloc_zero(mem_ctx, struct regval_ctr);
+        if (*ctr == NULL) {
+                return WERR_NOMEM;
+        }
+        return WERR_OK;
+}
 /***********************************************************************
  How many keys does the container hold ?
 …
         if ( val->data_p && val->size )
+        {
                 if ( !(copy->data_p = (uint8 *)memdup( val->data_p,
+                if ( !(copy->data_p = (uint8_t *)memdup( val->data_p,
                                                        val->size )) ) {
                         DEBUG(0,("dup_registry_value: memdup() failed for [%d] "
 …
  *********************************************************************/
 uint8* regval_data_p(struct regval_blob *val)
+uint8_t* regval_data_p(struct regval_blob *val)
+{
         return val->data_p;
 …
  *********************************************************************/
 uint32 regval_size(struct regval_blob *val)
+uint32_t regval_size(struct regval_blob *val)
+{
         return val->size;
 …
  *********************************************************************/
 uint32 regval_type(struct regval_blob *val)
+uint32_t regval_type(struct regval_blob *val)
+{
         return val->type;
 …
 struct regval_blob *regval_ctr_specific_value(struct regval_ctr *ctr,
                                               uint32 idx)
+                                              uint32_t idx)
+{
         if ( !(idx < ctr->num_values) )
 …
 struct regval_blob *regval_compose(TALLOC_CTX *ctx, const char *name,
                                    uint16 type,
                                    const char *data_p, size_t size)
+                                   uint32_t type,
+                                   const uint8_t *data_p, size_t size)
+{
         struct regval_blob *regval = TALLOC_P(ctx, struct regval_blob);
 …
         regval->type = type;
         if (size) {
                 regval->data_p = (uint8 *)TALLOC_MEMDUP(regval, data_p, size);
+                regval->data_p = (uint8_t *)TALLOC_MEMDUP(regval, data_p, size);
                 if (!regval->data_p) {
                         TALLOC_FREE(regval);
 …
  **********************************************************************/
 int regval_ctr_addvalue(struct regval_ctr *ctr, const char *name, uint16 type,
                         const char *data_p, size_t size)
+int regval_ctr_addvalue(struct regval_ctr *ctr, const char *name, uint32_t type,
+                        const uint8_t *data_p, size_t size)
+{
         if ( !name )
 …
         return regval_ctr_addvalue(ctr, name, REG_SZ,
                                    (const char *)blob.data,
+                                   (const uint8_t *)blob.data,
                                    blob.length);
+}
 …
         return regval_ctr_addvalue(ctr, name, REG_MULTI_SZ,
                                    (const char *)blob.data,
+                                   (const uint8_t *)blob.data,
                                    blob.length);
+}
 …
         if ( val ) {
                 regval_ctr_addvalue(ctr, val->valuename, val->type,
                                     (char *)val->data_p, val->size);
+                                    (uint8_t *)val->data_p, val->size);
+        }
 …
+}
+/***********************************************************************
+ return the data_p as a uint32
+ **********************************************************************/
+uint32 regval_dword(struct regval_blob *val)
+{
+        uint32 data;
+int regval_ctr_get_seqnum(struct regval_ctr *ctr)
+{
+        if (ctr == NULL) {
+                return -1;
+        }
+        return ctr->seqnum;
+}
+WERROR regval_ctr_set_seqnum(struct regval_ctr *ctr, int seqnum)
+{
+        if (ctr == NULL) {
+                return WERR_INVALID_PARAM;
+        }
+        ctr->seqnum = seqnum;
+        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 );

trunk/server/source3/registry/reg_perfcount.c

-              r414
+              r745
 #include "includes.h"
+#include "system/filesys.h"
+#include "../librpc/gen_ndr/perfcount.h"
+#include "registry.h"
+#include "reg_perfcount.h"
+#include "../libcli/registry/util_reg.h"
+#include "util_tdb.h"
 #undef DBGC_CLASS
 …
         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) {
 …
         TALLOC_FREE(path);
         return ret;
+}
-/*********************************************************************
-*********************************************************************/
-void perfcount_init_keys( void )
+{
-        char *p = state_path(PERFCOUNTDIR);
-        /* no registry keys; just create the perfmon directory */
-        if ( !directory_exist( p ) )
-                mkdir( p, 0755 );
-        return;
+}
 …
         memset(buf, 0, PERFCOUNT_MAX_LEN);
         memcpy(buf, data.dptr, data.dsize);
         begin = index(buf, '[');
         end = index(buf, ']');
+        begin = strchr(buf, '[');
+        end = strchr(buf, ']');
         if(begin == NULL || end == NULL)
                 return False;
 …
         while(start < end) {
                 stop = index(start, ',');
+                stop = strchr(start, ',');
                 if(stop == NULL)
                         stop = end;

trunk/server/source3/registry/regfio.c

-              r414
+              r745
 #include "includes.h"
+#include "system/filesys.h"
 #include "regfio.h"
+#include "../librpc/gen_ndr/ndr_security.h"
+#include "../libcli/security/security_descriptor.h"
 #undef DBGC_CLASS
 …
  ******************************************************************/
+#if defined(PARANOID_MALLOC_CHECKER)
+#define PRS_ALLOC_MEM(ps, type, count) (type *)prs_alloc_mem_((ps),sizeof(type),(count))
+#else
+#define PRS_ALLOC_MEM(ps, type, count) (type *)prs_alloc_mem((ps),sizeof(type),(count))
+#endif
+/*******************************************************************
+ Reads or writes an NTTIME structure.
+********************************************************************/
+static bool smb_io_time(const char *desc, NTTIME *nttime, prs_struct *ps, int depth)
+{
+        uint32 low, high;
+        if (nttime == NULL)
+                return False;
+        prs_debug(ps, depth, desc, "smb_io_time");
+        depth++;
+        if(!prs_align(ps))
+                return False;
+        if (MARSHALLING(ps)) {
+                low = *nttime & 0xFFFFFFFF;
+                high = *nttime >> 32;
+        }
+        if(!prs_uint32("low ", ps, depth, &low)) /* low part */
+                return False;
+        if(!prs_uint32("high", ps, depth, &high)) /* high part */
+                return False;
+        if (UNMARSHALLING(ps)) {
+                *nttime = (((uint64_t)high << 32) + low);
+        }
+        return True;
+}
 /*******************************************************************
 …
 *******************************************************************/
 static REGF_SK_REC* find_sk_record_by_sec_desc( REGF_FILE *file, SEC_DESC *sd )
+static REGF_SK_REC* find_sk_record_by_sec_desc( REGF_FILE *file, struct security_descriptor *sd )
+{
         REGF_SK_REC *p;
 …
         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);
         hbin->block_size     = block_size;
 …
 *******************************************************************/
 static uint32 sk_record_data_size( SEC_DESC * sd )
+static uint32 sk_record_data_size( struct security_descriptor * sd )
+{
         uint32 size, size_mod8;
 …
         /* the record size is sizeof(hdr) + name + static members + data_size_field */
         size = sizeof(uint32)*5 + ndr_size_security_descriptor(sd, NULL, 0) + sizeof(uint32);
+        size = sizeof(uint32)*5 + ndr_size_security_descriptor(sd, 0) + sizeof(uint32);
         /* multiple of 8 */
 …
  REGF_NK_REC* regfio_write_key( REGF_FILE *file, const char *name,
                                struct regval_ctr *values, struct regsubkey_ctr *subkeys,
                                SEC_DESC *sec_desc, REGF_NK_REC *parent )
+                               struct security_descriptor *sec_desc, REGF_NK_REC *parent )
+{
         REGF_NK_REC *nk;
 …
                 /* sort the list by keyname */
+                qsort( parent->subkeys.hashes, parent->subkey_index, sizeof(REGF_HASH_REC), QSORT_CAST hashrec_cmp );
+                TYPESAFE_QSORT(parent->subkeys.hashes, parent->subkey_index, hashrec_cmp);
                 if ( !hbin_prs_lf_records( "lf_rec", parent->subkeys.hbin, 0, parent ) )
 …
                         /* size value must be self-inclusive */
                         nk->sec_desc->size      = ndr_size_security_descriptor(sec_desc, NULL, 0)
+                        nk->sec_desc->size      = ndr_size_security_descriptor(sec_desc, 0)
                                 + sizeof(uint32);
 …
                            offsets to ourself. */
                         if ( nk->sec_desc->prev ) {
                                 REGF_SK_REC *prev = nk->sec_desc->prev;
+                        if ( DLIST_PREV(nk->sec_desc) ) {
+                                REGF_SK_REC *prev = DLIST_PREV(nk->sec_desc);
                                 nk->sec_desc->prev_sk_off = prev->hbin_off + prev->hbin->first_hbin_off - HBIN_HDR_SIZE;

Context Navigation

Legend:

trunk/server

trunk/server/source3/registry/reg_api.c

trunk/server/source3/registry/reg_backend_current_version.c

trunk/server/source3/registry/reg_backend_db.c

trunk/server/source3/registry/reg_backend_hkpt_params.c

trunk/server/source3/registry/reg_backend_netlogon_params.c

trunk/server/source3/registry/reg_backend_perflib.c

trunk/server/source3/registry/reg_backend_printing.c

trunk/server/source3/registry/reg_backend_prod_options.c

trunk/server/source3/registry/reg_backend_shares.c

trunk/server/source3/registry/reg_backend_smbconf.c

trunk/server/source3/registry/reg_backend_tcpip_params.c

trunk/server/source3/registry/reg_cachehook.c

trunk/server/source3/registry/reg_dispatcher.c

trunk/server/source3/registry/reg_init_basic.c

trunk/server/source3/registry/reg_init_full.c

trunk/server/source3/registry/reg_init_smbconf.c

trunk/server/source3/registry/reg_objects.c

trunk/server/source3/registry/reg_perfcount.c

trunk/server/source3/registry/regfio.c

Download in other formats: