summaryrefslogtreecommitdiffstats
path: root/source3/registry
diff options
context:
space:
mode:
Diffstat (limited to 'source3/registry')
-rw-r--r--source3/registry/reg_db.c78
-rw-r--r--source3/registry/reg_frontend.c58
-rw-r--r--source3/registry/reg_objects.c88
-rw-r--r--source3/registry/reg_printing.c20
4 files changed, 116 insertions, 128 deletions
diff --git a/source3/registry/reg_db.c b/source3/registry/reg_db.c
index 64a863ceac..19f9abd80d 100644
--- a/source3/registry/reg_db.c
+++ b/source3/registry/reg_db.c
@@ -31,7 +31,7 @@ static TDB_CONTEXT *tdb_reg;
/* List the deepest path into the registry. All part components will be created.*/
-/* If you want to have a part of the path controlled by the tdb abd part by
+/* If you want to have a part of the path controlled by the tdb and part by
a virtual registry db (e.g. printing), then you have to list the deepest path.
For example,"HKLM/SOFTWARE/Microsoft/Windows NT/CurrentVersion/Print"
allows the reg_db backend to handle everything up to
@@ -89,12 +89,20 @@ static BOOL init_registry_data( void )
{
pstring path, base, remaining;
fstring keyname, subkeyname;
- REGSUBKEY_CTR subkeys;
- REGVAL_CTR values;
+ REGSUBKEY_CTR *subkeys;
+ REGVAL_CTR *values;
+ uint32 *ctx;
int i;
const char *p, *p2;
UNISTR2 data;
+ /* create a new top level talloc ctx */
+
+ if ( !(ctx = TALLOC_P( NULL, uint32 )) ) {
+ DEBUG(0,("init_registry_data: top level talloc() failure!\n"));
+ return False;
+ }
+
/* loop over all of the predefined paths and add each component */
for ( i=0; builtin_registry_paths[i] != NULL; i++ ) {
@@ -131,27 +139,33 @@ static BOOL init_registry_data( void )
we are about to update the record. We just want any
subkeys already present */
- regsubkey_ctr_init( &subkeys );
-
- regdb_fetch_keys( base, &subkeys );
+ if ( !(subkeys = TALLOC_ZERO_P( ctx, REGSUBKEY_CTR )) ) {
+ DEBUG(0,("talloc() failure!\n"));
+ return False;
+ }
+
+ regdb_fetch_keys( base, subkeys );
if ( *subkeyname )
- regsubkey_ctr_addkey( &subkeys, subkeyname );
- if ( !regdb_store_keys( base, &subkeys ))
+ regsubkey_ctr_addkey( subkeys, subkeyname );
+ if ( !regdb_store_keys( base, subkeys ))
return False;
- regsubkey_ctr_destroy( &subkeys );
+ TALLOC_FREE( subkeys );
}
}
/* loop over all of the predefined values and add each component */
for ( i=0; builtin_registry_values[i].path != NULL; i++ ) {
- regval_ctr_init( &values );
-
- regdb_fetch_values( builtin_registry_values[i].path, &values );
+ if ( !(values = TALLOC_ZERO_P( ctx, REGVAL_CTR )) ) {
+ DEBUG(0,("talloc() failure!\n"));
+ return False;
+ }
+
+ regdb_fetch_values( builtin_registry_values[i].path, values );
switch( builtin_registry_values[i].type ) {
case REG_DWORD:
- regval_ctr_addvalue( &values,
+ regval_ctr_addvalue( values,
builtin_registry_values[i].valuename,
REG_DWORD,
(char*)&builtin_registry_values[i].data.dw_value,
@@ -160,7 +174,7 @@ static BOOL init_registry_data( void )
case REG_SZ:
init_unistr2( &data, builtin_registry_values[i].data.string, UNI_STR_TERMINATE);
- regval_ctr_addvalue( &values,
+ regval_ctr_addvalue( values,
builtin_registry_values[i].valuename,
REG_SZ,
(char*)data.buffer,
@@ -171,9 +185,9 @@ static BOOL init_registry_data( void )
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 );
- regval_ctr_destroy( &values );
+ TALLOC_FREE( values );
}
return True;
@@ -297,13 +311,17 @@ BOOL regdb_store_keys( const char *key, REGSUBKEY_CTR *ctr )
{
int num_subkeys, i;
pstring path;
- REGSUBKEY_CTR subkeys, old_subkeys;
+ REGSUBKEY_CTR *subkeys, *old_subkeys;
char *oldkeyname;
/* fetch a list of the old subkeys so we can determine if any were deleted */
- regsubkey_ctr_init( &old_subkeys );
- regdb_fetch_keys( key, &old_subkeys );
+ if ( !(old_subkeys = TALLOC_ZERO_P( ctr, REGSUBKEY_CTR )) ) {
+ DEBUG(0,("regdb_store_keys: talloc() failure!\n"));
+ return False;
+ }
+
+ regdb_fetch_keys( key, old_subkeys );
/* store the subkey list for the parent */
@@ -314,9 +332,9 @@ BOOL regdb_store_keys( const char *key, REGSUBKEY_CTR *ctr )
/* now delete removed keys */
- num_subkeys = regsubkey_ctr_numkeys( &old_subkeys );
+ num_subkeys = regsubkey_ctr_numkeys( old_subkeys );
for ( i=0; i<num_subkeys; i++ ) {
- oldkeyname = regsubkey_ctr_specific_key( &old_subkeys, i );
+ oldkeyname = regsubkey_ctr_specific_key( old_subkeys, i );
if ( !regsubkey_ctr_key_exists( ctr, oldkeyname ) ) {
pstr_sprintf( path, "%s%c%s", key, '/', oldkeyname );
normalize_reg_path( path );
@@ -324,23 +342,29 @@ BOOL regdb_store_keys( const char *key, REGSUBKEY_CTR *ctr )
}
}
- regsubkey_ctr_destroy( &old_subkeys );
+ TALLOC_FREE( old_subkeys );
/* now create records for any subkeys that don't already exist */
num_subkeys = regsubkey_ctr_numkeys( ctr );
for ( i=0; i<num_subkeys; i++ ) {
pstr_sprintf( path, "%s%c%s", key, '/', regsubkey_ctr_specific_key( ctr, i ) );
- regsubkey_ctr_init( &subkeys );
- if ( regdb_fetch_keys( path, &subkeys ) == -1 ) {
+
+ if ( !(subkeys = TALLOC_ZERO_P( ctr, REGSUBKEY_CTR )) ) {
+ DEBUG(0,("regdb_store_keys: talloc() failure!\n"));
+ return False;
+ }
+
+ if ( regdb_fetch_keys( path, subkeys ) == -1 ) {
/* create a record with 0 subkeys */
- if ( !regdb_store_keys_internal( path, &subkeys ) ) {
+ if ( !regdb_store_keys_internal( path, subkeys ) ) {
DEBUG(0,("regdb_store_keys: Failed to store new record for key [%s}\n", path ));
- regsubkey_ctr_destroy( &subkeys );
+ TALLOC_FREE( subkeys );
return False;
}
}
- regsubkey_ctr_destroy( &subkeys );
+
+ TALLOC_FREE( subkeys );
}
return True;
diff --git a/source3/registry/reg_frontend.c b/source3/registry/reg_frontend.c
index 51ad23b498..d6e0288461 100644
--- a/source3/registry/reg_frontend.c
+++ b/source3/registry/reg_frontend.c
@@ -38,7 +38,9 @@ REGISTRY_HOOK reg_hooks[] = {
{ KEY_PRINTING, &printing_ops },
{ KEY_PRINTING_2K, &printing_ops },
{ KEY_PRINTING_PORTS, &printing_ops },
+#if 0
{ KEY_EVENTLOG, &eventlog_ops },
+#endif
{ KEY_SHARES, &shares_reg_ops },
#endif
{ NULL, NULL }
@@ -124,9 +126,8 @@ int fetch_reg_keys( REGISTRY_KEY *key, REGSUBKEY_CTR *subkey_ctr )
BOOL fetch_reg_keys_specific( REGISTRY_KEY *key, char** subkey, uint32 key_index )
{
- static REGSUBKEY_CTR ctr;
+ static REGSUBKEY_CTR *ctr = NULL;
static pstring save_path;
- static BOOL ctr_init = False;
char *s;
*subkey = NULL;
@@ -135,32 +136,39 @@ BOOL fetch_reg_keys_specific( REGISTRY_KEY *key, char** subkey, uint32 key_index
DEBUG(8,("fetch_reg_keys_specific: Looking for key [%d] of [%s]\n", key_index, key->name));
- if ( !ctr_init ) {
+ if ( !ctr ) {
DEBUG(8,("fetch_reg_keys_specific: Initializing cache of subkeys for [%s]\n", key->name));
- regsubkey_ctr_init( &ctr );
+
+ if ( !(ctr = TALLOC_ZERO_P( NULL, REGSUBKEY_CTR )) ) {
+ DEBUG(0,("fetch_reg_keys_specific: talloc() failed!\n"));
+ return False;
+ }
pstrcpy( save_path, key->name );
- if ( fetch_reg_keys( key, &ctr) == -1 )
+ if ( fetch_reg_keys( key, ctr) == -1 )
return False;
- ctr_init = True;
}
/* clear the cache when key_index == 0 or the path has changed */
else if ( !key_index || StrCaseCmp( save_path, key->name) ) {
DEBUG(8,("fetch_reg_keys_specific: Updating cache of subkeys for [%s]\n", key->name));
- regsubkey_ctr_destroy( &ctr );
- regsubkey_ctr_init( &ctr );
+ TALLOC_FREE( ctr );
+
+ if ( !(ctr = TALLOC_ZERO_P( NULL, REGSUBKEY_CTR )) ) {
+ DEBUG(0,("fetch_reg_keys_specific: talloc() failed!\n"));
+ return False;
+ }
pstrcpy( save_path, key->name );
- if ( fetch_reg_keys( key, &ctr) == -1 )
+ if ( fetch_reg_keys( key, ctr) == -1 )
return False;
}
- if ( !(s = regsubkey_ctr_specific_key( &ctr, key_index )) )
+ if ( !(s = regsubkey_ctr_specific_key( ctr, key_index )) )
return False;
*subkey = SMB_STRDUP( s );
@@ -198,42 +206,46 @@ int fetch_reg_values( REGISTRY_KEY *key, REGVAL_CTR *val )
BOOL fetch_reg_values_specific( REGISTRY_KEY *key, REGISTRY_VALUE **val, uint32 val_index )
{
- static REGVAL_CTR ctr;
+ static REGVAL_CTR *ctr = NULL;
static pstring save_path;
- static BOOL ctr_init = False;
REGISTRY_VALUE *v;
*val = NULL;
/* simple caching for performance; very basic heuristic */
- if ( !ctr_init ) {
+ if ( !ctr ) {
DEBUG(8,("fetch_reg_values_specific: Initializing cache of values for [%s]\n", key->name));
- regval_ctr_init( &ctr );
-
+ if ( !(ctr = TALLOC_ZERO_P( NULL, REGVAL_CTR )) ) {
+ DEBUG(0,("fetch_reg_values_specific: talloc() failed!\n"));
+ return False;
+ }
+
pstrcpy( save_path, key->name );
- if ( fetch_reg_values( key, &ctr) == -1 )
+ if ( fetch_reg_values( key, ctr) == -1 )
return False;
-
- ctr_init = True;
}
/* clear the cache when val_index == 0 or the path has changed */
else if ( !val_index || !strequal(save_path, key->name) ) {
DEBUG(8,("fetch_reg_values_specific: Updating cache of values for [%s]\n", key->name));
- regval_ctr_destroy( &ctr );
- regval_ctr_init( &ctr );
-
+ TALLOC_FREE( ctr );
+
+ if ( !(ctr = TALLOC_ZERO_P( NULL, REGVAL_CTR )) ) {
+ DEBUG(0,("fetch_reg_values_specific: talloc() failed!\n"));
+ return False;
+ }
+
pstrcpy( save_path, key->name );
- if ( fetch_reg_values( key, &ctr) == -1 )
+ if ( fetch_reg_values( key, ctr) == -1 )
return False;
}
- if ( !(v = regval_ctr_specific_value( &ctr, val_index )) )
+ if ( !(v = regval_ctr_specific_value( ctr, val_index )) )
return False;
*val = dup_registry_value( v );
diff --git a/source3/registry/reg_objects.c b/source3/registry/reg_objects.c
index b5753fc688..70410a6740 100644
--- a/source3/registry/reg_objects.c
+++ b/source3/registry/reg_objects.c
@@ -25,17 +25,17 @@
#undef DBGC_CLASS
#define DBGC_CLASS DBGC_RPC_SRV
+/**********************************************************************
-/***********************************************************************
- Init the talloc context held by a REGSUBKEY_CTR structure
- This now zero's the structure
- **********************************************************************/
+ Note that the REGSUB_CTR and REGVAL_CTR objects *must* be talloc()'d
+ since the methods use the object pointer as the talloc context for
+ internal private data.
-void regsubkey_ctr_init( REGSUBKEY_CTR *ctr )
-{
- ZERO_STRUCTP( ctr );
- ctr->ctx = talloc_init("regsubkey_ctr_init for ctr %p", ctr);
-}
+ There is no longer a regXXX_ctr_intit() and regXXX_ctr_destroy()
+ pair of functions. Simply TALLOC_ZERO_P() and TALLOC_FREE() the
+ object.
+
+ **********************************************************************/
/***********************************************************************
Add a new key to the array
@@ -56,16 +56,16 @@ int regsubkey_ctr_addkey( REGSUBKEY_CTR *ctr, const char *keyname )
/* allocate a space for the char* in the array */
if ( ctr->subkeys == 0 )
- ctr->subkeys = TALLOC_P( ctr->ctx, char *);
+ ctr->subkeys = TALLOC_P( ctr, char *);
else {
- pp = TALLOC_REALLOC_ARRAY( ctr->ctx, ctr->subkeys, char *, ctr->num_subkeys+1);
+ pp = TALLOC_REALLOC_ARRAY( ctr, ctr->subkeys, char *, ctr->num_subkeys+1);
if ( pp )
ctr->subkeys = pp;
}
/* allocate the string and save it in the array */
- ctr->subkeys[ctr->num_subkeys] = talloc_strdup( ctr->ctx, keyname );
+ ctr->subkeys[ctr->num_subkeys] = talloc_strdup( ctr, keyname );
ctr->num_subkeys++;
return ctr->num_subkeys;
@@ -137,35 +137,11 @@ char* regsubkey_ctr_specific_key( REGSUBKEY_CTR *ctr, uint32 key_index )
return ctr->subkeys[key_index];
}
-/***********************************************************************
- free memory held by a REGSUBKEY_CTR structure
- **********************************************************************/
-
-void regsubkey_ctr_destroy( REGSUBKEY_CTR *ctr )
-{
- if ( ctr ) {
- talloc_destroy( ctr->ctx );
- ZERO_STRUCTP( ctr );
- }
-}
-
-
/*
* Utility functions for REGVAL_CTR
*/
/***********************************************************************
- Init the talloc context held by a REGSUBKEY_CTR structure
- This now zero's the structure
- **********************************************************************/
-
-void regval_ctr_init( REGVAL_CTR *ctr )
-{
- ZERO_STRUCTP( ctr );
- ctr->ctx = talloc_init("regval_ctr_init for ctr %p", ctr);
-}
-
-/***********************************************************************
How many keys does the container hold ?
**********************************************************************/
@@ -272,17 +248,6 @@ REGISTRY_VALUE* regval_ctr_specific_value( REGVAL_CTR *ctr, uint32 idx )
}
/***********************************************************************
- Retrive the TALLOC_CTX associated with a REGISTRY_VALUE
- **********************************************************************/
-
-TALLOC_CTX* regval_ctr_getctx( REGVAL_CTR *val )
-{
- if ( !val )
- return NULL;
-
- return val->ctx; }
-
-/***********************************************************************
Check for the existance of a value
**********************************************************************/
@@ -316,22 +281,22 @@ int regval_ctr_addvalue( REGVAL_CTR *ctr, const char *name, uint16 type,
/* allocate a slot in the array of pointers */
if ( ctr->num_values == 0 )
- ctr->values = TALLOC_P( ctr->ctx, REGISTRY_VALUE *);
+ ctr->values = TALLOC_P( ctr, REGISTRY_VALUE *);
else {
- ppreg = TALLOC_REALLOC_ARRAY( ctr->ctx, ctr->values, REGISTRY_VALUE *, ctr->num_values+1 );
+ ppreg = TALLOC_REALLOC_ARRAY( ctr, ctr->values, REGISTRY_VALUE *, ctr->num_values+1 );
if ( ppreg )
ctr->values = ppreg;
}
/* allocate a new value and store the pointer in the arrya */
- ctr->values[ctr->num_values] = TALLOC_P( ctr->ctx, REGISTRY_VALUE);
+ ctr->values[ctr->num_values] = TALLOC_P( ctr, REGISTRY_VALUE);
/* init the value */
fstrcpy( ctr->values[ctr->num_values]->valuename, name );
ctr->values[ctr->num_values]->type = type;
- ctr->values[ctr->num_values]->data_p = TALLOC_MEMDUP( ctr->ctx, data_p, size );
+ ctr->values[ctr->num_values]->data_p = TALLOC_MEMDUP( ctr, data_p, size );
ctr->values[ctr->num_values]->size = size;
ctr->num_values++;
@@ -351,22 +316,22 @@ int regval_ctr_copyvalue( REGVAL_CTR *ctr, REGISTRY_VALUE *val )
/* allocate a slot in the array of pointers */
if ( ctr->num_values == 0 )
- ctr->values = TALLOC_P( ctr->ctx, REGISTRY_VALUE *);
+ ctr->values = TALLOC_P( ctr, REGISTRY_VALUE *);
else {
- ppreg = TALLOC_REALLOC_ARRAY( ctr->ctx, ctr->values, REGISTRY_VALUE *, ctr->num_values+1 );
+ ppreg = TALLOC_REALLOC_ARRAY( ctr, ctr->values, REGISTRY_VALUE *, ctr->num_values+1 );
if ( ppreg )
ctr->values = ppreg;
}
/* allocate a new value and store the pointer in the arrya */
- ctr->values[ctr->num_values] = TALLOC_P( ctr->ctx, REGISTRY_VALUE);
+ ctr->values[ctr->num_values] = TALLOC_P( ctr, REGISTRY_VALUE);
/* init the value */
fstrcpy( ctr->values[ctr->num_values]->valuename, val->valuename );
ctr->values[ctr->num_values]->type = val->type;
- ctr->values[ctr->num_values]->data_p = TALLOC_MEMDUP( ctr->ctx, val->data_p, val->size );
+ ctr->values[ctr->num_values]->data_p = TALLOC_MEMDUP( ctr, val->data_p, val->size );
ctr->values[ctr->num_values]->size = val->size;
ctr->num_values++;
}
@@ -420,16 +385,3 @@ REGISTRY_VALUE* regval_ctr_getvalue( REGVAL_CTR *ctr, const char *name )
return NULL;
}
-/***********************************************************************
- free memory held by a REGVAL_CTR structure
- **********************************************************************/
-
-void regval_ctr_destroy( REGVAL_CTR *ctr )
-{
- if ( ctr ) {
- talloc_destroy( ctr->ctx );
- ZERO_STRUCTP( ctr );
- }
-}
-
-
diff --git a/source3/registry/reg_printing.c b/source3/registry/reg_printing.c
index c1f7d3925f..d0f7daa926 100644
--- a/source3/registry/reg_printing.c
+++ b/source3/registry/reg_printing.c
@@ -261,7 +261,7 @@ static int key_printers_fetch_keys( const char *key, REGSUBKEY_CTR *subkeys )
return -1;
}
- num_subkeys = get_printer_subkeys( &printer->info_2->data, printerdatakey?printerdatakey:"", &subkey_names );
+ num_subkeys = get_printer_subkeys( printer->info_2->data, printerdatakey?printerdatakey:"", &subkey_names );
for ( i=0; i<num_subkeys; i++ )
regsubkey_ctr_addkey( subkeys, subkey_names[i] );
@@ -345,7 +345,7 @@ static BOOL key_printers_store_keys( const char *key, REGSUBKEY_CTR *subkeys )
/* get the top level printer keys */
- num_existing_keys = get_printer_subkeys( &printer->info_2->data, "", &existing_subkeys );
+ num_existing_keys = get_printer_subkeys( printer->info_2->data, "", &existing_subkeys );
for ( i=0; i<num_existing_keys; i++ ) {
@@ -354,7 +354,7 @@ static BOOL key_printers_store_keys( const char *key, REGSUBKEY_CTR *subkeys )
if ( !regsubkey_ctr_key_exists( subkeys, existing_subkeys[i] ) ) {
DEBUG(5,("key_printers_store_keys: deleting key %s\n",
existing_subkeys[i]));
- delete_printer_key( &printer->info_2->data, existing_subkeys[i] );
+ delete_printer_key( printer->info_2->data, existing_subkeys[i] );
}
}
@@ -362,10 +362,10 @@ static BOOL key_printers_store_keys( const char *key, REGSUBKEY_CTR *subkeys )
for ( i=0; i<num_subkeys; i++ ) {
subkeyname = regsubkey_ctr_specific_key(subkeys, i);
/* add any missing printer keys */
- if ( lookup_printerkey(&printer->info_2->data, subkeyname) == -1 ) {
+ if ( lookup_printerkey(printer->info_2->data, subkeyname) == -1 ) {
DEBUG(5,("key_printers_store_keys: adding key %s\n",
existing_subkeys[i]));
- if ( add_new_printer_key( &printer->info_2->data, subkeyname ) == -1 )
+ if ( add_new_printer_key( printer->info_2->data, subkeyname ) == -1 )
return False;
}
}
@@ -445,7 +445,7 @@ static void fill_in_printer_values( NT_PRINTER_INFO_LEVEL_2 *info2, REGVAL_CTR *
/* use a prs_struct for converting the devmode and security
descriptor to REG_BINARY */
- prs_init( &prs, MAX_PDU_FRAG_LEN, regval_ctr_getctx(values), MARSHALL);
+ prs_init( &prs, MAX_PDU_FRAG_LEN, values, MARSHALL);
/* stream the device mode */
@@ -508,7 +508,7 @@ static int key_printers_fetch_values( const char *key, REGVAL_CTR *values )
/* iterate over all printer data keys and fill the regval container */
- p_data = &printer->info_2->data;
+ p_data = printer->info_2->data;
if ( (key_index = lookup_printerkey( p_data, printerdatakey )) == -1 ) {
/* failure....should never happen if the client has a valid open handle first */
DEBUG(10,("key_printers_fetch_values: Unknown keyname [%s]\n", printerdatakey));
@@ -517,9 +517,9 @@ static int key_printers_fetch_values( const char *key, REGVAL_CTR *values )
return -1;
}
- num_values = regval_ctr_numvals( &p_data->keys[key_index].values );
+ num_values = regval_ctr_numvals( p_data->keys[key_index].values );
for ( i=0; i<num_values; i++ )
- regval_ctr_copyvalue( values, regval_ctr_specific_value(&p_data->keys[key_index].values, i) );
+ regval_ctr_copyvalue( values, regval_ctr_specific_value(p_data->keys[key_index].values, i) );
done:
@@ -702,7 +702,7 @@ static BOOL key_printers_store_values( const char *key, REGVAL_CTR *values )
int i;
REGISTRY_VALUE *val;
- delete_printer_key( &printer->info_2->data, keyname );
+ delete_printer_key( printer->info_2->data, keyname );
/* deal with any subkeys */
for ( i=0; i<num_values; i++ ) {