X-Git-Url: http://git.samba.org/samba.git/?a=blobdiff_plain;f=source3%2Fregistry%2Freg_backend_db.c;h=4b8a4b4c374becd8a49678feb25795056beb2188;hb=fcdfff1cc8c1214cbce1fdd863b1ede970234121;hp=e162fb587f573f15b26d785c6f3a1bc82694c56e;hpb=eba5fbff749b84a3e1bcd1f849c3454417532454;p=kai%2Fsamba-autobuild%2F.git diff --git a/source3/registry/reg_backend_db.c b/source3/registry/reg_backend_db.c index e162fb587f5..4b8a4b4c374 100644 --- a/source3/registry/reg_backend_db.c +++ b/source3/registry/reg_backend_db.c @@ -24,8 +24,8 @@ #undef DBGC_CLASS #define DBGC_CLASS DBGC_REGISTRY -static struct tdb_wrap *tdb_reg = NULL; -static int tdb_refcount; +static struct db_context *regdb = NULL; +static int regdb_refcount; /* List the deepest path into the registry. All part components will be created.*/ @@ -46,6 +46,14 @@ static const char *builtin_registry_paths[] = { KEY_SMBCONF, KEY_PERFLIB, KEY_PERFLIB_009, + KEY_GROUP_POLICY, + KEY_SAMBA_GROUP_POLICY, + KEY_GP_MACHINE_POLICY, + KEY_GP_MACHINE_WIN_POLICY, + KEY_HKCU, + KEY_GP_USER_POLICY, + KEY_GP_USER_WIN_POLICY, + KEY_WINLOGON_GPEXT_PATH, "HKLM\\SYSTEM\\CurrentControlSet\\Control\\Print\\Monitors", KEY_PROD_OPTIONS, "HKLM\\SYSTEM\\CurrentControlSet\\Control\\Terminal Server\\DefaultUserConfiguration", @@ -79,157 +87,214 @@ static struct builtin_regkey_value builtin_registry_values[] = { { NULL, NULL, 0, { NULL } } }; -/*********************************************************************** - Open the registry data in the tdb - ***********************************************************************/ - -static bool init_registry_data( void ) +/** + * Initialize a key in the registry: + * create each component key of the specified path. + */ +static bool init_registry_key_internal(const char *add_path) { + bool ret = false; + TALLOC_CTX *frame = talloc_stackframe(); char *path = NULL; char *base = NULL; char *remaining = NULL; - TALLOC_CTX *frame = NULL; char *keyname; char *subkeyname; REGSUBKEY_CTR *subkeys; - REGVAL_CTR *values; - int i; const char *p, *p2; - UNISTR2 data; - /* - * There are potentially quite a few store operations which are all - * indiviually wrapped in tdb transactions. Wrapping them in a single - * transaction gives just a single transaction_commit() to actually do - * its fsync()s. See tdb/common/transaction.c for info about nested - * transaction behaviour. - */ + DEBUG(6, ("init_registry_key: Adding [%s]\n", add_path)); - if ( tdb_transaction_start( tdb_reg->tdb ) == -1 ) { - DEBUG(0, ("init_registry_data: tdb_transaction_start " - "failed\n")); - return false; + path = talloc_strdup(frame, add_path); + base = talloc_strdup(frame, ""); + if (!path || !base) { + goto fail; } + p = path; - /* loop over all of the predefined paths and add each component */ - - for ( i=0; builtin_registry_paths[i] != NULL; i++ ) { - - frame = talloc_stackframe(); + while (next_token_talloc(frame, &p, &keyname, "\\")) { - DEBUG(6,("init_registry_data: Adding [%s]\n", builtin_registry_paths[i])); + /* build up the registry path from the components */ - path = talloc_strdup(talloc_tos(), builtin_registry_paths[i]); - base = talloc_strdup(talloc_tos(), ""); - if (!path || !base) { - goto fail; - } - p = path; - - while (next_token_talloc(talloc_tos(), &p, &keyname, "\\")) { - - /* build up the registry path from the components */ - - if (*base) { - base = talloc_asprintf(talloc_tos(), "%s\\", base); - if (!base) { - goto fail; - } - } - base = talloc_asprintf_append(base, "%s", keyname); + if (*base) { + base = talloc_asprintf(frame, "%s\\", base); if (!base) { goto fail; } + } + base = talloc_asprintf_append(base, "%s", keyname); + if (!base) { + goto fail; + } - /* get the immediate subkeyname (if we have one ) */ + /* get the immediate subkeyname (if we have one ) */ - subkeyname = talloc_strdup(talloc_tos(), ""); - if (!subkeyname) { + subkeyname = talloc_strdup(frame, ""); + if (!subkeyname) { + goto fail; + } + if (*p) { + remaining = talloc_strdup(frame, p); + if (!remaining) { goto fail; } - if (*p) { - remaining = talloc_strdup(talloc_tos(), p); - if (!remaining) { + p2 = remaining; + + if (!next_token_talloc(frame, &p2, + &subkeyname, "\\")) + { + subkeyname = talloc_strdup(frame,p2); + if (!subkeyname) { goto fail; } - p2 = remaining; - - if (!next_token_talloc(talloc_tos(), &p2, - &subkeyname, "\\")) { - subkeyname = talloc_strdup(talloc_tos(),p2); - if (!subkeyname) { - goto fail; - } - } } + } - DEBUG(10,("init_registry_data: Storing key [%s] with subkey [%s]\n", - base, *subkeyname ? subkeyname : "NULL")); + DEBUG(10,("init_registry_key: Storing key [%s] with " + "subkey [%s]\n", base, + *subkeyname ? subkeyname : "NULL")); - /* we don't really care if the lookup succeeds or not since - we are about to update the record. We just want any - subkeys already present */ + /* we don't really care if the lookup succeeds or not + * since we are about to update the record. + * We just want any subkeys already present */ - if ( !(subkeys = TALLOC_ZERO_P(talloc_tos(), REGSUBKEY_CTR )) ) { - DEBUG(0,("talloc() failure!\n")); - goto fail; - } + if (!(subkeys = TALLOC_ZERO_P(frame, REGSUBKEY_CTR))) { + DEBUG(0,("talloc() failure!\n")); + goto fail; + } - regdb_fetch_keys(base, subkeys); - if (*subkeyname) { - regsubkey_ctr_addkey( subkeys, subkeyname); - } - if (!regdb_store_keys( base, subkeys)) { - goto fail; - } + regdb_fetch_keys(base, subkeys); + if (*subkeyname) { + regsubkey_ctr_addkey( subkeys, subkeyname); + } + if (!regdb_store_keys( base, subkeys)) { + goto fail; } + } + + ret = true; +fail: + TALLOC_FREE(frame); + return ret; +} + +/** + * Initialize a key in the registry: + * create each component key of the specified path, + * wrapped in one db transaction. + */ +bool init_registry_key(const char *add_path) +{ + if (regdb->transaction_start(regdb) != 0) { + DEBUG(0, ("init_registry_key: transaction_start failed\n")); + return false; + } + + if (!init_registry_key_internal(add_path)) { + goto fail; + } - TALLOC_FREE(frame); + if (regdb->transaction_commit(regdb) != 0) { + DEBUG(0, ("init_registry_key: Could not commit transaction\n")); + return false; + } + + return true; + +fail: + if (regdb->transaction_cancel(regdb) != 0) { + smb_panic("init_registry_key: transaction_cancel failed\n"); + } + + return false; +} + +/*********************************************************************** + Open the registry data in the tdb + ***********************************************************************/ + +bool init_registry_data(void) +{ + TALLOC_CTX *frame = NULL; + REGVAL_CTR *values; + int i; + UNISTR2 data; + + /* + * There are potentially quite a few store operations which are all + * indiviually wrapped in tdb transactions. Wrapping them in a single + * transaction gives just a single transaction_commit() to actually do + * its fsync()s. See tdb/common/transaction.c for info about nested + * transaction behaviour. + */ + + if (regdb->transaction_start(regdb) != 0) { + DEBUG(0, ("init_registry_data: tdb_transaction_start " + "failed\n")); + return false; + } + + /* loop over all of the predefined paths and add each component */ + + for (i=0; builtin_registry_paths[i] != NULL; i++) { + if (!init_registry_key_internal(builtin_registry_paths[i])) { + goto fail; + } } /* loop over all of the predefined values and add each component */ + frame = talloc_stackframe(); + for (i=0; builtin_registry_values[i].path != NULL; i++) { - if (!(values = TALLOC_ZERO_P(talloc_tos(), REGVAL_CTR))) { + values = TALLOC_ZERO_P(frame, REGVAL_CTR); + if (values == NULL) { goto fail; } - regdb_fetch_values( builtin_registry_values[i].path, values); + regdb_fetch_values(builtin_registry_values[i].path, values); - /* preserve existing values across restarts. Only add new ones */ + /* preserve existing values across restarts. Only add new ones */ - if (!regval_ctr_key_exists(values, builtin_registry_values[i].valuename)) { + if (!regval_ctr_key_exists(values, + builtin_registry_values[i].valuename)) + { switch(builtin_registry_values[i].type) { case REG_DWORD: - regval_ctr_addvalue( values, - builtin_registry_values[i].valuename, - REG_DWORD, - (char*)&builtin_registry_values[i].data.dw_value, - sizeof(uint32) ); + regval_ctr_addvalue(values, + builtin_registry_values[i].valuename, + REG_DWORD, + (char*)&builtin_registry_values[i].data.dw_value, + sizeof(uint32)); break; case REG_SZ: - init_unistr2( &data, builtin_registry_values[i].data.string, UNI_STR_TERMINATE); - regval_ctr_addvalue( values, - builtin_registry_values[i].valuename, - REG_SZ, - (char*)data.buffer, - data.uni_str_len*sizeof(uint16) ); + init_unistr2(&data, + builtin_registry_values[i].data.string, + UNI_STR_TERMINATE); + regval_ctr_addvalue(values, + builtin_registry_values[i].valuename, + REG_SZ, + (char*)data.buffer, + data.uni_str_len*sizeof(uint16)); break; default: - DEBUG(0,("init_registry_data: invalid value type in builtin_registry_values [%d]\n", - builtin_registry_values[i].type)); + DEBUG(0, ("init_registry_data: invalid value " + "type in builtin_registry_values " + "[%d]\n", + builtin_registry_values[i].type)); } - regdb_store_values( builtin_registry_values[i].path, values ); + regdb_store_values(builtin_registry_values[i].path, + values); } - TALLOC_FREE( values ); + TALLOC_FREE(values); } TALLOC_FREE(frame); - if (tdb_transaction_commit( tdb_reg->tdb ) == -1) { + if (regdb->transaction_commit(regdb) != 0) { DEBUG(0, ("init_registry_data: Could not commit " "transaction\n")); return false; @@ -241,7 +306,7 @@ static bool init_registry_data( void ) TALLOC_FREE(frame); - if (tdb_transaction_cancel( tdb_reg->tdb ) == -1) { + if (regdb->transaction_cancel(regdb) != 0) { smb_panic("init_registry_data: tdb_transaction_cancel " "failed\n"); } @@ -253,18 +318,24 @@ static bool init_registry_data( void ) Open the registry database ***********************************************************************/ -bool regdb_init( void ) +bool regdb_init(void) { const char *vstring = "INFO/version"; uint32 vers_id; - if ( tdb_reg ) + if (regdb) { + DEBUG(10, ("regdb_init: incrementing refcount (%d)\n", + regdb_refcount)); + regdb_refcount++; return true; + } - if ( !(tdb_reg = tdb_wrap_open(NULL, state_path("registry.tdb"), 0, REG_TDB_FLAGS, O_RDWR, 0600)) ) - { - tdb_reg = tdb_wrap_open(NULL, state_path("registry.tdb"), 0, REG_TDB_FLAGS, O_RDWR|O_CREAT, 0600); - if ( !tdb_reg ) { + regdb = db_open_trans(NULL, state_path("registry.tdb"), 0, + REG_TDB_FLAGS, O_RDWR, 0600); + if (!regdb) { + regdb = db_open_trans(NULL, state_path("registry.tdb"), 0, + REG_TDB_FLAGS, O_RDWR|O_CREAT, 0600); + if (!regdb) { DEBUG(0,("regdb_init: Failed to open registry %s (%s)\n", state_path("registry.tdb"), strerror(errno) )); return false; @@ -273,21 +344,24 @@ bool regdb_init( void ) DEBUG(10,("regdb_init: Successfully created registry tdb\n")); } - tdb_refcount = 1; + regdb_refcount = 1; - vers_id = tdb_fetch_int32(tdb_reg->tdb, vstring); + 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 INFO/version = %d != %d\n", + DEBUG(10, ("regdb_init: got %s = %d != %d\n", vstring, vers_id, REGVER_V1)); - } - - /* always setup the necessary keys and values */ - - if ( !init_registry_data() ) { - DEBUG(0,("regdb_init: Failed to initialize data in registry!\n")); - return false; + status = dbwrap_trans_store_int32(regdb, vstring, REGVER_V1); + if (!NT_STATUS_IS_OK(status)) { + DEBUG(0, ("regdb_init: error storing %s = %d: %s\n", + vstring, REGVER_V1, nt_errstr(status))); + return false; + } else { + DEBUG(10, ("regdb_init: stored %s = %d\n", + vstring, REGVER_V1)); + } } return true; @@ -301,16 +375,17 @@ WERROR regdb_open( void ) { WERROR result = WERR_OK; - if ( tdb_reg ) { - DEBUG(10,("regdb_open: incrementing refcount (%d)\n", tdb_refcount)); - tdb_refcount++; + if ( regdb ) { + DEBUG(10,("regdb_open: incrementing refcount (%d)\n", regdb_refcount)); + regdb_refcount++; return WERR_OK; } become_root(); - tdb_reg = tdb_wrap_open(NULL, state_path("registry.tdb"), 0, REG_TDB_FLAGS, O_RDWR, 0600); - if ( !tdb_reg ) { + regdb = db_open_trans(NULL, state_path("registry.tdb"), 0, + REG_TDB_FLAGS, O_RDWR, 0600); + if ( !regdb ) { result = ntstatus_to_werror( map_nt_error_from_unix( errno ) ); DEBUG(0,("regdb_open: Failed to open %s! (%s)\n", state_path("registry.tdb"), strerror(errno) )); @@ -318,8 +393,8 @@ WERROR regdb_open( void ) unbecome_root(); - tdb_refcount = 1; - DEBUG(10,("regdb_open: refcount reset (%d)\n", tdb_refcount)); + regdb_refcount = 1; + DEBUG(10,("regdb_open: refcount reset (%d)\n", regdb_refcount)); return result; } @@ -329,20 +404,20 @@ WERROR regdb_open( void ) int regdb_close( void ) { - if (tdb_refcount == 0) { + if (regdb_refcount == 0) { return 0; } - tdb_refcount--; + regdb_refcount--; - DEBUG(10,("regdb_close: decrementing refcount (%d)\n", tdb_refcount)); + DEBUG(10,("regdb_close: decrementing refcount (%d)\n", regdb_refcount)); - if ( tdb_refcount > 0 ) + if ( regdb_refcount > 0 ) return 0; - SMB_ASSERT( tdb_refcount >= 0 ); + SMB_ASSERT( regdb_refcount >= 0 ); - TALLOC_FREE(tdb_reg); + TALLOC_FREE(regdb); return 0; } @@ -353,7 +428,7 @@ int regdb_close( void ) ***********************************************************************/ int regdb_get_seqnum(void) { - return tdb_get_seqnum(tdb_reg->tdb); + return regdb->get_seqnum(regdb); } /*********************************************************************** @@ -371,7 +446,8 @@ static bool regdb_store_keys_internal(const char *key, REGSUBKEY_CTR *ctr) bool ret = true; uint32 num_subkeys = regsubkey_ctr_numkeys(ctr); char *keyname = NULL; - TALLOC_CTX *ctx = talloc_tos(); + TALLOC_CTX *ctx = talloc_stackframe(); + NTSTATUS status; if (!key) { return false; @@ -385,7 +461,8 @@ static bool regdb_store_keys_internal(const char *key, REGSUBKEY_CTR *ctr) /* allocate some initial memory */ - if (!(buffer = (uint8 *)SMB_MALLOC(1024))) { + buffer = (uint8 *)SMB_MALLOC(1024); + if (buffer == NULL) { return false; } buflen = 1024; @@ -393,22 +470,25 @@ static bool regdb_store_keys_internal(const char *key, REGSUBKEY_CTR *ctr) /* store the number of subkeys */ - len += tdb_pack(buffer+len, buflen-len, "d", num_subkeys ); + len += tdb_pack(buffer+len, buflen-len, "d", num_subkeys); /* pack all the strings */ for (i=0; i buflen ) { + len += tdb_pack(buffer+len, buflen-len, "f", + regsubkey_ctr_specific_key(ctr, i)); + if (len > buflen) { /* allocate some extra space */ - if ((buffer = (uint8 *)SMB_REALLOC( buffer, len*2 )) == NULL) { - DEBUG(0,("regdb_store_keys: Failed to realloc memory of size [%d]\n", len*2)); + buffer = (uint8 *)SMB_REALLOC(buffer, len*2); + if(buffer == NULL) { + DEBUG(0, ("regdb_store_keys: Failed to realloc " + "memory of size [%d]\n", len*2)); ret = false; goto done; } buflen = len*2; - - len = tdb_pack( buffer+len, buflen-len, "f", regsubkey_ctr_specific_key(ctr, i) ); + len = tdb_pack(buffer+len, buflen-len, "f", + regsubkey_ctr_specific_key(ctr, i)); } } @@ -416,13 +496,15 @@ static bool regdb_store_keys_internal(const char *key, REGSUBKEY_CTR *ctr) dbuf.dptr = buffer; dbuf.dsize = len; - if ( tdb_store_bystring( tdb_reg->tdb, keyname, dbuf, TDB_REPLACE ) == -1) { + status = dbwrap_store_bystring(regdb, keyname, dbuf, TDB_REPLACE); + if (!NT_STATUS_IS_OK(status)) { ret = false; goto done; } done: - SAFE_FREE( buffer ); + TALLOC_FREE(ctx); + SAFE_FREE(buffer); return ret; } @@ -437,21 +519,23 @@ bool regdb_store_keys(const char *key, REGSUBKEY_CTR *ctr) char *path = NULL; REGSUBKEY_CTR *subkeys = NULL, *old_subkeys = NULL; char *oldkeyname = NULL; - TALLOC_CTX *ctx = talloc_tos(); + TALLOC_CTX *ctx = talloc_stackframe(); + NTSTATUS status; /* * fetch a list of the old subkeys so we can determine if anything has * changed */ - if (!(old_subkeys = TALLOC_ZERO_P(ctr, REGSUBKEY_CTR))) { + if (!(old_subkeys = TALLOC_ZERO_P(ctx, REGSUBKEY_CTR))) { DEBUG(0,("regdb_store_keys: talloc() failure!\n")); return false; } regdb_fetch_keys(key, old_subkeys); - if (ctr->num_subkeys == old_subkeys->num_subkeys) { + if ((ctr->num_subkeys && old_subkeys->num_subkeys) && + (ctr->num_subkeys == old_subkeys->num_subkeys)) { for (i = 0; inum_subkeys; i++) { if (strcmp(ctr->subkeys[i], @@ -469,20 +553,20 @@ bool regdb_store_keys(const char *key, REGSUBKEY_CTR *ctr) } } - if (tdb_transaction_start( tdb_reg->tdb ) == -1) { - DEBUG(0, ("regdb_store_keys: tdb_transaction_start failed\n")); - return false; + TALLOC_FREE(old_subkeys); + + if (regdb->transaction_start(regdb) != 0) { + DEBUG(0, ("regdb_store_keys: transaction_start failed\n")); + goto fail; } /* * Re-fetch the old keys inside the transaction */ - TALLOC_FREE(old_subkeys); - - if (!(old_subkeys = TALLOC_ZERO_P(ctr, REGSUBKEY_CTR))) { + if (!(old_subkeys = TALLOC_ZERO_P(ctx, REGSUBKEY_CTR))) { DEBUG(0,("regdb_store_keys: talloc() failure!\n")); - goto fail; + goto cancel; } regdb_fetch_keys(key, old_subkeys); @@ -492,7 +576,7 @@ bool regdb_store_keys(const char *key, REGSUBKEY_CTR *ctr) if (!regdb_store_keys_internal(key, ctr) ) { DEBUG(0,("regdb_store_keys: Failed to store new subkey list " "for parent [%s]\n", key)); - goto fail; + goto cancel; } /* now delete removed keys */ @@ -511,15 +595,16 @@ bool regdb_store_keys(const char *key, REGSUBKEY_CTR *ctr) path = talloc_asprintf(ctx, "%s/%s", key, oldkeyname); if (!path) { - goto fail; + goto cancel; } path = normalize_reg_path(ctx, path); if (!path) { - goto fail; + goto cancel; } - if (tdb_delete_bystring(tdb_reg->tdb, path) == -1) { + status = dbwrap_delete_bystring(regdb, path); + if (!NT_STATUS_IS_OK(status)) { DEBUG(1, ("Deleting %s failed\n", path)); - goto fail; + goto cancel; } TALLOC_FREE(path); @@ -528,17 +613,17 @@ bool regdb_store_keys(const char *key, REGSUBKEY_CTR *ctr) key, oldkeyname ); if (!path) { - goto fail; + goto cancel; } path = normalize_reg_path(ctx, path); if (!path) { - goto fail; + goto cancel; } /* * Ignore errors here, we might have no values around */ - tdb_delete_bystring( tdb_reg->tdb, path ); + dbwrap_delete_bystring(regdb, path); TALLOC_FREE(path); } @@ -547,16 +632,32 @@ bool regdb_store_keys(const char *key, REGSUBKEY_CTR *ctr) /* now create records for any subkeys that don't already exist */ num_subkeys = regsubkey_ctr_numkeys(ctr); + + if (num_subkeys == 0) { + if (!(subkeys = TALLOC_ZERO_P(ctx, REGSUBKEY_CTR)) ) { + DEBUG(0,("regdb_store_keys: talloc() failure!\n")); + goto cancel; + } + + if (!regdb_store_keys_internal(key, subkeys)) { + DEBUG(0,("regdb_store_keys: Failed to store " + "new record for key [%s]\n", key)); + goto cancel; + } + TALLOC_FREE(subkeys); + + } + for (i=0; itdb ) == -1) { + if (regdb->transaction_commit(regdb) != 0) { DEBUG(0, ("regdb_store_keys: Could not commit transaction\n")); - return false; + goto fail; } + TALLOC_FREE(ctx); return true; - fail: - TALLOC_FREE(old_subkeys); - TALLOC_FREE(subkeys); - - if (tdb_transaction_cancel(tdb_reg->tdb) == -1) { - smb_panic("regdb_store_keys: tdb_transaction_cancel failed\n"); +cancel: + if (regdb->transaction_cancel(regdb) != 0) { + smb_panic("regdb_store_keys: transaction_cancel failed\n"); } +fail: + TALLOC_FREE(ctx); + return false; } @@ -600,40 +702,38 @@ int regdb_fetch_keys(const char *key, REGSUBKEY_CTR *ctr) { char *path = NULL; uint32 num_items; - TDB_DATA dbuf; uint8 *buf; uint32 buflen, len; int i; fstring subkeyname; int ret = -1; + int dbret = -1; TALLOC_CTX *frame = talloc_stackframe(); + TDB_DATA value; DEBUG(11,("regdb_fetch_keys: Enter key => [%s]\n", key ? key : "NULL")); - path = talloc_strdup(talloc_tos(), key); + path = talloc_strdup(frame, key); if (!path) { goto fail; } /* convert to key format */ - path = talloc_string_sub(talloc_tos(), path, "\\", "/"); + path = talloc_string_sub(frame, path, "\\", "/"); if (!path) { goto fail; } strupper_m(path); - if (tdb_read_lock_bystring_with_timeout(tdb_reg->tdb, path, 10) == -1) { - return 0; - } - - dbuf = tdb_fetch_bystring(tdb_reg->tdb, path); ctr->seqnum = regdb_get_seqnum(); - tdb_read_unlock_bystring(tdb_reg->tdb, path); - + dbret = regdb->fetch(regdb, frame, string_term_tdb_data(path), &value); + if (dbret != 0) { + goto fail; + } - buf = dbuf.dptr; - buflen = dbuf.dsize; + buf = value.dptr; + buflen = value.dsize; if ( !buf ) { DEBUG(5,("regdb_fetch_keys: tdb lookup failed to locate key [%s]\n", key)); @@ -647,8 +747,6 @@ int regdb_fetch_keys(const char *key, REGSUBKEY_CTR *ctr) regsubkey_ctr_addkey(ctr, subkeyname); } - SAFE_FREE(dbuf.dptr); - DEBUG(11,("regdb_fetch_keys: Exit [%d] items\n", num_items)); ret = num_items; @@ -743,9 +841,11 @@ static int regdb_pack_values(REGVAL_CTR *values, uint8 *buf, int buflen) int regdb_fetch_values( const char* key, REGVAL_CTR *values ) { - TDB_DATA data; char *keystr = NULL; - TALLOC_CTX *ctx = talloc_tos(); + TALLOC_CTX *ctx = talloc_stackframe(); + int ret = 0; + int dbret = -1; + TDB_DATA value; DEBUG(10,("regdb_fetch_values: Looking for value of key [%s] \n", key)); @@ -755,35 +855,37 @@ int regdb_fetch_values( const char* key, REGVAL_CTR *values ) } keystr = normalize_reg_path(ctx, keystr); if (!keystr) { - return 0; - } - - if (tdb_read_lock_bystring_with_timeout(tdb_reg->tdb, keystr, 10) == -1) { - return 0; + goto done; } - data = tdb_fetch_bystring(tdb_reg->tdb, keystr); values->seqnum = regdb_get_seqnum(); - tdb_read_unlock_bystring(tdb_reg->tdb, keystr); + dbret = regdb->fetch(regdb, ctx, string_term_tdb_data(keystr), &value); + if (dbret != 0) { + goto done; + } - if (!data.dptr) { + if (!value.dptr) { /* all keys have zero values by default */ - return 0; + goto done; } - regdb_unpack_values(values, data.dptr, data.dsize); + regdb_unpack_values(values, value.dptr, value.dsize); + ret = regval_ctr_numvals(values); - SAFE_FREE(data.dptr); - return regval_ctr_numvals(values); +done: + TALLOC_FREE(ctx); + return ret; } bool regdb_store_values( const char *key, REGVAL_CTR *values ) { TDB_DATA old_data, data; char *keystr = NULL; - TALLOC_CTX *ctx = talloc_tos(); - int len, ret; + TALLOC_CTX *ctx = talloc_stackframe(); + int len; + NTSTATUS status; + bool result = false; DEBUG(10,("regdb_store_values: Looking for value of key [%s] \n", key)); @@ -792,10 +894,10 @@ bool regdb_store_values( const char *key, REGVAL_CTR *values ) len = regdb_pack_values(values, data.dptr, data.dsize); if (len <= 0) { DEBUG(0,("regdb_store_values: unable to pack values. len <= 0\n")); - return false; + goto done; } - data.dptr = SMB_MALLOC_ARRAY( uint8, len ); + data.dptr = TALLOC_ARRAY(ctx, uint8, len); data.dsize = len; len = regdb_pack_values(values, data.dptr, data.dsize); @@ -804,31 +906,31 @@ bool regdb_store_values( const char *key, REGVAL_CTR *values ) keystr = talloc_asprintf(ctx, "%s/%s", REG_VALUE_PREFIX, key ); if (!keystr) { - SAFE_FREE(data.dptr); - return false; + goto done; } keystr = normalize_reg_path(ctx, keystr); if (!keystr) { - SAFE_FREE(data.dptr); - return false; + goto done; } - old_data = tdb_fetch_bystring(tdb_reg->tdb, keystr); + old_data = dbwrap_fetch_bystring(regdb, ctx, keystr); if ((old_data.dptr != NULL) && (old_data.dsize == data.dsize) - && (memcmp(old_data.dptr, data.dptr, data.dsize) == 0)) { - SAFE_FREE(old_data.dptr); - SAFE_FREE(data.dptr); - return true; + && (memcmp(old_data.dptr, data.dptr, data.dsize) == 0)) + { + result = true; + goto done; } - ret = tdb_trans_store_bystring(tdb_reg->tdb, keystr, data, TDB_REPLACE); + status = dbwrap_trans_store(regdb, string_term_tdb_data(keystr), data, + TDB_REPLACE); - SAFE_FREE( old_data.dptr ); - SAFE_FREE( data.dptr ); + result = NT_STATUS_IS_OK(status); - return ret != -1 ; +done: + TALLOC_FREE(ctx); + return result; } static WERROR regdb_get_secdesc(TALLOC_CTX *mem_ctx, const char *key, @@ -837,70 +939,63 @@ static WERROR regdb_get_secdesc(TALLOC_CTX *mem_ctx, const char *key, char *tdbkey; TDB_DATA data; NTSTATUS status; + TALLOC_CTX *tmp_ctx = talloc_stackframe(); + WERROR err = WERR_OK; DEBUG(10, ("regdb_get_secdesc: Getting secdesc of key [%s]\n", key)); - if (asprintf(&tdbkey, "%s/%s", REG_SECDESC_PREFIX, key) == -1) { - return WERR_NOMEM; + tdbkey = talloc_asprintf(tmp_ctx, "%s/%s", REG_SECDESC_PREFIX, key); + if (tdbkey == NULL) { + err = WERR_NOMEM; + goto done; } normalize_dbkey(tdbkey); - data = tdb_fetch_bystring(tdb_reg->tdb, tdbkey); - SAFE_FREE(tdbkey); - + data = dbwrap_fetch_bystring(regdb, tmp_ctx, tdbkey); if (data.dptr == NULL) { - return WERR_BADFILE; + err = WERR_BADFILE; + goto done; } status = unmarshall_sec_desc(mem_ctx, (uint8 *)data.dptr, data.dsize, psecdesc); - SAFE_FREE(data.dptr); - if (NT_STATUS_EQUAL(status, NT_STATUS_NO_MEMORY)) { - return WERR_NOMEM; - } - - if (!NT_STATUS_IS_OK(status)) { - return WERR_REG_CORRUPT; + err = WERR_NOMEM; + } else if (!NT_STATUS_IS_OK(status)) { + err = WERR_REG_CORRUPT; } - return WERR_OK; +done: + TALLOC_FREE(tmp_ctx); + return err; } static WERROR regdb_set_secdesc(const char *key, struct security_descriptor *secdesc) { - prs_struct ps; - TALLOC_CTX *mem_ctx; + TALLOC_CTX *mem_ctx = talloc_stackframe(); char *tdbkey; + NTSTATUS status; WERROR err = WERR_NOMEM; TDB_DATA tdbdata; + int tdb_ret; - if (!(mem_ctx = talloc_init("regdb_set_secdesc"))) { - return WERR_NOMEM; - } - - ZERO_STRUCT(ps); - - if (!(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); if (secdesc == NULL) { /* assuming a delete */ - int tdb_ret; - - tdb_ret = tdb_trans_delete(tdb_reg->tdb, - string_term_tdb_data(tdbkey)); - if (tdb_ret == -1) { - err = ntstatus_to_werror(map_nt_error_from_unix(errno)); - } else { + tdb_ret = dbwrap_trans_delete(regdb, + string_term_tdb_data(tdbkey)); + if (tdb_ret == 0) { err = WERR_OK; + } else { + err = ntstatus_to_werror(map_nt_error_from_unix(errno)); } - goto done; } @@ -911,13 +1006,14 @@ static WERROR regdb_set_secdesc(const char *key, goto done; } - if (tdb_trans_store_bystring(tdb_reg->tdb, tdbkey, tdbdata, 0) == -1) { - err = ntstatus_to_werror(map_nt_error_from_unix(errno)); + status = dbwrap_trans_store(regdb, string_term_tdb_data(tdbkey), + tdbdata, 0); + if (!NT_STATUS_IS_OK(status)) { + err = ntstatus_to_werror(status); goto done; } done: - prs_mem_free(&ps); TALLOC_FREE(mem_ctx); return err; } @@ -937,13 +1033,12 @@ bool regdb_values_need_update(REGVAL_CTR *values) */ REGISTRY_OPS regdb_ops = { - regdb_fetch_keys, - regdb_fetch_values, - regdb_store_keys, - regdb_store_values, - NULL, - regdb_get_secdesc, - regdb_set_secdesc, - regdb_subkeys_need_update, - regdb_values_need_update + .fetch_subkeys = regdb_fetch_keys, + .fetch_values = regdb_fetch_values, + .store_subkeys = regdb_store_keys, + .store_values = regdb_store_values, + .get_secdesc = regdb_get_secdesc, + .set_secdesc = regdb_set_secdesc, + .subkeys_need_update = regdb_subkeys_need_update, + .values_need_update = regdb_values_need_update };