* 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)

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;
 }