Changeset 751 for trunk/server/source3/registry

Timestamp:

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

Author:

Silvan Scherrer

Message:

Samba Server: updated trunk to 3.6.9

Location:

trunk/server/source3/registry

Files:

• reg_api.c (modified) (25 diffs)
• reg_backend_db.c (modified) (11 diffs)
• reg_backend_smbconf.c (modified) (2 diffs)
• reg_format.c (modified) (3 diffs)
• reg_objects.c (modified) (2 diffs)
• reg_objects.h (modified) (1 diff)
• reg_parse.c (modified) (1 diff)
• regfio.c (modified) (1 diff)

trunk/server/source3/registry/reg_api.c

@@ -90 +90 @@
         }
 
+
         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_;
         }
 
@@ -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(, 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 @@
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 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;
         }
@@ -540 +587 @@
                                     KEY_ENUMERATE_SUB_KEYS, &tmp, &action);
                 if (!W_ERROR_IS_OK(err)) {
-                        goto done;
+                        goto done;
                 }
 
@@ -561 +608 @@
                         *paction = REG_OPENED_EXISTING_KEY;
                 }
-                goto done;
+                goto done;
         }
 
@@ -568 +615 @@
                  * Something but "notfound" has happened, so bail out
                  */
-                goto done;
+                goto 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,
+        
+        
+        
                 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, , path, desired_access, pkey);
         if (W_ERROR_IS_OK(err) && (paction != NULL)) {
                 *paction = REG_CREATED_NEW_KEY;
+
+
+
+
+
+
+
+
+
+
+
+
+
         }
 
@@ -623 +683 @@
         W_ERROR_NOT_OK_GOTO_DONE(err);
 
+
+
+
+
+
+
+
         err = fill_subkey_cache(key);
-        W_ERROR_NOT_OK_GOTO_DONE(err);
+        W_ERROR_NOT_OK_GOTO);
 
         if (regsubkey_ctr_numkeys(key->subkeys) > 0) {
                 err = WERR_ACCESS_DENIED;
-                goto done;
+                goto 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);
 
                 parent = tmp_key;
@@ -646 +713 @@
         if (name[0] == '\0') {
                 err = WERR_INVALID_PARAM;
-                goto done;
+                goto done;
         }
 
         err = delete_reg_subkey(parent->key, name);
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 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;
+
+
+
+
+
+
         }
 
@@ -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 = reg_value_exists(key, name);
         if (!W_ERROR_IS_OK(err)) {
-                return err;
+                ;
         }
 
@@ -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;
 }
 

trunk/server/source3/registry/reg_backend_db.c

@@ -321 +321 @@
                 /* preserve existing values across restarts. Only add new ones */
 
