* changed structure of REG_R_ENUM_VALUE structure since the BUFFER2

  is not and [in/out] buffer

* registry value enumeration is working now for the Print\Forms
  key.  The format of the binary data is not quite right yet
  but all installed forms are listed
(This used to be commit 998eb9c7312c3c9a9ed1e9ec294593503c0304bf)

1 files changed, 260 insertions, 145 deletions

diff --git a/source3/registry/reg_frontend.c b/source3/registry/reg_frontend.c
index d8a10940fd..a282207376 100644
--- a/source3/registry/reg_frontend.c
+++ b/source3/registry/reg_frontend.c
@@ -37,151 +37,6 @@ REGISTRY_HOOK reg_hooks[] = {
 };
 
 
-/***********************************************************************
- Open the registry database and initialize the REGISTRY_HOOK cache
- ***********************************************************************/
- 
-BOOL init_registry( void )
-{
-	int i;
-	
-	if ( !init_registry_db() ) {
-		DEBUG(0,("init_registry: failed to initialize the registry tdb!\n"));
-		return False;
-	}
-		
-	/* build the cache tree of registry hooks */
-	
-	reghook_cache_init();
-	
-	for ( i=0; reg_hooks[i].keyname; i++ ) {
-		if ( !reghook_cache_add(&reg_hooks[i]) )
-			return False;
-	}
-
-	if ( DEBUGLEVEL >= 20 )
-		reghook_dump_cache(20);
-
-	return True;
-}
-
-
-
-
-/***********************************************************************
- High level wrapper function for storing registry subkeys
- ***********************************************************************/
- 
-BOOL store_reg_keys( REGISTRY_KEY *key, REGSUBKEY_CTR *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;
-
-}
-
-/***********************************************************************
- High level wrapper function for storing registry values
- ***********************************************************************/
- 
-BOOL store_reg_values( REGISTRY_KEY *key, REGVAL_CTR *val )
-{
-	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, REGSUBKEY_CTR *subkey_ctr )
-{
-	int result = -1;
-	
-	if ( key->hook && key->hook->ops && key->hook->ops->subkey_fn )
-		result = key->hook->ops->subkey_fn( key->name, subkey_ctr );
-
-	return result;
-}
-
-/***********************************************************************
- 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 )
-{
-	char *s;
-	REGSUBKEY_CTR ctr;
-	
-	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, REGVAL_CTR *val )
-{
-	int result = -1;
-	
-	if ( key->hook && key->hook->ops && key->hook->ops->value_fn )
-		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
  */
@@ -209,6 +64,8 @@ int regsubkey_ctr_addkey( REGSUBKEY_CTR *ctr, char *keyname )
 	{
 		len = strlen( keyname );
 
+		/* allocate a space for the char* in the array */
+		
 		if (  ctr->subkeys == 0 )
 			ctr->subkeys = talloc( ctr->ctx, sizeof(char*) );
 		else {
@@ -217,6 +74,8 @@ int regsubkey_ctr_addkey( REGSUBKEY_CTR *ctr, char *keyname )
 				ctr->subkeys = pp;
 		}
 
+		/* allocate the string and save it in the array */
+		
 		ctr->subkeys[ctr->num_subkeys] = talloc( ctr->ctx, len+1 );
 		strncpy( ctr->subkeys[ctr->num_subkeys], keyname, len+1 );
 		ctr->num_subkeys++;
@@ -282,6 +141,88 @@ int regval_ctr_numvals( REGVAL_CTR *ctr )
 	return ctr->num_values;
 }
 
