summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--source3/include/rpc_reg.h33
-rw-r--r--source3/lib/adt_tree.c47
-rw-r--r--source3/registry/reg_cachehook.c4
-rw-r--r--source3/registry/reg_db.c145
-rw-r--r--source3/registry/reg_frontend.c207
-rw-r--r--source3/registry/reg_printing.c199
-rw-r--r--source3/rpc_server/srv_reg_nt.c93
7 files changed, 488 insertions, 240 deletions
diff --git a/source3/include/rpc_reg.h b/source3/include/rpc_reg.h
index 071ef408d4..7dbf49cf84 100644
--- a/source3/include/rpc_reg.h
+++ b/source3/include/rpc_reg.h
@@ -66,7 +66,7 @@
#define KEY_HKLM "HKLM"
#define KEY_HKU "HKU"
#define KEY_PRINTING "HKLM\\SYSTEM\\CurrentControlSet\\Control\\Print"
-
+#define KEY_TREE_ROOT ""
/* Registry data types */
@@ -89,7 +89,7 @@
/* structure to contain registry values */
-typedef struct _RegistryValue {
+typedef struct {
fstring valuename;
uint16 type;
uint32 size; /* in bytes */
@@ -100,22 +100,37 @@ typedef struct _RegistryValue {
} data;
} REGISTRY_VALUE;
+/* container for regostry values */
+
+typedef struct {
+ TALLOC_CTX *ctx;
+ uint32 num_values;
+ REGISTRY_VALUE **values;
+} REGVAL_CTR;
+
+/* container for registry subkey names */
+
+typedef struct {
+ TALLOC_CTX *ctx;
+ uint32 num_subkeys;
+ char **subkeys;
+} REGSUBKEY_CTR;
+
/*
* container for function pointers to enumeration routines
* for vitural registry view
*/
-typedef struct _reg_ops {
+typedef struct {
/* functions for enumerating subkeys and values */
- int (*subkey_fn)( char *key, char **subkeys );
- int (*subkey_specific_fn)( char *key, char** subkey, uint32 indx );
- int (*value_fn) ( char *key, REGISTRY_VALUE **val );
- BOOL (*store_subkeys_fn)( char *key, char **subkeys, uint32 num_subkeys );
- BOOL (*store_values_fn)( char *key, REGISTRY_VALUE **val, uint32 num_values );
+ int (*subkey_fn)( char *key, REGSUBKEY_CTR *subkeys);
+ int (*value_fn) ( char *key, REGVAL_CTR *val );
+ BOOL (*store_subkeys_fn)( char *key, REGSUBKEY_CTR *subkeys );
+ BOOL (*store_values_fn)( char *key, REGVAL_CTR *val );
} REGISTRY_OPS;
-typedef struct _reg_hook {
+typedef struct {
char *keyname; /* full path to name of key */
REGISTRY_OPS *ops; /* registry function hooks */
} REGISTRY_HOOK;
diff --git a/source3/lib/adt_tree.c b/source3/lib/adt_tree.c
index e3519c6c41..3a6e722c97 100644
--- a/source3/lib/adt_tree.c
+++ b/source3/lib/adt_tree.c
@@ -26,7 +26,8 @@
for comparision of two children
*************************************************************************/
-SORTED_TREE* sorted_tree_init( int (cmp_fn)(void*, void*),
+SORTED_TREE* sorted_tree_init( void *data_p,
+ int (cmp_fn)(void*, void*),
void (free_fn)(void*) )
{
SORTED_TREE *tree = NULL;
@@ -45,6 +46,7 @@ SORTED_TREE* sorted_tree_init( int (cmp_fn)(void*, void*),
}
ZERO_STRUCTP( tree->root );
+ tree->root->data_p = data_p;
return tree;
}
@@ -94,7 +96,6 @@ void sorted_tree_destroy( SORTED_TREE *tree )
static TREE_NODE* sorted_tree_birth_child( TREE_NODE *node, char* key )
{
TREE_NODE *infant = NULL;
- TREE_NODE *child, *crib;
TREE_NODE **siblings;
int i, result;
@@ -116,7 +117,7 @@ static TREE_NODE* sorted_tree_birth_child( TREE_NODE *node, char* key )
/* first child */
if ( node->num_children == 1 ) {
- DEBUG(11,("sorted_tree_birth_child: First child of node [%s]! [%s]\n",
+ DEBUG(10,("sorted_tree_birth_child: First child of node [%s]! [%s]\n",
node->key ? node->key : "NULL", infant->key ));
node->children[0] = infant;
}
@@ -133,23 +134,28 @@ static TREE_NODE* sorted_tree_birth_child( TREE_NODE *node, char* key )
for ( i = node->num_children-1; i>=1; i-- )
{
- crib = node->children[i];
- child = node->children[i-1];
-
DEBUG(10,("sorted_tree_birth_child: Looking for crib; infant -> [%s], child -> [%s]\n",
- infant->key, child->key));
+ infant->key, node->children[i-1]->key));
/* the strings should never match assuming that we
have called sorted_tree_find_child() first */
- result = StrCaseCmp( infant->key, child->key );
+ result = StrCaseCmp( infant->key, node->children[i-1]->key );
if ( result > 0 ) {
- crib = infant;
+ node->children[i] = infant;
break;
}
-
- crib = child;
+
+ /* bump everything towards the end on slot */
+
+ node->children[i] = node->children[i-1];
}
+
+ /* if we haven't found the correct clot yet, the child
+ will be first in the list */
+
+ if ( i == 0 )
+ node->children[0] = infant;
}
return infant;
@@ -376,6 +382,9 @@ void* sorted_tree_find( SORTED_TREE *tree, char *key )
str = keystr;
current = tree->root;
+ if ( tree->root->data_p )
+ result = tree->root->data_p;
+
do
{
/* break off the remaining part of the path */
@@ -384,7 +393,7 @@ void* sorted_tree_find( SORTED_TREE *tree, char *key )
if ( str )
*str = '\0';
- DEBUG(10,("sorted_tree_find: [loop] key => [%s]\n", base));
+ DEBUG(11,("sorted_tree_find: [loop] key => [%s]\n", base));
/* iterate to the next child */
@@ -399,10 +408,18 @@ void* sorted_tree_find( SORTED_TREE *tree, char *key )
str = base;
}
+ /*
+ * the idea is that the data_p for a parent should
+ * be inherited by all children, but allow it to be
+ * overridden farther down
+ */
+
+ if ( current && current->data_p )
+ result = current->data_p;
+
} while ( base && current );
-
- if ( current )
- result = current->data_p;
+
+ /* result should be the data_p from the lowest match node in the tree */
SAFE_FREE( keystr );
diff --git a/source3/registry/reg_cachehook.c b/source3/registry/reg_cachehook.c
index daf2f24180..346ba20eb7 100644
--- a/source3/registry/reg_cachehook.c
+++ b/source3/registry/reg_cachehook.c
@@ -26,6 +26,8 @@
#define DBGC_CLASS DBGC_RPC_SRV
static SORTED_TREE *cache_tree;
+extern REGISTRY_OPS regdb_ops; /* these are the default */
+static REGISTRY_HOOK default_hook = { KEY_TREE_ROOT, &regdb_ops };
/**********************************************************************
Initialize the cache tree
@@ -33,7 +35,7 @@ static SORTED_TREE *cache_tree;
BOOL reghook_cache_init( void )
{
- cache_tree = sorted_tree_init( NULL, NULL );
+ cache_tree = sorted_tree_init( &default_hook, NULL, NULL );
return ( cache_tree == NULL );
}
diff --git a/source3/registry/reg_db.c b/source3/registry/reg_db.c
index a521cdcdd0..d44a8d004c 100644
--- a/source3/registry/reg_db.c
+++ b/source3/registry/reg_db.c
@@ -34,73 +34,72 @@ static TDB_CONTEXT *tdb_reg;
static BOOL init_registry_data( void )
{
- pstring keyname;
- char *subkeys[3];
+ pstring keyname;
+ REGSUBKEY_CTR subkeys;
+
+ ZERO_STRUCTP( &subkeys );
+
+ regsubkey_ctr_init( &subkeys );
/* HKEY_LOCAL_MACHINE */
pstrcpy( keyname, KEY_HKLM );
- subkeys[0] = "SYSTEM";
- if ( !regdb_store_reg_keys( keyname, subkeys, 1 ))
+ regsubkey_ctr_addkey( &subkeys, "SYSTEM" );
+ if ( !regdb_store_reg_keys( keyname, &subkeys ))
return False;
+ regsubkey_ctr_destroy( &subkeys );
pstrcpy( keyname, KEY_HKLM );
pstrcat( keyname, "/SYSTEM" );
- subkeys[0] = "CurrentControlSet";
- if ( !regdb_store_reg_keys( keyname, subkeys, 1 ))
+ regsubkey_ctr_addkey( &subkeys, "CurrentControlSet" );
+ if ( !regdb_store_reg_keys( keyname, &subkeys ))
return False;
+ regsubkey_ctr_destroy( &subkeys );
pstrcpy( keyname, KEY_HKLM );
pstrcat( keyname, "/SYSTEM/CurrentControlSet" );
- subkeys[0] = "Control";
- subkeys[1] = "services";
- if ( !regdb_store_reg_keys( keyname, subkeys, 2 ))
+ regsubkey_ctr_addkey( &subkeys, "Control" );
+ regsubkey_ctr_addkey( &subkeys, "services" );
+ if ( !regdb_store_reg_keys( keyname, &subkeys ))
return False;
+ regsubkey_ctr_destroy( &subkeys );
pstrcpy( keyname, KEY_HKLM );
pstrcat( keyname, "/SYSTEM/CurrentControlSet/Control" );
- subkeys[0] = "Print";
- subkeys[1] = "ProduceOptions";
- if ( !regdb_store_reg_keys( keyname, subkeys, 2 ))
- return False;
-
-#if 0 /* JERRY */
- pstrcpy( keyname, KEY_HKLM );
- pstrcat( keyname, "/SYSTEM/CurrentControlSet/Control/Print" );
- subkeys[0] = "Environments";
- subkeys[1] = "Forms";
- subkeys[2] = "Printers";
- if ( !regdb_store_reg_keys( keyname, subkeys, 0 ))
+ regsubkey_ctr_addkey( &subkeys, "Print" );
+ regsubkey_ctr_addkey( &subkeys, "ProductOptions" );
+ if ( !regdb_store_reg_keys( keyname, &subkeys ))
return False;
-#endif
+ regsubkey_ctr_destroy( &subkeys );
pstrcpy( keyname, KEY_HKLM );
pstrcat( keyname, "/SYSTEM/CurrentControlSet/Control/ProductOptions" );
- if ( !regdb_store_reg_keys( keyname, subkeys, 0 ))
+ if ( !regdb_store_reg_keys( keyname, &subkeys ))
return False;
pstrcpy( keyname, KEY_HKLM );
pstrcat( keyname, "/SYSTEM/CurrentControlSet/services" );
- subkeys[0] = "Netlogon";
- if ( !regdb_store_reg_keys( keyname, subkeys, 1 ))
+ regsubkey_ctr_addkey( &subkeys, "Netlogon" );
+ if ( !regdb_store_reg_keys( keyname, &subkeys ))
return False;
+ regsubkey_ctr_destroy( &subkeys );
pstrcpy( keyname, KEY_HKLM );
pstrcat( keyname, "/SYSTEM/CurrentControlSet/services/Netlogon" );
- subkeys[0] = "parameters";
- if ( !regdb_store_reg_keys( keyname, subkeys, 1 ))
+ regsubkey_ctr_addkey( &subkeys, "parameters" );
+ if ( !regdb_store_reg_keys( keyname, &subkeys ))
return False;
+ regsubkey_ctr_destroy( &subkeys );
pstrcpy( keyname, KEY_HKLM );
pstrcat( keyname, "/SYSTEM/CurrentControlSet/services/Netlogon/parameters" );
- if ( !regdb_store_reg_keys( keyname, subkeys, 0 ))
+ if ( !regdb_store_reg_keys( keyname, &subkeys ))
return False;
-
/* HKEY_USER */
pstrcpy( keyname, KEY_HKU );
- if ( !regdb_store_reg_keys( keyname, subkeys, 0 ) )
+ if ( !regdb_store_reg_keys( keyname, &subkeys ) )
return False;
return True;
@@ -157,13 +156,14 @@ BOOL init_registry_db( void )
\'s are converted to /'s.
***********************************************************************/
-BOOL regdb_store_reg_keys( char *keyname, char **subkeys, uint32 num_subkeys )
+BOOL regdb_store_reg_keys( char *keyname, REGSUBKEY_CTR *ctr )
{
TDB_DATA kbuf, dbuf;
char *buffer, *tmpbuf;
int i = 0;
uint32 len, buflen;
BOOL ret = True;
+ uint32 num_subkeys = regsubkey_ctr_numkeys( ctr );
if ( !keyname )
return False;
@@ -176,23 +176,23 @@ BOOL regdb_store_reg_keys( char *keyname, char **subkeys, uint32 num_subkeys )
/* 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<num_subkeys; i++) {
- len += tdb_pack(buffer+len, buflen-len, "f", subkeys[i]);
+ len += tdb_pack( buffer+len, buflen-len, "f", regsubkey_ctr_specific_key(ctr, i) );
if ( len > buflen ) {
/* allocate some extra space */
if ((tmpbuf = Realloc( buffer, len*2 )) == NULL) {
- DEBUG(0,("store_reg_keys: Failed to realloc memory of size [%d]\n", len*2));
+ DEBUG(0,("regdb_store_reg_keys: Failed to realloc memory of size [%d]\n", len*2));
ret = False;
goto done;
}
buffer = tmpbuf;
buflen = len*2;
- len = tdb_pack(buffer+len, buflen-len, "f", subkeys[i]);
+ len = tdb_pack( buffer+len, buflen-len, "f", regsubkey_ctr_specific_key(ctr, i) );
}
}
@@ -218,7 +218,7 @@ done:
of null terminated character strings
***********************************************************************/
-int regdb_fetch_reg_keys( char* key, char **subkeys )
+int regdb_fetch_reg_keys( char* key, REGSUBKEY_CTR *ctr )
{
pstring path;
uint32 num_items;
@@ -226,7 +226,7 @@ int regdb_fetch_reg_keys( char* key, char **subkeys )
char *buf;
uint32 buflen, len;
int i;
- char *s;
+ fstring subkeyname;
pstrcpy( path, key );
@@ -240,72 +240,53 @@ int regdb_fetch_reg_keys( char* key, char **subkeys )
buflen = dbuf.dsize;
if ( !buf ) {
- DEBUG(5,("fetch_reg_keys: Failed to fetch any subkeys for [%s]\n", key));
+ DEBUG(5,("regdb_fetch_reg_keys: Failed to fetch any subkeys for [%s]\n", key));
return 0;
}
len = tdb_unpack( buf, buflen, "d", &num_items);
- if (num_items) {
- if ( (*subkeys = (char*)malloc(sizeof(fstring)*num_items)) == NULL ) {
- DEBUG(0,("fetch_reg_keys: Failed to malloc memory for subkey array containing [%d] items!\n",
- num_items));
- num_items = -1;
- goto done;
- }
- }
- s = *subkeys;
for (i=0; i<num_items; i++) {
- len += tdb_unpack( buf+len, buflen-len, "f", s );
- s += strlen(s) + 1;
+ len += tdb_unpack( buf+len, buflen-len, "f", subkeyname );
+ regsubkey_ctr_addkey( ctr, subkeyname );
}
-done:
SAFE_FREE(dbuf.dptr);
return num_items;
}
+
/***********************************************************************
- retreive a specific subkey specified by index. The subkey parameter
- is assumed to be an fstring.
+ Retrieve an array of strings containing subkeys. Memory should be
+ released by the caller. The subkeys are stored in a catenated string
+ of null terminated character strings
***********************************************************************/
-BOOL regdb_fetch_reg_keys_specific( char* key, char** subkey, uint32 key_index )
+int regdb_fetch_reg_values( char* key, REGVAL_CTR *val )
{
- int num_subkeys, i;
- char *subkeys = NULL;
- char *s;
-
- num_subkeys = regdb_fetch_reg_keys( key, &subkeys );
- if ( num_subkeys == -1 )
- return False;
-
- s = subkeys;
- for ( i=0; i<num_subkeys; i++ ) {
- /* copy the key if the index matches */
- if ( i == key_index ) {
- *subkey = strdup( s );
- break;
- }
-
- /* go onto the next string */
- s += strlen(s) + 1;
- }
-
- SAFE_FREE(subkeys);
-
- return True;
+ return 0;
}
-
/***********************************************************************
- Retrieve an array of strings containing subkeys. Memory should be
- released by the caller. The subkeys are stored in a catenated string
- of null terminated character strings
+ Stub function since we do not currently support storing registry
+ values in the registry.tdb
***********************************************************************/
-int regdb_fetch_reg_values( char* key, REGISTRY_VALUE **val )
+BOOL regdb_store_reg_values( char *key, REGVAL_CTR *val )
{
- return 0;
+ return False;
}
+
+/*
+ * Table of function pointers for default access
+ */
+
+REGISTRY_OPS regdb_ops = {
+ regdb_fetch_reg_keys,
+ regdb_fetch_reg_values,
+ regdb_store_reg_keys,
+ regdb_store_reg_values
+};
+
+
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, &regdb_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;
+}
diff --git a/source3/registry/reg_printing.c b/source3/registry/reg_printing.c
index cbeab13142..b2403a3133 100644
--- a/source3/registry/reg_printing.c
+++ b/source3/registry/reg_printing.c
@@ -51,9 +51,26 @@ static char *top_level_keys[MAX_TOP_LEVEL_KEYS] = {
static char* trim_reg_path( char *path )
{
char *p;
+ uint16 key_len = strlen(KEY_PRINTING);
+
+ /*
+ * sanity check...this really should never be True.
+ * It is only here to prevent us from accessing outside
+ * the path buffer in the extreme case.
+ */
+
+ if ( strlen(path) < key_len ) {
+ DEBUG(0,("trim_reg_path: Registry path too short! [%s]\n", path));
+ DEBUG(0,("trim_reg_path: KEY_PRINTING => [%s]!\n", KEY_PRINTING));
+ return NULL;
+ }
+
p = path + strlen(KEY_PRINTING);
+ if ( *p == '\\' )
+ p++;
+
if ( *p )
return strdup(p);
else
@@ -61,15 +78,98 @@ static char* trim_reg_path( char *path )
}
/**********************************************************************
- handle enumeration of subkeys below KEY_PRINTING.
+ handle enumeration of subkeys below KEY_PRINTING\Environments
+ *********************************************************************/
+
+static int print_subpath_environments( char *key, REGSUBKEY_CTR *subkeys, int32 idx )
+{
+ DEBUG(10,("print_subpath_environments: key=>[%s]\n", key ? key : "NULL" ));
+
+ if ( !key )
+ {
+ /* listed architectures of installed drivers */
+
+ }
+
+
+ return 0;
+}
+
+/**********************************************************************
+ handle enumeration of subkeys below KEY_PRINTING\Forms
*********************************************************************/
-static int handle_printing_subpath( char *key, char **subkeys, uint32 index )
+static int print_subpath_forms( char *key, REGSUBKEY_CTR *subkeys, int32 idx )
+{
+ DEBUG(10,("print_subpath_forms: key=>[%s]\n", key ? key : "NULL" ));
+
+ return 0;
+}
+
+/**********************************************************************
+ handle enumeration of values below KEY_PRINTING\Forms
+ *********************************************************************/
+
+static int print_values_forms( char *key, REGVAL_CTR *val, int idx )
+{
+ int num_values = 0;
+
+ DEBUG(10,("print_values_forms: key=>[%s]\n", key ? key : "NULL" ));
+
+ /* handle ..\Forms\ */
+
+#if 0 /* JERRY */
+ if ( !key )
+ {
+ nt_forms_struct *forms = NULL;
+ int i;
+
+ if ( (num_values = get_ntforms( &forms )) == 0 )
+ return 0;
+
+ if ( !(*values = malloc(sizeof(REGISTRY_VALUE) * num_values)) ) {
+ DEBUG(0,("print_values_forms: Failed to malloc memory for [%d] REGISTRY_VALUE structs!\n",
+ num_values));
+ return -1;
+ }
+
+ for ( i=0; i<num_values; i++ )
+ {
+
+
+ }
+ }
+#endif
+
+ return num_values;
+}
+
+/**********************************************************************
+ handle enumeration of subkeys below KEY_PRINTING\Printers
+ *********************************************************************/
+
+static int print_subpath_printers( char *key, REGSUBKEY_CTR *subkeys, int32 idx )
+{
+ DEBUG(10,("print_subpath_printers: key=>[%s]\n", key ? key : "NULL" ));
+
+ return 0;
+}
+
+/**********************************************************************
+ Routine to handle enumeration of subkeys and values
+ below KEY_PRINTING (depending on whether or not subkeys/val are
+ valid pointers.
+ *********************************************************************/
+
+static int handle_printing_subpath( char *key, REGSUBKEY_CTR *subkeys,
+ REGVAL_CTR *val, int32 key_index, int32 val_index )
{
int result = 0;
char *p, *base;
int i;
-
+
+ DEBUG(10,("handle_printing_subpath: key=>[%s], key_index == [%d], val_index == [%d]\n",
+ key, key_index, val_index));
/*
* break off the first part of the path
@@ -77,29 +177,36 @@ static int handle_printing_subpath( char *key, char **subkeys, uint32 index )
* in top_level_keys[]
*/
- base = key;
- p = strchr( key, '\\' );
- if ( p )
- *p = '\0';
+ reg_split_path( key, &base, &p);
for ( i=0; i<MAX_TOP_LEVEL_KEYS; i++ ) {
if ( StrCaseCmp( top_level_keys[i], base ) == 0 )
break;
}
- if ( !(i < MAX_TOP_LEVEL_KEYS) )
+ DEBUG(10,("handle_printing_subpath: base=>[%s], i==[%d]\n", base, i));
+
+ if ( (key_index != -1) && !(i < MAX_TOP_LEVEL_KEYS) )
return -1;
-
+
/* Call routine to handle each top level key */
switch ( i )
{
case KEY_INDEX_ENVIR:
+ if ( subkeys )
+ print_subpath_environments( p, subkeys, key_index );
+#if 0 /* JERRY */
+ if ( val )
+ print_subpath_values_environments( p, val, val_index );
+#endif
break;
case KEY_INDEX_FORMS:
+ result = print_subpath_forms( p, subkeys, key_index );
break;
case KEY_INDEX_PRINTER:
+ result = print_subpath_printers( p, subkeys, key_index );
break;
/* default case for top level key that has no handler */
@@ -118,7 +225,7 @@ static int handle_printing_subpath( char *key, char **subkeys, uint32 index )
Caller is responsible for freeing memory to **subkeys
*********************************************************************/
-int printing_subkey_info( char *key, char **subkeys )
+int printing_subkey_info( char *key, REGSUBKEY_CTR *subkey_ctr )
{
char *path;
BOOL top_level = False;
@@ -134,32 +241,29 @@ int printing_subkey_info( char *key, char **subkeys )
top_level = True;
if ( top_level ) {
- if ( ! (*subkeys = malloc( sizeof(top_level_keys) )) )
- goto done;
-
- num_subkeys = MAX_TOP_LEVEL_KEYS;
- memcpy( *subkeys, top_level_keys, sizeof(top_level_keys) );
+ for ( num_subkeys=0; num_subkeys<MAX_TOP_LEVEL_KEYS; num_subkeys++ )
+ regsubkey_ctr_addkey( subkey_ctr, top_level_keys[num_subkeys] );
}
else
- num_subkeys = handle_printing_subpath( path, subkeys, -1 );
+ num_subkeys = handle_printing_subpath( path, subkey_ctr, NULL, -1, -1 );
-done:
SAFE_FREE( path );
+
return num_subkeys;
}
/**********************************************************************
- Count the registry subkey names given a registry path.
- Caller is responsible for freeing memory to **subkey
+ Enumerate registry values given a registry path.
+ Caller is responsible for freeing memory
*********************************************************************/
-
-BOOL printing_subkey_specific( char *key, char** subkey, uint32 indx )
+
+int printing_value_info( char *key, REGVAL_CTR *val )
{
char *path;
BOOL top_level = False;
- BOOL result = False;
+ int num_values = 0;
- DEBUG(10,("printing_subkey_specific: key=>[%s], index=>[%d]\n", key, indx));
+ DEBUG(10,("printing_value_info: key=>[%s]\n", key));
path = trim_reg_path( key );
@@ -168,43 +272,16 @@ BOOL printing_subkey_specific( char *key, char** subkey, uint32 indx )
if ( !path )
top_level = True;
-
-
- if ( top_level ) {
-
- /* make sure the index is in range */
-
- if ( !(indx < MAX_TOP_LEVEL_KEYS) )
- goto done;
-
- if ( !(*subkey = malloc( strlen(top_level_keys[indx])+1 )) )
- goto done;
-
- strncpy( *subkey, top_level_keys[indx], strlen(top_level_keys[indx])+1 );
-
- result = True;
- }
- else {
- if ( handle_printing_subpath( path, subkey, indx ) != -1 )
- result = True;
+ /* fill in values from the getprinterdata_printer_server() */
+ if ( top_level )
+ {
+ num_values = 0;
}
+ else
+ num_values = handle_printing_subpath( path, NULL, val, -1, -1 );
+
-done:
- SAFE_FREE( path );
-
- return result;
-}
-
-/**********************************************************************
- Enumerate registry values given a registry path.
- Caller is responsible for freeing memory
- *********************************************************************/
-
-int printing_value_info( char *key, REGISTRY_VALUE **val )
-{
- DEBUG(10,("printing_value_info: key=>[%s]\n", key));
-
- return 0;
+ return num_values;
}
/**********************************************************************
@@ -213,7 +290,7 @@ int printing_value_info( char *key, REGISTRY_VALUE **val )
(for now at least)
*********************************************************************/
-BOOL printing_store_subkey( char *key, char **subkeys, uint32 num_subkeys )
+BOOL printing_store_subkey( char *key, REGSUBKEY_CTR *subkeys )
{
return False;
}
@@ -224,7 +301,7 @@ BOOL printing_store_subkey( char *key, char **subkeys, uint32 num_subkeys )
(for now at least)
*********************************************************************/
-BOOL printing_store_value( char *key, REGISTRY_VALUE **val, uint32 num_values )
+BOOL printing_store_value( char *key, REGVAL_CTR *val )
{
return False;
}
@@ -235,9 +312,9 @@ BOOL printing_store_value( char *key, REGISTRY_VALUE **val, uint32 num_values )
REGISTRY_OPS printing_ops = {
printing_subkey_info,
- printing_subkey_specific,
printing_value_info,
printing_store_subkey,
printing_store_value
};
+
diff --git a/source3/rpc_server/srv_reg_nt.c b/source3/rpc_server/srv_reg_nt.c
index d5b2394b40..ebed13edfe 100644
--- a/source3/rpc_server/srv_reg_nt.c
+++ b/source3/rpc_server/srv_reg_nt.c
@@ -40,7 +40,7 @@ static REGISTRY_KEY *regkeys_list;
free() function for REGISTRY_KEY
*****************************************************************/
-static void free_reg_info(void *ptr)
+static void free_regkey_info(void *ptr)
{
REGISTRY_KEY *info = (REGISTRY_KEY*)ptr;
@@ -77,11 +77,10 @@ static REGISTRY_KEY *find_regkey_index_by_hnd(pipes_struct *p, POLICY_HND *hnd)
static NTSTATUS open_registry_key(pipes_struct *p, POLICY_HND *hnd, REGISTRY_KEY *parent,
char *subkeyname, uint32 access_granted )
{
- REGISTRY_KEY *regkey = NULL;
- pstring parent_keyname;
- NTSTATUS result = NT_STATUS_OK;
- int num_subkeys;
- char *subkeys = NULL;
+ REGISTRY_KEY *regkey = NULL;
+ pstring parent_keyname;
+ NTSTATUS result = NT_STATUS_OK;
+ REGSUBKEY_CTR subkeys;
if ( parent ) {
pstrcpy( parent_keyname, parent->name );
@@ -110,27 +109,23 @@ static NTSTATUS open_registry_key(pipes_struct *p, POLICY_HND *hnd, REGISTRY_KEY
pstrcpy( regkey->name, parent_keyname );
pstrcat( regkey->name, subkeyname );
- /* try to use en existing hook. Otherwise, try to lookup our own */
+ /* Look up the table of registry I/O operations */
- if ( parent && parent->hook )
- regkey->hook = parent->hook;
- else
- regkey->hook = reghook_cache_find( regkey->name );
-
- if ( regkey->hook ) {
- DEBUG(10,("open_registry_key: Assigned REGISTRY_HOOK to [%s]\n",
+ if ( !(regkey->hook = reghook_cache_find( regkey->name )) ) {
+ DEBUG(0,("open_registry_key: Failed to assigned a REGISTRY_HOOK to [%s]\n",
regkey->name ));
+ return NT_STATUS_OBJECT_PATH_NOT_FOUND;
}
- /* check if the path really exists...num_subkeys should be >= 0 */
+ /* check if the path really exists; failed is indicated by -1 */
+ /* if the subkey count failed, bail out */
+
+ ZERO_STRUCTP( &subkeys );
- num_subkeys = fetch_reg_keys( regkey, &subkeys );
+ regsubkey_ctr_init( &subkeys );
- /* if the subkey count failed, bail out */
+ if ( fetch_reg_keys( regkey, &subkeys ) == -1 ) {
- if ( num_subkeys == -1 ) {
- SAFE_FREE( regkey );
-
/* don't really know what to return here */
result = NT_STATUS_ACCESS_DENIED;
@@ -141,13 +136,18 @@ static NTSTATUS open_registry_key(pipes_struct *p, POLICY_HND *hnd, REGISTRY_KEY
* that doesn't sound quite right to me --jerry
*/
- if ( !create_policy_hnd( p, hnd, free_reg_info, regkey ) )
+ if ( !create_policy_hnd( p, hnd, free_regkey_info, regkey ) )
result = NT_STATUS_OBJECT_NAME_NOT_FOUND;
}
DEBUG(7,("open_registry_key: exit\n"));
- SAFE_FREE( subkeys );
+ /* clean up */
+
+ regsubkey_ctr_destroy( &subkeys );
+
+ if ( ! NT_STATUS_IS_OK(result) )
+ SAFE_FREE( regkey );
return result;
}
@@ -177,37 +177,35 @@ static BOOL close_registry_key(pipes_struct *p, POLICY_HND *hnd)
static BOOL get_subkey_information( REGISTRY_KEY *key, uint32 *maxnum, uint32 *maxlen )
{
- int num_subkeys, i;
- uint32 max_len;
- char *subkeys = NULL;
- uint32 len;
- char *s;
+ int num_subkeys, i;
+ uint32 max_len;
+ REGSUBKEY_CTR subkeys;
+ uint32 len;
if ( !key )
return False;
+
+ ZERO_STRUCTP( &subkeys );
- /* first use any registry hook available.
- Fall back to tdb if non available */
+ regsubkey_ctr_init( &subkeys );
- num_subkeys = fetch_reg_keys( key, &subkeys );
-
- if ( num_subkeys == -1 )
+ if ( fetch_reg_keys( key, &subkeys ) == -1 )
return False;
/* find the longest string */
max_len = 0;
- s = subkeys;
+ num_subkeys = regsubkey_ctr_numkeys( &subkeys );
+
for ( i=0; i<num_subkeys; i++ ) {
- len = strlen(s);
+ len = strlen( regsubkey_ctr_specific_key(&subkeys, i) );
max_len = MAX(max_len, len);
- s += len + 1;
}
*maxnum = num_subkeys;
*maxlen = max_len*2;
- SAFE_FREE(subkeys);
+ regsubkey_ctr_destroy( &subkeys );
return True;
}
@@ -221,31 +219,34 @@ static BOOL get_subkey_information( REGISTRY_KEY *key, uint32 *maxnum, uint32 *m
static BOOL get_value_information( REGISTRY_KEY *key, uint32 *maxnum,
uint32 *maxlen, uint32 *maxsize )
{
- REGISTRY_VALUE *val = NULL;
- uint32 i, sizemax, lenmax;
- int num_values;
+ REGVAL_CTR val;
+ uint32 sizemax, lenmax;
+ int num_values;
if ( !key )
return False;
- num_values = fetch_reg_values( key, &val );
-
- if ( num_values == -1 )
+ ZERO_STRUCTP( &val );
+
+ regval_ctr_init( &val );
+
+ if ( fetch_reg_values( key, &val ) == -1 )
return False;
-
lenmax = sizemax = 0;
-
+ num_values = regval_ctr_numvals( &val );
+
+#if 0 /* JERRY */
for ( i=0; i<num_values; i++ ) {
lenmax = MAX(lenmax, strlen(val[i].valuename)+1 );
sizemax = MAX(sizemax, val[i].size );
}
-
+#endif
*maxnum = num_values;
*maxlen = lenmax;
*maxsize = sizemax;
- SAFE_FREE( val );
+ regval_ctr_destroy( &val );
return True;
}