s3:registry: untangle assignments from checks in reg_createkey() (cherry picked from...

[ddiss/samba.git] / source3 / registry / reg_api.c

diff --git a/source3/registry/reg_api.c b/source3/registry/reg_api.c
index 935d2441afa5fdf1e282dd16d631abf4e4b859e1..b8d8f2cc29f6873fbf682626f6f880b7eef9850d 100644 (file)
--- a/source3/registry/reg_api.c
+++ b/source3/registry/reg_api.c
@@ -89,6 +89,7 @@ static WERROR fill_value_cache(struct registry_key *key)
                }
        }
 
+       TALLOC_FREE(key->values);
        werr = regval_ctr_init(key, &(key->values));
        W_ERROR_NOT_OK_RETURN(werr);
 
@@ -375,6 +376,43 @@ WERROR reg_enumvalue(TALLOC_CTX *mem_ctx, struct registry_key *key,
        return WERR_OK;
 }
 
+static WERROR reg_enumvalue_nocachefill(TALLOC_CTX *mem_ctx,
+                                       struct registry_key *key,
+                                       uint32 idx, char **pname,
+                                       struct registry_value **pval)
+{
+       struct registry_value *val;
+       struct regval_blob *blob;
+
+       if (!(key->key->access_granted & KEY_QUERY_VALUE)) {
+               return WERR_ACCESS_DENIED;
+       }
+
+       if (idx >= regval_ctr_numvals(key->values)) {
+               return WERR_NO_MORE_ITEMS;
+       }
+
+       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, regval_name(blob)))) {
+               TALLOC_FREE(val);
+               return WERR_NOMEM;
+       }
+
+       *pval = val;
+       return WERR_OK;
+}
+
 WERROR reg_queryvalue(TALLOC_CTX *mem_ctx, struct registry_key *key,
                      const char *name, struct registry_value **pval)
 {
@@ -393,7 +431,14 @@ WERROR reg_queryvalue(TALLOC_CTX *mem_ctx, struct registry_key *key,
                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);
+                       /*
+                        * don't use reg_enumvalue here:
+                        * re-reading the values from the disk
+                        * would change the indexing and break
+                        * this function.
+                        */
+                       return reg_enumvalue_nocachefill(mem_ctx, key, i,
+                                                        NULL, pval);
                }
        }
 
@@ -523,9 +568,13 @@ WERROR reg_createkey(TALLOC_CTX *ctx, struct registry_key *parent,
        char *path, *end;
        WERROR err;
 
-       if (!(mem_ctx = talloc_new(ctx))) return WERR_NOMEM;
+       mem_ctx = talloc_new(ctx);
+       if (mem_ctx == NULL) {
+               return WERR_NOMEM;
+       }
 
-       if (!(path = talloc_strdup(mem_ctx, subkeypath))) {
+       path = talloc_strdup(mem_ctx, subkeypath);
+       if (path == NULL) {
                err = WERR_NOMEM;
                goto done;
        }
@@ -666,17 +715,28 @@ WERROR reg_setvalue(struct registry_key *key, const char *name,
                return WERR_ACCESS_DENIED;
        }
 
-       if (!W_ERROR_IS_OK(err = fill_value_cache(key))) {
+       err = regdb_transaction_start();
+       if (!W_ERROR_IS_OK(err)) {
+               DEBUG(0, ("reg_setvalue: Failed to start transaction: %s\n",
+                         win_errstr(err)));
                return err;
        }
 
+       err = fill_value_cache(key);
+       if (!W_ERROR_IS_OK(err)) {
+               DEBUG(0, ("reg_setvalue: Error filling value cache: %s\n", win_errstr(err)));
+               goto done;
+       }
+
        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;
+                   val->data.length) == 0))
+       {
+               err = WERR_OK;
+               goto done;
        }
 
        res = regval_ctr_addvalue(key->values, name, val->type,
@@ -684,15 +744,33 @@ WERROR reg_setvalue(struct registry_key *key, const char *name,
 
        if (res == 0) {
                TALLOC_FREE(key->values);
-               return WERR_NOMEM;
+               err = WERR_NOMEM;
+               goto done;
        }
 
        if (!store_reg_values(key->key, key->values)) {
                TALLOC_FREE(key->values);
-               return WERR_REG_IO_FAILURE;
+               DEBUG(0, ("reg_setvalue: store_reg_values failed\n"));
+               err = WERR_REG_IO_FAILURE;
+               goto done;
        }
 
-       return WERR_OK;
+       err = WERR_OK;
+
+done:
+       if (W_ERROR_IS_OK(err)) {
+               err = regdb_transaction_commit();
+               if (!W_ERROR_IS_OK(err)) {
+                       DEBUG(0, ("reg_setvalue: Error committing transaction: %s\n", win_errstr(err)));
+               }
+       } else {
+               WERROR err1 = regdb_transaction_cancel();
+               if (!W_ERROR_IS_OK(err1)) {
+                       DEBUG(0, ("reg_setvalue: Error cancelling transaction: %s\n", win_errstr(err1)));
+               }
+       }
+
+       return err;
 }
 
 static WERROR reg_value_exists(struct registry_key *key, const char *name)
@@ -716,23 +794,50 @@ WERROR reg_deletevalue(struct registry_key *key, const char *name)
                return WERR_ACCESS_DENIED;
        }
 
-       if (!W_ERROR_IS_OK(err = fill_value_cache(key))) {
+       err = regdb_transaction_start();
+       if (!W_ERROR_IS_OK(err)) {
+               DEBUG(0, ("reg_deletevalue: Failed to start transaction: %s\n",
+                         win_errstr(err)));
                return err;
        }
 
+       err = fill_value_cache(key);
+       if (!W_ERROR_IS_OK(err)) {
+               DEBUG(0, ("reg_deletevalue; Error filling value cache: %s\n",
+                         win_errstr(err)));
+               goto done;
+       }
+
        err = reg_value_exists(key, name);
        if (!W_ERROR_IS_OK(err)) {
-               return err;
+               goto done;
        }
 
        regval_ctr_delvalue(key->values, name);
 
        if (!store_reg_values(key->key, key->values)) {
                TALLOC_FREE(key->values);
-               return WERR_REG_IO_FAILURE;
+               err = WERR_REG_IO_FAILURE;
+               DEBUG(0, ("reg_deletevalue: store_reg_values failed\n"));
+               goto done;
        }
 
-       return WERR_OK;
+       err = WERR_OK;
+
+done:
+       if (W_ERROR_IS_OK(err)) {
+               err = regdb_transaction_commit();
+               if (!W_ERROR_IS_OK(err)) {
+                       DEBUG(0, ("reg_deletevalue: Error committing transaction: %s\n", win_errstr(err)));
+               }
+       } else {
+               WERROR err1 = regdb_transaction_cancel();
+               if (!W_ERROR_IS_OK(err1)) {
+                       DEBUG(0, ("reg_deletevalue: Error cancelling transaction: %s\n", win_errstr(err1)));
+               }
+       }
+
+       return err;
 }
 
 WERROR reg_getkeysecurity(TALLOC_CTX *mem_ctx, struct registry_key *key,