Changeset 751 for trunk/server/source3/registry/reg_api.c

Timestamp:

Nov 29, 2012, 1:59:04 PM (13 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: updated trunk to 3.6.9

File:

• trunk/server/source3/registry/reg_api.c (modified) (25 diffs)

trunk/server/source3/registry/reg_api.c

@@ -90 +90 @@
         }
 
+        TALLOC_FREE(key->values);
         werr = regval_ctr_init(key, &(key->values));
         W_ERROR_NOT_OK_RETURN(werr);
@@ -116 +117 @@
         if (fetch_reg_keys(key->key, key->subkeys) == -1) {
                 TALLOC_FREE(key->subkeys);
-                return WERR_NO_MORE_ITEMS;
+                return WERR_BADFILE;
         }
 
@@ -137 +138 @@
         struct registry_key *regkey;
         struct registry_key_handle *key;
-        struct regsubkey_ctr    *subkeys = NULL;
 
         DEBUG(7,("regkey_open_onelevel: name = [%s]\n", name));
@@ -151 +151 @@
         }
 
-        if ( !(W_ERROR_IS_OK(result = regdb_open())) ) {
+        result = regdb_open();
+        if (!(W_ERROR_IS_OK(result))) {
                 goto done;
         }
@@ -194 +195 @@
         /* 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 ));
@@ -201 +203 @@
         }
 
-        /* check if the path really exists; failed is indicated by -1 */
-        /* if the subkey count failed, bail out */
-
-        result = regsubkey_ctr_init(key, &subkeys);
+        /* FIXME: Existence is currently checked by fetching the subkeys */
+
+        result = fill_subkey_cache(regkey);
         if (!W_ERROR_IS_OK(result)) {
                 goto done;
         }
-
-        if ( fetch_reg_keys( key, subkeys ) == -1 )  {
-                result = WERR_BADFILE;
-                goto done;
-        }
-
-        TALLOC_FREE( subkeys );
 
         if ( !regkey_access_check( key, access_desired, &key->access_granted,
@@ -257 +251 @@
         struct registry_key *direct_parent = parent;
         WERROR err;
-        char *p, *path, *to_free;
+        char *p, *path;
         size_t len;
-
-        if (!(path = SMB_STRDUP(name))) {
-                return WERR_NOMEM;
-        }
-        to_free = path;
+        TALLOC_CTX *frame = talloc_stackframe();
+
+        path = talloc_strdup(frame, name);
+        if (path == NULL) {
+                err = WERR_NOMEM;
+                goto error;
+        }
 
         len = strlen(path);
@@ -275 +271 @@
                 struct registry_key *tmp;
 
-                if (!(name_component = SMB_STRNDUP(path, (p - path)))) {
+                name_component = talloc_strndup(frame, path, (p - path));
+                if (name_component == NULL) {
                         err = WERR_NOMEM;
                         goto error;
                 }
 
-                err = regkey_open_onelevel(mem_ctx, direct_parent,
+                err = regkey_open_onelevel(frame, direct_parent,
                                            name_component, parent->token,
                                            KEY_ENUMERATE_SUB_KEYS, &tmp);
-                SAFE_FREE(name_component);
 
                 if (!W_ERROR_IS_OK(err)) {
                         goto error;
                 }
-                if (direct_parent != parent) {
-                        TALLOC_FREE(direct_parent);
-                }
 
                 direct_parent = tmp;
@@ -298 +291 @@
         err = regkey_open_onelevel(mem_ctx, direct_parent, path, parent->token,
                                    desired_access, pkey);
- error:
-        if (direct_parent != parent) {
-                TALLOC_FREE(direct_parent);
-        }
-        SAFE_FREE(to_free);
+
+error:
+        talloc_free(frame);
         return err;
 }
@@ -376 +367 @@
 }
 
+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)
@@ -394 +422 @@
                 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 +558 @@
         char *path, *end;
         WERROR err;
-
-        if (!(mem_ctx = talloc_new(ctx))) return WERR_NOMEM;
-
-        if (!(path = talloc_strdup(mem_ctx, subkeypath))) {
+        uint32_t access_granted;
+
+        mem_ctx = talloc_new(ctx);
+        if (mem_ctx == NULL) {
+                return WERR_NOMEM;
+        }
+
+        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;
         }
@@ -540 +587 @@
                                     KEY_ENUMERATE_SUB_KEYS, &tmp, &action);
                 if (!W_ERROR_IS_OK(err)) {
-                        goto done;
+                        goto trans_done;
                 }
 
@@ -561 +608 @@
                         *paction = REG_OPENED_EXISTING_KEY;
                 }
-                goto done;
+                goto trans_done;
         }
 
@@ -568 +615 @@
                  * Something but "notfound" has happened, so bail out
                  */
-                goto done;
+                goto trans_done;
         }
 
         /*
-         * We have to make a copy of the current key, as we opened it only
-         * with ENUM_SUBKEY access.
+         * We may (e.g. in the iteration) have opened the key with ENUM_SUBKEY.
+         * Instead of re-opening the key with CREATE_SUB_KEY, we simply
+         * duplicate the access check here and skip the expensive full open.
          */
-
-        err = reg_openkey(mem_ctx, key, "", KEY_CREATE_SUB_KEY,
-                          &create_parent);
-        if (!W_ERROR_IS_OK(err)) {
+        if (!regkey_access_check(key->key, KEY_CREATE_SUB_KEY, &access_granted,
+                                 key->token))
+        {
+                err = WERR_ACCESS_DENIED;
                 goto done;
         }
@@ -586 +634 @@
          */
 
-        err = fill_subkey_cache(create_parent);
-        if (!W_ERROR_IS_OK(err)) goto done;
-
         err = create_reg_subkey(key->key, path);
-        W_ERROR_NOT_OK_GOTO_DONE(err);
+        if (!W_ERROR_IS_OK(err)) {
+                goto trans_done;
+        }
 
         /*
@@ -596 +643 @@
          */
 
-        err = reg_openkey(ctx, create_parent, path, desired_access, pkey);
+        err = reg_openkey(ctx, key, path, desired_access, pkey);
         if (W_ERROR_IS_OK(err) && (paction != NULL)) {
                 *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)));
+                }
         }
 
@@ -623 +683 @@
         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;
         }
 
@@ -638 +705 @@
                 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;
@@ -646 +713 @@
         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:
@@ -667 +747 @@
         }
 
-        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;
         }
 
@@ -676 +765 @@
             (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;
         }
 
@@ -685 +776 @@
         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;
-        }
-
-        return WERR_OK;
+                DEBUG(0, ("reg_setvalue: store_reg_values failed\n"));
+                err = WERR_REG_IO_FAILURE;
+                goto done;
+        }
+
+        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;
 }
 
@@ -717 +826 @@
         }
 
-        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;
         }
 
@@ -730 +849 @@
         if (!store_reg_values(key->key, key->values)) {
                 TALLOC_FREE(key->values);
-                return WERR_REG_IO_FAILURE;
-        }
-
-        return WERR_OK;
+                err = WERR_REG_IO_FAILURE;
+                DEBUG(0, ("reg_deletevalue: store_reg_values failed\n"));
+                goto done;
+        }
+
+        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;
 }