From 9fe3bd1259e7bda901f7a264bd7fc88c72d2112f Mon Sep 17 00:00:00 2001 From: Gerald Carter Date: Fri, 19 Jul 2002 18:49:44 +0000 Subject: * refactored registry operations some. subkey lists and registry values are now passed around in containers (REGSUBKEY_CTR & REGVAL_CTR) which each possess a TALLOC_CTX. * removed subkey_specific_fn() from REGISTRY_OPS. Is implemented in the form of a wrapper * temporarily broke the printing registry ops. * implemented inheritence for the data_p of nodes in a SORTED_TREE * All REGISTRY_KEY instances now store a valid REGISTRY_HOOK since the default REGOSTRY_OPS structure is stored in the root of the cache_tree. * Probably some other change I forgot.... T (This used to be commit e7b55e8f017e638342d9c8c1a9259000745a0298) --- source3/registry/reg_frontend.c | 207 +++++++++++++++++++++++++++++++++++----- 1 file changed, 181 insertions(+), 26 deletions(-) (limited to 'source3/registry/reg_frontend.c') diff --git a/source3/registry/reg_frontend.c b/source3/registry/reg_frontend.c index 76d67fdfc9..7b7cade6c0 100644 --- a/source3/registry/reg_frontend.c +++ b/source3/registry/reg_frontend.c @@ -26,12 +26,14 @@ #define DBGC_CLASS DBGC_RPC_SRV extern REGISTRY_OPS printing_ops; +extern REGISTRY_OPS regdb_ops; /* these are the default */ /* array of REGISTRY_HOOK's which are read into a tree for easy access */ REGISTRY_HOOK reg_hooks[] = { - { KEY_PRINTING, &printing_ops }, + { KEY_TREE_ROOT, ®db_ops }, + { KEY_PRINTING, &printing_ops }, { NULL, NULL } }; @@ -70,9 +72,12 @@ BOOL init_registry( void ) High level wrapper function for storing registry subkeys ***********************************************************************/ -BOOL store_reg_keys( REGISTRY_KEY *key, char **subkeys, uint32 num_subkeys ) +BOOL store_reg_keys( REGISTRY_KEY *key, REGSUBKEY_CTR *subkeys ) { - return regdb_store_reg_keys( key->name, subkeys, num_subkeys ); + if ( key->hook && key->hook->ops && key->hook->ops->store_subkeys_fn ) + return key->hook->ops->store_subkeys_fn( key->name, subkeys ); + else + return False; } @@ -80,60 +85,210 @@ BOOL store_reg_keys( REGISTRY_KEY *key, char **subkeys, uint32 num_subkeys ) High level wrapper function for storing registry values ***********************************************************************/ -BOOL store_reg_values( REGISTRY_KEY *key, REGISTRY_VALUE **val, uint32 num_values ) +BOOL store_reg_values( REGISTRY_KEY *key, REGVAL_CTR *val ) { - return True; + if ( key->hook && key->hook->ops && key->hook->ops->store_values_fn ) + return key->hook->ops->store_values_fn( key->name, val ); + else + return False; } /*********************************************************************** High level wrapper function for enumerating registry subkeys + Initialize the TALLOC_CTX if necessary ***********************************************************************/ -int fetch_reg_keys( REGISTRY_KEY *key, char **subkeys ) +int fetch_reg_keys( REGISTRY_KEY *key, REGSUBKEY_CTR *subkey_ctr ) { - int num_subkeys; + int result = -1; if ( key->hook && key->hook->ops && key->hook->ops->subkey_fn ) - num_subkeys = key->hook->ops->subkey_fn( key->name, subkeys ); - else - num_subkeys = regdb_fetch_reg_keys( key->name, subkeys ); + result = key->hook->ops->subkey_fn( key->name, subkey_ctr ); - return num_subkeys; + return result; } /*********************************************************************** - High level wrapper function for retreiving a specific registry subkey - given and index. + retreive a specific subkey specified by index. Caller is + responsible for freeing memory ***********************************************************************/ BOOL fetch_reg_keys_specific( REGISTRY_KEY *key, char** subkey, uint32 key_index ) { - BOOL result; - - if ( key->hook && key->hook->ops && key->hook->ops->subkey_specific_fn ) - result = key->hook->ops->subkey_specific_fn( key->name, subkey, key_index ); - else - result = regdb_fetch_reg_keys_specific( key->name, subkey, key_index ); + char *s; + REGSUBKEY_CTR ctr; - return result; + ZERO_STRUCTP( &ctr ); + + regsubkey_ctr_init( &ctr ); + + if ( fetch_reg_keys( key, &ctr) == -1 ) + return False; + + if ( !(s = regsubkey_ctr_specific_key( &ctr, key_index )) ) + return False; + + *subkey = strdup( s ); + + regsubkey_ctr_destroy( &ctr ); + + return True; } /*********************************************************************** High level wrapper function for enumerating registry values + Initialize the TALLOC_CTX if necessary ***********************************************************************/ -int fetch_reg_values( REGISTRY_KEY *key, REGISTRY_VALUE **val ) +int fetch_reg_values( REGISTRY_KEY *key, REGVAL_CTR *val ) { - int num_values; + int result = -1; if ( key->hook && key->hook->ops && key->hook->ops->value_fn ) - num_values = key->hook->ops->value_fn( key->name, val ); - else - num_values = regdb_fetch_reg_values( key->name, val ); + result = key->hook->ops->value_fn( key->name, val ); + + return result; +} + +/*********************************************************************** + Utility function for splitting the base path of a registry path off + by setting base and new_path to the apprapriate offsets withing the + path. + + WARNING!! Does modify the original string! + ***********************************************************************/ + +BOOL reg_split_path( char *path, char **base, char **new_path ) +{ + char *p; + + *new_path = *base = NULL; + + if ( !path) + return False; + + *base = path; + + p = strchr( path, '\\' ); + + if ( p ) { + *p = '\0'; + *new_path = p+1; + } + + return True; +} + + +/* + * Utility functions for REGSUBKEY_CTR + */ + +/*********************************************************************** + Init the talloc context held by a REGSUBKEY_CTR structure + **********************************************************************/ + +void regsubkey_ctr_init( REGSUBKEY_CTR *ctr ) +{ + if ( !ctr->ctx ) + ctr->ctx = talloc_init(); +} + +/*********************************************************************** + Add a new key to the array + **********************************************************************/ + +int regsubkey_ctr_addkey( REGSUBKEY_CTR *ctr, char *keyname ) +{ + uint32 len; + + if ( keyname ) + { + len = strlen( keyname ); + + if ( ctr->subkeys == 0 ) + ctr->subkeys = talloc( ctr->ctx, 1 ); + else + talloc_realloc( ctr->ctx, ctr->subkeys, ctr->num_subkeys+1 ); + + ctr->subkeys[ctr->num_subkeys] = talloc( ctr->ctx, len+1 ); + strncpy( ctr->subkeys[ctr->num_subkeys], keyname, len+1 ); + ctr->num_subkeys++; + } + + return ctr->num_subkeys; +} + +/*********************************************************************** + How many keys does the container hold ? + **********************************************************************/ + +int regsubkey_ctr_numkeys( REGSUBKEY_CTR *ctr ) +{ + return ctr->num_subkeys; +} + +/*********************************************************************** + Retreive a specific key string + **********************************************************************/ + +char* regsubkey_ctr_specific_key( REGSUBKEY_CTR *ctr, uint32 index ) +{ + if ( ! (index < ctr->num_subkeys) ) + return NULL; + + return ctr->subkeys[index]; +} + +/*********************************************************************** + free memory held by a REGSUBKEY_CTR structure + **********************************************************************/ + +void regsubkey_ctr_destroy( REGSUBKEY_CTR *ctr ) +{ + if ( ctr ) + talloc_destroy( ctr->ctx ); - return num_values; + ctr->num_subkeys = 0; + ctr->subkeys = NULL; +} + + +/* + * Utility functions for REGVAL_CTR + */ + +/*********************************************************************** + Init the talloc context held by a REGSUBKEY_CTR structure + **********************************************************************/ + +void regval_ctr_init( REGVAL_CTR *ctr ) +{ + if ( !ctr->ctx ) + ctr->ctx = talloc_init(); +} + +/*********************************************************************** + How many keys does the container hold ? + **********************************************************************/ + +int regval_ctr_numvals( REGVAL_CTR *ctr ) +{ + return ctr->num_values; } +/*********************************************************************** + free memory held by a REGVAL_CTR structure + **********************************************************************/ + +void regval_ctr_destroy( REGVAL_CTR *ctr ) +{ + if ( ctr ) + talloc_destroy( ctr->ctx ); + + ctr->num_values = 0; + ctr->values = NULL; +} -- cgit