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

4 files changed, 385 insertions, 170 deletions

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