s3:registry untangle an assignment from the check in regkey_open_onelevel() (cherry...

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

diff --git a/source3/registry/reg_api.c b/source3/registry/reg_api.c
index 6bdd18be7ce48668f5f9d51f7997f35196b87102..592f4e3ab0a8a7fe9d44dc7c94941ff4932b0935 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);
 
@@ -150,7 +151,8 @@ static WERROR regkey_open_onelevel(TALLOC_CTX *mem_ctx,
                goto done;
        }
 
-       if ( !(W_ERROR_IS_OK(result = regdb_open())) ) {
+       result = regdb_open();
+       if (!(W_ERROR_IS_OK(result))) {
                goto done;
        }
 
@@ -193,7 +195,8 @@ static WERROR regkey_open_onelevel(TALLOC_CTX *mem_ctx,
 
        /* Look up the table of registry I/O operations */
 
-       if ( !(key->ops = reghook_cache_find( key->name )) ) {
+       key->ops = reghook_cache_find( key->name );
+       if (key->ops == NULL) {
                DEBUG(0,("reg_open_onelevel: Failed to assign "
                         "registry_ops to [%s]\n", key->name ));
                result = WERR_BADFILE;
@@ -567,13 +570,24 @@ 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;
        }
 
+       err = regdb_transaction_start();
+       if (!W_ERROR_IS_OK(err)) {
+               DEBUG(0, ("reg_createkey: failed to start transaction: %s\n",
+                         win_errstr(err)));
+               goto done;
+       }
+
        while ((end = strchr(path, '\\')) != NULL) {
                struct registry_key *tmp;
                enum winreg_CreateAction action;
@@ -583,7 +597,7 @@ WERROR reg_createkey(TALLOC_CTX *ctx, struct registry_key *parent,
                err = reg_createkey(mem_ctx, key, path,
                                    KEY_ENUMERATE_SUB_KEYS, &tmp, &action);
                if (!W_ERROR_IS_OK(err)) {
-                       goto done;
+                       goto trans_done;
                }
 
                if (key != parent) {
@@ -604,14 +618,14 @@ WERROR reg_createkey(TALLOC_CTX *ctx, struct registry_key *parent,
                if (paction != NULL) {
                        *paction = REG_OPENED_EXISTING_KEY;
                }
-               goto done;
+               goto trans_done;
        }
 
        if (!W_ERROR_EQUAL(err, WERR_BADFILE)) {
                /*
                 * Something but "notfound" has happened, so bail out
                 */
-               goto done;
+               goto trans_done;
        }
 
        /*
@@ -622,7 +636,7 @@ WERROR reg_createkey(TALLOC_CTX *ctx, struct registry_key *parent,
        err = reg_openkey(mem_ctx, key, "", KEY_CREATE_SUB_KEY,
                          &create_parent);
        if (!W_ERROR_IS_OK(err)) {
-               goto done;
+               goto trans_done;
        }
 
        /*
@@ -630,10 +644,14 @@ WERROR reg_createkey(TALLOC_CTX *ctx, struct registry_key *parent,
         */
 
        err = fill_subkey_cache(create_parent);
-       if (!W_ERROR_IS_OK(err)) goto done;
+       if (!W_ERROR_IS_OK(err)) {
+               goto trans_done;
+       }
 
        err = create_reg_subkey(key->key, path);
-       W_ERROR_NOT_OK_GOTO_DONE(err);
+       if (!W_ERROR_IS_OK(err)) {
+               goto trans_done;
+       }
 
        /*
         * Now open the newly created key
@@ -644,6 +662,19 @@ WERROR reg_createkey(TALLOC_CTX *ctx, struct registry_key *parent,
                *paction = REG_CREATED_NEW_KEY;
        }
 
+trans_done:
+       if (W_ERROR_IS_OK(err)) {
+               err = regdb_transaction_commit();
+               if (!W_ERROR_IS_OK(err)) {
+                       DEBUG(0, ("reg_createkey: Error committing transaction: %s\n", win_errstr(err)));
+               }
+       } else {
+               WERROR err1 = regdb_transaction_cancel();
+               if (!W_ERROR_IS_OK(err1)) {
+                       DEBUG(0, ("reg_createkey: Error cancelling transaction: %s\n", win_errstr(err1)));
+               }
+       }
+
  done:
        TALLOC_FREE(mem_ctx);
        return err;
@@ -666,12 +697,19 @@ WERROR reg_deletekey(struct registry_key *parent, const char *path)
        err = reg_openkey(mem_ctx, parent, name, REG_KEY_READ, &key);
        W_ERROR_NOT_OK_GOTO_DONE(err);
 
+       err = regdb_transaction_start();
+       if (!W_ERROR_IS_OK(err)) {
+               DEBUG(0, ("reg_deletekey: Error starting transaction: %s\n",
+                         win_errstr(err)));
+               goto done;
+       }
+
        err = fill_subkey_cache(key);
-       W_ERROR_NOT_OK_GOTO_DONE(err);
+       W_ERROR_NOT_OK_GOTO(err, trans_done);
 
        if (regsubkey_ctr_numkeys(key->subkeys) > 0) {
                err = WERR_ACCESS_DENIED;
-               goto done;
+               goto trans_done;
        }
 
        /* no subkeys - proceed with delete */
@@ -681,7 +719,7 @@ WERROR reg_deletekey(struct registry_key *parent, const char *path)
 
                err = reg_openkey(mem_ctx, parent, name,
                                  KEY_CREATE_SUB_KEY, &tmp_key);
-               W_ERROR_NOT_OK_GOTO_DONE(err);
+               W_ERROR_NOT_OK_GOTO(err, trans_done);
 
                parent = tmp_key;
                name = end+1;
@@ -689,11 +727,24 @@ WERROR reg_deletekey(struct registry_key *parent, const char *path)
 
        if (name[0] == '\0') {
                err = WERR_INVALID_PARAM;
-               goto done;
+               goto trans_done;
        }
 
        err = delete_reg_subkey(parent->key, name);
 
+trans_done:
+       if (W_ERROR_IS_OK(err)) {
+               err = regdb_transaction_commit();
+               if (!W_ERROR_IS_OK(err)) {
+                       DEBUG(0, ("reg_deletekey: Error committing transaction: %s\n", win_errstr(err)));
+               }
+       } else {
+               WERROR err1 = regdb_transaction_cancel();
+               if (!W_ERROR_IS_OK(err1)) {
+                       DEBUG(0, ("reg_deletekey: Error cancelling transaction: %s\n", win_errstr(err1)));
+               }
+       }
+
 done:
        TALLOC_FREE(mem_ctx);
        return err;
@@ -710,17 +761,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,
@@ -728,15 +790,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)
@@ -760,23 +840,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,