-                if (!regval_ctr_key_exists(values,
+                if (!regval_ctr__exists(values,
                                         builtin_registry_values[i].valuename))
                 {
@@ -365 +365 @@
                                             builtin_registry_values[i].path,
                                             values);
-                if (!regval_ctr_key_exists(values,
+                if (!regval_ctr__exists(values,
                                         builtin_registry_values[i].valuename))
                 {
@@ -985 +985 @@
         }
 
-        werr = WERR_OK;
+        /*
+         * Update the seqnum in the container to possibly
+         * prevent next read from going to disk
+         */
+        werr = regsubkey_ctr_set_seqnum(store_ctx->ctr, db->get_seqnum(db));
 
 done:
@@ -1612 +1616 @@
         TALLOC_CTX *frame = talloc_stackframe();
         TDB_DATA value;
+
 
         DEBUG(11,("regdb_fetch_keys: Enter key => [%s]\n", key ? key : "NULL"));
@@ -1621 +1626 @@
         }
 
-        werr = regsubkey_ctr_set_seqnum(ctr, db->get_seqnum(db));
+        werr = regsubkey_ctr_);
         W_ERROR_NOT_OK_GOTO_DONE(werr);
 
-        value = regdb_fetch_key_internal(db, frame, key);
+        count = 0;
+        ZERO_STRUCT(value);
+        seqnum[0] = db->get_seqnum(db);
+
+        do {
+                count++;
+                TALLOC_FREE(value.dptr);
+                value = regdb_fetch_key_internal(db, frame, key);
+                seqnum[count % 2] = db->get_seqnum(db);
+
+        } while (seqnum[0] != seqnum[1]);
+
+        if (count > 1) {
+                DEBUG(5, ("regdb_fetch_keys_internal: it took %d attempts to "
+                          "fetch key '%s' with constant seqnum\n",
+                          count, key));
+        }
+
+        werr = regsubkey_ctr_set_seqnum(ctr, seqnum[0]);
+        if (!W_ERROR_IS_OK(werr)) {
+                goto done;
+        }
 
         if (value.dsize == 0 || value.dptr == NULL) {
@@ -1639 +1665 @@
                 goto done;
         }
-
-        werr = regsubkey_ctr_reinit(ctr);
-        W_ERROR_NOT_OK_GOTO_DONE(werr);
 
         for (i=0; i<num_items; i++) {
@@ -1708 +1731 @@
                 SAFE_FREE(data_p); /* 'B' option to tdb_unpack does a malloc() */
 
-                DEBUG(8,("specific: [%s], len: %d\n", valuename, size));
+                DEBUG(10, ("regdb_unpack_values: value[%d]: name[%s] len[%d]\n",
+                           i, valuename, size));
         }
 
@@ -1761 +1785 @@
         TDB_DATA value;
         WERROR werr;
-
-        DEBUG(10,("regdb_fetch_values: Looking for value of key [%s] \n", key));
+        int seqnum[2], count;
+
+        DEBUG(10,("regdb_fetch_values: Looking for values of key [%s]\n", key));
 
         if (!regdb_key_exists(db, key)) {
+
+
+
                 goto done;
         }
@@ -1773 +1801 @@
         }
 
-        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);
+        ZERO_STRUCT(value);
+        count = 0;
+        seqnum[0] = db->get_seqnum(db);
+
+        do {
+                count++;
+                TALLOC_FREE(value.dptr);
+                value = regdb_fetch_key_internal(db, ctx, keystr);
+                seqnum[count % 2] = db->get_seqnum(db);
+        } while (seqnum[0] != seqnum[1]);
+
+        if (count > 1) {
+                DEBUG(5, ("regdb_fetch_values_internal: it took %d attempts "
+                          "to fetch key '%s' with constant seqnum\n",
+                          count, key));
+        }
+
+        werr = regval_ctr_set_seqnum(values, seqnum[0]);
+        if (!W_ERROR_IS_OK(werr)) {
+                goto done;
+        }
 
         if (!value.dptr) {
@@ -1805 +1850 @@
         NTSTATUS status;
         bool result = false;
-
-        DEBUG(10,("regdb_store_values: Looking for value of key [%s] \n", key));
+        WERROR werr;
+
+        DEBUG(10,("regdb_store_values: Looking for values of key [%s]\n", key));
 
         if (!regdb_key_exists(db, key)) {
@@ -1847 +1893 @@
 
         status = dbwrap_trans_store_bystring(db, keystr, data, TDB_REPLACE);
-
-        result = NT_STATUS_IS_OK(status);
+        if (!NT_STATUS_IS_OK(status)) {
+                DEBUG(0, ("regdb_store_values_internal: error storing: %s\n", nt_errstr(status)));
+                goto done;
+        }
+
+        /*
+         * update the seqnum in the cache to prevent the next read
+         * from going to disk
+         */
+        werr = regval_ctr_set_seqnum(values, db->get_seqnum(db));
+        result = W_ERROR_IS_OK(status);
 
 done:

trunk/server/source3/registry/reg_backend_smbconf.c

@@ -82 +82 @@
 }
 
+
+
+
+
+
+
+
+
+
 
 /*
@@ -97 +106 @@
         .get_secdesc = smbconf_get_secdesc,
         .set_secdesc = smbconf_set_secdesc,
+
+
 };

trunk/server/source3/registry/reg_format.c

@@ -25 +25 @@
  */
 
+
 #include "reg_format.h"
 #include "reg_parse.h"
@@ -326 +327 @@
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 int reg_format_value(struct reg_format* f, const char* name, uint32_t type,
                      const uint8_t* data, size_t len)
@@ -334 +350 @@
         switch (type) {
         case REG_SZ:
-                if (!(f->flags & REG_FMT_HEX_SZ)) {
+                if (!(f->flags & REG_FMT_HEX_SZ)
+                    && is_zero_terminated_ucs2(data, len))
+                {
                         char* str = NULL;
                         size_t dlen;

trunk/server/source3/registry/reg_objects.c

@@ -447 +447 @@
  **********************************************************************/
 
-bool regval_ctr_key_exists(struct regval_ctr *ctr, const char *value)
+bool regval_ctr__exists(struct regval_ctr *ctr, const char *value)
 {
         int     i;
@@ -458 +458 @@
         return False;
 }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 /***********************************************************************

trunk/server/source3/registry/reg_objects.h

@@ -56 +56 @@
 struct regval_blob* regval_ctr_specific_value(struct regval_ctr *ctr,
                                               uint32_t idx);
-bool regval_ctr_key_exists(struct regval_ctr *ctr, const char *value);
+struct regval_blob *regval_ctr_value_byname(struct regval_ctr *ctr,
+                                            const char *value);
+bool regval_ctr_value_exists(struct regval_ctr *ctr, const char *value);
 struct regval_blob *regval_compose(TALLOC_CTX *ctx, const char *name,
                                    uint32_t type,

trunk/server/source3/registry/reg_parse.c

@@ -794 +794 @@
                   (long unsigned)(linenum+1), pos));
 
-        assert(ilen > 0);
+        assert( > 0);
         do {
                 size_t il = 1;
                 DEBUGADD(0, ("<%02x>", (unsigned char)**iptr));
 
-                if (olen > 0) {
+                if ( > 0) {
                         *(*optr)++ = '\?';
                         (*iptr)++;

trunk/server/source3/registry/regfio.c

@@ -1468 +1468 @@
                 return NULL;
 
-        memcpy( hbin->header, "hbin", sizeof(HBIN_HDR_SIZE) );
+        memcpy( hbin->header, "hbin", );