+/***********************************************************************
+ allocate memory for and duplicate a REGISTRY_VALUE.
+ This is malloc'd memory so the caller should free it when done
+ **********************************************************************/
+
+REGISTRY_VALUE* dup_registry_value( REGISTRY_VALUE *val )
+{
+	REGISTRY_VALUE 	*copy = NULL;
+	BOOL		fail = True;
+	
+	if ( !val )
+		return NULL;
+	
+	if ( !(copy = malloc( sizeof(REGISTRY_VALUE) )) ) {
+		DEBUG(0,("dup_registry_value: malloc() failed!\n"));
+		return NULL;
+	}
+	
+	/* copy all the non-pointer initial data */
+	
+	memcpy( copy, val, sizeof(REGISTRY_VALUE) );
+	
+	switch ( val->type ) {
+		case REG_SZ:
+			if ( !(copy->data.string = strdup( val->data.string )) ) {
+				DEBUG(0,("dup_registry_value: strdup() failed for [%s]!\n",
+					val->data.string));
+				goto done;
+			}
+			break;
+			
+		case REG_DWORD:
+			/* nothing to be done; already copied by memcpy() */
+			break;
+			
+		case REG_BINARY:
+			if ( !(copy->data.string = memdup( val->data.binary, val->size )) ) {
+				DEBUG(0,("dup_registry_value: memdup() failed for [%d] bytes!\n",
+					val->size));
+				goto done;
+			}
+			break;
+	 } 
+	 
+	 fail = False;
+	 
+done:
+	if ( fail )
+		SAFE_FREE( copy );
+
+	return copy;	
+}
+
+/**********************************************************************
+ free the memory allocated to a REGISTRY_VALUE 
+ *********************************************************************/
+ 
+void free_registry_value( REGISTRY_VALUE *val )
+{
+	if ( !val )
+		return;
+		
+	switch ( val->type ) 
+	{
+		case REG_SZ:
+			SAFE_FREE( val->data.string );
+			break;
+		case REG_BINARY:
+			SAFE_FREE( val->data.binary );
+			break;
+	}
+	
+	SAFE_FREE( val );
+	
+	return;
+}
+
+/***********************************************************************
+ Retreive a pointer to a specific value.  Caller shoud dup the structure
+ since this memory may go away with a regval_ctr_destroy()
+ **********************************************************************/
+
 REGISTRY_VALUE* regval_ctr_specific_value( REGVAL_CTR *ctr, uint32 idx )
 {
 	if ( !(idx < ctr->num_values) )
@@ -354,3 +295,177 @@ void regval_ctr_destroy( REGVAL_CTR *ctr )
 	}
 }
 
+/***********************************************************************
+ Open the registry database and initialize the REGISTRY_HOOK cache
+ ***********************************************************************/
+ 
+BOOL init_registry( void )
+{
+	int i;
+	
+	if ( !init_registry_db() ) {
+		DEBUG(0,("init_registry: failed to initialize the registry tdb!\n"));
+		return False;
+	}
+		
+	/* build the cache tree of registry hooks */
+	
+	reghook_cache_init();
+	
+	for ( i=0; reg_hooks[i].keyname; i++ ) {
+		if ( !reghook_cache_add(&reg_hooks[i]) )
+			return False;
+	}
+
+	if ( DEBUGLEVEL >= 20 )
+		reghook_dump_cache(20);
+
+	return True;
+}
+
+
+
+
+/***********************************************************************
+ High level wrapper function for storing registry subkeys
+ ***********************************************************************/
+ 
+BOOL store_reg_keys( REGISTRY_KEY *key, REGSUBKEY_CTR *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;
+
+}
+
+/***********************************************************************
+ High level wrapper function for storing registry values
+ ***********************************************************************/
+ 
+BOOL store_reg_values( REGISTRY_KEY *key, REGVAL_CTR *val )
+{
+	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, REGSUBKEY_CTR *subkey_ctr )
+{
+	int result = -1;
+	
+	if ( key->hook && key->hook->ops && key->hook->ops->subkey_fn )
+		result = key->hook->ops->subkey_fn( key->name, subkey_ctr );
+
+	return result;
+}
+
+/***********************************************************************
+ 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 )
+{
+	char *s;
+	REGSUBKEY_CTR ctr;
+	
+	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, REGVAL_CTR *val )
+{
+	int result = -1;
+	
+	if ( key->hook && key->hook->ops && key->hook->ops->value_fn )
+		result = key->hook->ops->value_fn( key->name, val );
+
+	return result;
+}
+
+
+/***********************************************************************
+ retreive a specific subkey specified by index.  Caller is 
+ responsible for freeing memory
+ ***********************************************************************/
+
+BOOL fetch_reg_values_specific( REGISTRY_KEY *key, REGISTRY_VALUE **val, uint32 key_index )
+{
+	REGVAL_CTR 	ctr;
+	REGISTRY_VALUE	*v;
+	
+	ZERO_STRUCTP( &ctr );
+	
+	regval_ctr_init( &ctr );
+	
+	if ( fetch_reg_values( key, &ctr) == -1 )
+		return False;
+
+	if ( !(v = regval_ctr_specific_value( &ctr, key_index )) )
+		return False;
+
+	*val = dup_registry_value( v );
+
+	regval_ctr_destroy( &ctr ); 
+	
+	return True;
+}
+
+/***********************************************************************
+ 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;
+}
+
+
+