s3:registry: replace typedef "REGSUBKEY_CTR" by "struct regsubkey_ctr"

This paves the way for hiding the typedef and the implementation from the
surface.

Michael

21 files changed, 85 insertions, 85 deletions

diff --git a/source3/include/proto.h b/source3/include/proto.h
index 3fb57e44d4..8947e762e7 100644
--- a/source3/include/proto.h
+++ b/source3/include/proto.h
@@ -5053,11 +5053,11 @@ WERROR regdb_transaction_start(void);
 WERROR regdb_transaction_commit(void);
 WERROR regdb_transaction_cancel(void);
 int regdb_get_seqnum(void);
-bool regdb_store_keys(const char *key, REGSUBKEY_CTR *ctr);
-int regdb_fetch_keys(const char *key, REGSUBKEY_CTR *ctr);
+bool regdb_store_keys(const char *key, struct regsubkey_ctr *ctr);
+int regdb_fetch_keys(const char *key, struct regsubkey_ctr *ctr);
 int regdb_fetch_values( const char* key, REGVAL_CTR *values );
 bool regdb_store_values( const char *key, REGVAL_CTR *values );
-bool regdb_subkeys_need_update(REGSUBKEY_CTR *subkeys);
+bool regdb_subkeys_need_update(struct regsubkey_ctr *subkeys);
 bool regdb_values_need_update(REGVAL_CTR *values);
 
 /* The following definitions come from registry/reg_backend_hkpt_params.c  */
@@ -5093,9 +5093,9 @@ void reghook_dump_cache( int debuglevel );
 
 /* The following definitions come from registry/reg_dispatcher.c  */
 
-bool store_reg_keys( REGISTRY_KEY *key, REGSUBKEY_CTR *subkeys );
+bool store_reg_keys( REGISTRY_KEY *key, struct regsubkey_ctr *subkeys );
 bool store_reg_values( REGISTRY_KEY *key, REGVAL_CTR *val );
-int fetch_reg_keys( REGISTRY_KEY *key, REGSUBKEY_CTR *subkey_ctr );
+int fetch_reg_keys( REGISTRY_KEY *key, struct regsubkey_ctr *subkey_ctr );
 int fetch_reg_values( REGISTRY_KEY *key, REGVAL_CTR *val );
 bool regkey_access_check( REGISTRY_KEY *key, uint32 requested, uint32 *granted,
 			  const struct nt_user_token *token );
@@ -5103,7 +5103,7 @@ WERROR regkey_get_secdesc(TALLOC_CTX *mem_ctx, REGISTRY_KEY *key,
 			  struct security_descriptor **psecdesc);
 WERROR regkey_set_secdesc(REGISTRY_KEY *key,
 			  struct security_descriptor *psecdesc);
-bool reg_subkeys_need_update(REGISTRY_KEY *key, REGSUBKEY_CTR *subkeys);
+bool reg_subkeys_need_update(REGISTRY_KEY *key, struct regsubkey_ctr *subkeys);
 bool reg_values_need_update(REGISTRY_KEY *key, REGVAL_CTR *values);
 
 /* The following definitions come from registry/reg_eventlog.c  */
@@ -5129,11 +5129,11 @@ WERROR registry_init_smbconf(const char *keyname);
 
 /* The following definitions come from registry/reg_objects.c  */
 
-WERROR regsubkey_ctr_addkey( REGSUBKEY_CTR *ctr, const char *keyname );
-int regsubkey_ctr_delkey( REGSUBKEY_CTR *ctr, const char *keyname );
-bool regsubkey_ctr_key_exists( REGSUBKEY_CTR *ctr, const char *keyname );
-int regsubkey_ctr_numkeys( REGSUBKEY_CTR *ctr );
-char* regsubkey_ctr_specific_key( REGSUBKEY_CTR *ctr, uint32 key_index );
+WERROR regsubkey_ctr_addkey( struct regsubkey_ctr *ctr, const char *keyname );
+int regsubkey_ctr_delkey( struct regsubkey_ctr *ctr, const char *keyname );
+bool regsubkey_ctr_key_exists( struct regsubkey_ctr *ctr, const char *keyname );
+int regsubkey_ctr_numkeys( struct regsubkey_ctr *ctr );
+char* regsubkey_ctr_specific_key( struct regsubkey_ctr *ctr, uint32 key_index );
 int regval_ctr_numvals( REGVAL_CTR *ctr );
 REGISTRY_VALUE* dup_registry_value( REGISTRY_VALUE *val );
 void free_registry_value( REGISTRY_VALUE *val );
diff --git a/source3/include/reg_objects.h b/source3/include/reg_objects.h
index d9159dd464..6081eb482c 100644
--- a/source3/include/reg_objects.h
+++ b/source3/include/reg_objects.h
@@ -66,11 +66,11 @@ typedef struct {
 
 /* container for registry subkey names */
 
-typedef struct {
+struct regsubkey_ctr {
 	uint32          num_subkeys;
 	char            **subkeys;
 	int seqnum;
-} REGSUBKEY_CTR;
+};
 
 /*
  *
@@ -132,9 +132,9 @@ typedef struct {
  
 typedef struct {
 	/* functions for enumerating subkeys and values */	
-	int 	(*fetch_subkeys)( const char *key, REGSUBKEY_CTR *subkeys);
+	int 	(*fetch_subkeys)( const char *key, struct regsubkey_ctr *subkeys);
 	int 	(*fetch_values) ( const char *key, REGVAL_CTR *val );
-	bool 	(*store_subkeys)( const char *key, REGSUBKEY_CTR *subkeys );
+	bool 	(*store_subkeys)( const char *key, struct regsubkey_ctr *subkeys );
 	bool 	(*store_values)( const char *key, REGVAL_CTR *val );
 	bool	(*reg_access_check)( const char *keyname, uint32 requested,
 				     uint32 *granted,
@@ -143,7 +143,7 @@ typedef struct {
 			      struct security_descriptor **psecdesc);
 	WERROR (*set_secdesc)(const char *key,
 			      struct security_descriptor *sec_desc);
-	bool	(*subkeys_need_update)(REGSUBKEY_CTR *subkeys);
+	bool	(*subkeys_need_update)(struct regsubkey_ctr *subkeys);
 	bool	(*values_need_update)(REGVAL_CTR *values);
 } REGISTRY_OPS;
 
@@ -164,7 +164,7 @@ typedef struct _RegistryKey {
 
 struct registry_key {
 	REGISTRY_KEY *key;
-	REGSUBKEY_CTR *subkeys;
+	struct regsubkey_ctr *subkeys;
 	REGVAL_CTR *values;
 	struct nt_user_token *token;
 };
diff --git a/source3/include/regfio.h b/source3/include/regfio.h
index 63516a358d..0e957d51e5 100644
--- a/source3/include/regfio.h
+++ b/source3/include/regfio.h
@@ -214,7 +214,7 @@ int           regfio_close( REGF_FILE *r );
 REGF_NK_REC*  regfio_rootkey( REGF_FILE *file );
 REGF_NK_REC*  regfio_fetch_subkey( REGF_FILE *file, REGF_NK_REC *nk );
 REGF_NK_REC*  regfio_write_key ( REGF_FILE *file, const char *name,
-                                 REGVAL_CTR *values, REGSUBKEY_CTR *subkeys,
+                                 REGVAL_CTR *values, struct regsubkey_ctr *subkeys,
                                  SEC_DESC *sec_desc, REGF_NK_REC *parent );
 
 
diff --git a/source3/registry/reg_api.c b/source3/registry/reg_api.c
index 4dde493a49..35d8e306e0 100644
--- a/source3/registry/reg_api.c
+++ b/source3/registry/reg_api.c
@@ -100,7 +100,7 @@ static WERROR fill_subkey_cache(struct registry_key *key)
 		}
 	}
 
-	if (!(key->subkeys = TALLOC_ZERO_P(key, REGSUBKEY_CTR))) {
+	if (!(key->subkeys = TALLOC_ZERO_P(key, struct regsubkey_ctr))) {
 		return WERR_NOMEM;
 	}
 
@@ -127,7 +127,7 @@ static WERROR regkey_open_onelevel(TALLOC_CTX *mem_ctx,
 	WERROR     	result = WERR_OK;
 	struct registry_key *regkey;
 	REGISTRY_KEY *key;
-	REGSUBKEY_CTR	*subkeys = NULL;
+	struct regsubkey_ctr	*subkeys = NULL;
 
 	DEBUG(7,("regkey_open_onelevel: name = [%s]\n", name));
 
@@ -193,7 +193,7 @@ static WERROR regkey_open_onelevel(TALLOC_CTX *mem_ctx,
 	/* check if the path really exists; failed is indicated by -1 */
 	/* if the subkey count failed, bail out */
 
-	if ( !(subkeys = TALLOC_ZERO_P( key, REGSUBKEY_CTR )) ) {
+	if ( !(subkeys = TALLOC_ZERO_P( key, struct regsubkey_ctr )) ) {
 		result = WERR_NOMEM;
 		goto done;
 	}
@@ -726,7 +726,7 @@ static WERROR reg_load_tree(REGF_FILE *regfile, const char *topkeypath,
 	REGF_NK_REC *subkey;
 	REGISTRY_KEY registry_key;
 	REGVAL_CTR *values;
-	REGSUBKEY_CTR *subkeys;
+	struct regsubkey_ctr *subkeys;
 	int i;
 	char *path = NULL;
 	WERROR result = WERR_OK;
@@ -748,7 +748,7 @@ static WERROR reg_load_tree(REGF_FILE *regfile, const char *topkeypath,
 
 	/* now start parsing the values and subkeys */
 
-	subkeys = TALLOC_ZERO_P(regfile->mem_ctx, REGSUBKEY_CTR);
+	subkeys = TALLOC_ZERO_P(regfile->mem_ctx, struct regsubkey_ctr);
 	if (subkeys == NULL) {
 		return WERR_NOMEM;
 	}
@@ -767,7 +767,7 @@ static WERROR reg_load_tree(REGF_FILE *regfile, const char *topkeypath,
 				    (key->values[i].data_size & ~VK_DATA_IN_OFFSET));
 	}
 
-	/* copy subkeys into the REGSUBKEY_CTR */
+	/* copy subkeys into the struct regsubkey_ctr */
 
 	key->subkey_index = 0;
 	while ((subkey = regfio_fetch_subkey( regfile, key ))) {
@@ -861,7 +861,7 @@ static WERROR reg_write_tree(REGF_FILE *regfile, const char *keypath,
 {
 	REGF_NK_REC *key;
 	REGVAL_CTR *values;
-	REGSUBKEY_CTR *subkeys;
+	struct regsubkey_ctr *subkeys;
 	int i, num_subkeys;
 	char *key_tmp = NULL;
 	char *keyname, *parentpath;
@@ -909,7 +909,7 @@ static WERROR reg_write_tree(REGF_FILE *regfile, const char *keypath,
 
 	/* lookup the values and subkeys */
 
-	subkeys = TALLOC_ZERO_P(regfile->mem_ctx, REGSUBKEY_CTR);
+	subkeys = TALLOC_ZERO_P(regfile->mem_ctx, struct regsubkey_ctr);
 	if (subkeys == NULL) {
 		return WERR_NOMEM;
 	}
diff --git a/source3/registry/reg_backend_current_version.c b/source3/registry/reg_backend_current_version.c
index 04cc0ebfa7..f76840ee22 100644
--- a/source3/registry/reg_backend_current_version.c
+++ b/source3/registry/reg_backend_current_version.c
@@ -70,7 +70,7 @@ static int current_version_fetch_values(const char *key, REGVAL_CTR *values)
 }
 
 static int current_version_fetch_subkeys(const char *key,
-					 REGSUBKEY_CTR *subkey_ctr)
+					 struct regsubkey_ctr *subkey_ctr)
 {
 	return regdb_ops.fetch_subkeys(key, subkey_ctr);
 }
diff --git a/source3/registry/reg_backend_db.c b/source3/registry/reg_backend_db.c
index 02787738fc..5722240f24 100644
--- a/source3/registry/reg_backend_db.c
+++ b/source3/registry/reg_backend_db.c
@@ -103,7 +103,7 @@ static WERROR init_registry_key_internal(const char *add_path)
 	char *remaining = NULL;
 	char *keyname;
 	char *subkeyname;
-	REGSUBKEY_CTR *subkeys;
+	struct regsubkey_ctr *subkeys;
 	const char *p, *p2;
 
 	DEBUG(6, ("init_registry_key: Adding [%s]\n", add_path));
@@ -167,7 +167,7 @@ static WERROR init_registry_key_internal(const char *add_path)
 		 * since we are about to update the record.
 		 * We just want any subkeys already present */
 
-		if (!(subkeys = TALLOC_ZERO_P(frame, REGSUBKEY_CTR))) {
+		if (!(subkeys = TALLOC_ZERO_P(frame, struct regsubkey_ctr))) {
 			DEBUG(0,("talloc() failure!\n"));
 			werr = WERR_NOMEM;
 			goto fail;
@@ -516,7 +516,7 @@ int regdb_get_seqnum(void)
  fstrings
  ***********************************************************************/
 
-static bool regdb_store_keys_internal(const char *key, REGSUBKEY_CTR *ctr)
+static bool regdb_store_keys_internal(const char *key, struct regsubkey_ctr *ctr)
 {
 	TDB_DATA dbuf;
 	uint8 *buffer = NULL;
@@ -617,11 +617,11 @@ done:
  do not currently exist
  ***********************************************************************/
 
-bool regdb_store_keys(const char *key, REGSUBKEY_CTR *ctr)
+bool regdb_store_keys(const char *key, struct regsubkey_ctr *ctr)
 {
 	int num_subkeys, i;
 	char *path = NULL;
-	REGSUBKEY_CTR *subkeys = NULL, *old_subkeys = NULL;
+	struct regsubkey_ctr *subkeys = NULL, *old_subkeys = NULL;
 	char *oldkeyname = NULL;
 	TALLOC_CTX *ctx = talloc_stackframe();
 	NTSTATUS status;
@@ -635,7 +635,7 @@ bool regdb_store_keys(const char *key, REGSUBKEY_CTR *ctr)
 	 * changed
 	 */
 
-	if (!(old_subkeys = TALLOC_ZERO_P(ctx, REGSUBKEY_CTR))) {
+	if (!(old_subkeys = TALLOC_ZERO_P(ctx, struct regsubkey_ctr))) {
 		DEBUG(0,("regdb_store_keys: talloc() failure!\n"));
 		return false;
 	}
@@ -672,7 +672,7 @@ bool regdb_store_keys(const char *key, REGSUBKEY_CTR *ctr)
 	 * Re-fetch the old keys inside the transaction
 	 */
 
-	if (!(old_subkeys = TALLOC_ZERO_P(ctx, REGSUBKEY_CTR))) {
+	if (!(old_subkeys = TALLOC_ZERO_P(ctx, struct regsubkey_ctr))) {
 		DEBUG(0,("regdb_store_keys: talloc() failure!\n"));
 		goto cancel;
 	}
@@ -792,7 +792,7 @@ bool regdb_store_keys(const char *key, REGSUBKEY_CTR *ctr)
 	num_subkeys = regsubkey_ctr_numkeys(ctr);
 
 	if (num_subkeys == 0) {
-		if (!(subkeys = TALLOC_ZERO_P(ctx, REGSUBKEY_CTR)) ) {
+		if (!(subkeys = TALLOC_ZERO_P(ctx, struct regsubkey_ctr)) ) {
 			DEBUG(0,("regdb_store_keys: talloc() failure!\n"));
 			goto cancel;
 		}
@@ -813,7 +813,7 @@ bool regdb_store_keys(const char *key, REGSUBKEY_CTR *ctr)
 		if (!path) {
 			goto cancel;
 		}
-		if (!(subkeys = TALLOC_ZERO_P(ctx, REGSUBKEY_CTR)) ) {
+		if (!(subkeys = TALLOC_ZERO_P(ctx, struct regsubkey_ctr)) ) {
 			DEBUG(0,("regdb_store_keys: talloc() failure!\n"));
 			goto cancel;
 		}
@@ -930,7 +930,7 @@ static int cmp_keynames(const void *p1, const void *p2)
 static bool create_sorted_subkeys(const char *key, const char *sorted_keyname)
 {
 	char **sorted_subkeys;
-	REGSUBKEY_CTR *ctr;
+	struct regsubkey_ctr *ctr;
 	bool result = false;
 	NTSTATUS status;
 	char *buf;
@@ -944,7 +944,7 @@ static bool create_sorted_subkeys(const char *key, const char *sorted_keyname)
 		return false;
 	}
 
-	ctr = talloc(talloc_tos(), REGSUBKEY_CTR);
+	ctr = talloc(talloc_tos(), struct regsubkey_ctr);
 	if (ctr == NULL) {
 		goto fail;
 	}
@@ -1164,7 +1164,7 @@ done:
  released by the caller.
  ***********************************************************************/
 
-int regdb_fetch_keys(const char *key, REGSUBKEY_CTR *ctr)
+int regdb_fetch_keys(const char *key, struct regsubkey_ctr *ctr)
 {
 	WERROR werr;
 	uint32 num_items;
@@ -1484,7 +1484,7 @@ static WERROR regdb_set_secdesc(const char *key,
 	return err;
 }
 
-bool regdb_subkeys_need_update(REGSUBKEY_CTR *subkeys)
+bool regdb_subkeys_need_update(struct regsubkey_ctr *subkeys)
 {
 	return (regdb_get_seqnum() != subkeys->seqnum);
 }
diff --git a/source3/registry/reg_backend_hkpt_params.c b/source3/registry/reg_backend_hkpt_params.c
index 2ed5e78e1c..c67f7b3ea4 100644
--- a/source3/registry/reg_backend_hkpt_params.c
+++ b/source3/registry/reg_backend_hkpt_params.c
@@ -59,7 +59,7 @@ static int hkpt_params_fetch_values(const char *key, REGVAL_CTR *regvals)
 }
 
 static int hkpt_params_fetch_subkeys(const char *key,
-					 REGSUBKEY_CTR *subkey_ctr)
+					 struct regsubkey_ctr *subkey_ctr)
 {
 	return regdb_ops.fetch_subkeys(key, subkey_ctr);
 }
diff --git a/source3/registry/reg_backend_netlogon_params.c b/source3/registry/reg_backend_netlogon_params.c
index 71f88144c8..17abf038a6 100644
--- a/source3/registry/reg_backend_netlogon_params.c
+++ b/source3/registry/reg_backend_netlogon_params.c
@@ -46,7 +46,7 @@ static int netlogon_params_fetch_values(const char *key, REGVAL_CTR *regvals)
 }
 
 static int netlogon_params_fetch_subkeys(const char *key,
-					 REGSUBKEY_CTR *subkey_ctr)
+					 struct regsubkey_ctr *subkey_ctr)
 {
 	return regdb_ops.fetch_subkeys(key, subkey_ctr);
 }
diff --git a/source3/registry/reg_backend_perflib.c b/source3/registry/reg_backend_perflib.c
index 999bca2682..e23c87efe8 100644
--- a/source3/registry/reg_backend_perflib.c
+++ b/source3/registry/reg_backend_perflib.c
@@ -95,7 +95,7 @@ static int perflib_fetch_values(const char *key, REGVAL_CTR *regvals)
 }
 
 static int perflib_fetch_subkeys(const char *key,
-					 REGSUBKEY_CTR *subkey_ctr)
+				 struct regsubkey_ctr *subkey_ctr)
 {
 	return regdb_ops.fetch_subkeys(key, subkey_ctr);
 }
diff --git a/source3/registry/reg_backend_printing.c b/source3/registry/reg_backend_printing.c
index 5c1e6eb543..192bc78e09 100644
--- a/source3/registry/reg_backend_printing.c
+++ b/source3/registry/reg_backend_printing.c
@@ -42,8 +42,8 @@ struct reg_dyn_tree {
 	const char *path;
 
 	/* callbscks for fetch/store operations */
-	int ( *fetch_subkeys) ( const char *path, REGSUBKEY_CTR *subkeys );
-	bool (*store_subkeys) ( const char *path, REGSUBKEY_CTR *subkeys );
+	int ( *fetch_subkeys) ( const char *path, struct regsubkey_ctr *subkeys );
+	bool (*store_subkeys) ( const char *path, struct regsubkey_ctr *subkeys );
 	int  (*fetch_values)  ( const char *path, REGVAL_CTR *values );
 	bool (*store_values)  ( const char *path, REGVAL_CTR *values );
 };
@@ -77,7 +77,7 @@ static const char *dos_basename(const char *path)
  *********************************************************************
  *********************************************************************/
 
-static int key_forms_fetch_keys(const char *key, REGSUBKEY_CTR *subkeys)
+static int key_forms_fetch_keys(const char *key, struct regsubkey_ctr *subkeys)
 {
 	char *p = reg_remaining_path(talloc_tos(), key + strlen(KEY_FORMS));
 
@@ -196,7 +196,7 @@ static char *strip_printers_prefix(const char *key)
 /*********************************************************************
  *********************************************************************/
 
-static int key_printers_fetch_keys( const char *key, REGSUBKEY_CTR *subkeys )
+static int key_printers_fetch_keys( const char *key, struct regsubkey_ctr *subkeys )
 {
 	int n_services = lp_numservices();
 	int snum;
@@ -275,7 +275,7 @@ done:
  keyname is the sharename and not the printer name.
  *********************************************************************/
 
-static bool add_printers_by_registry( REGSUBKEY_CTR *subkeys )
+static bool add_printers_by_registry( struct regsubkey_ctr *subkeys )
 {
 	int i, num_keys, snum;
 	char *printername;
@@ -310,7 +310,7 @@ static bool add_printers_by_registry( REGSUBKEY_CTR *subkeys )
 /**********************************************************************
  *********************************************************************/
 
-static bool key_printers_store_keys( const char *key, REGSUBKEY_CTR *subkeys )
+static bool key_printers_store_keys( const char *key, struct regsubkey_ctr *subkeys )
 {
 	char *printers_key;
 	char *printername, *printerdatakey;
@@ -738,7 +738,7 @@ static bool key_printers_store_values( const char *key, REGVAL_CTR *values )
  *********************************************************************
  *********************************************************************/
 
-static int key_driver_fetch_keys( const char *key, REGSUBKEY_CTR *subkeys )
+static int key_driver_fetch_keys( const char *key, struct regsubkey_ctr *subkeys )
 {
 	const char *environments[] = {
 		"Windows 4.0",
@@ -1085,7 +1085,7 @@ static int key_driver_fetch_values( const char *key, REGVAL_CTR *values )
  *********************************************************************
  *********************************************************************/
 
-static int key_print_fetch_keys( const char *key, REGSUBKEY_CTR *subkeys )
+static int key_print_fetch_keys( const char *key, struct regsubkey_ctr *subkeys )
 {
 	int key_len = strlen(key);
 
@@ -1192,7 +1192,7 @@ static int match_registry_path(const char *key)
 /***********************************************************************
  **********************************************************************/
 
-static int regprint_fetch_reg_keys( const char *key, REGSUBKEY_CTR *subkeys )
+static int regprint_fetch_reg_keys( const char *key, struct regsubkey_ctr *subkeys )
 {
 	int i = match_registry_path( key );
 
@@ -1208,7 +1208,7 @@ static int regprint_fetch_reg_keys( const char *key, REGSUBKEY_CTR *subkeys )
 /**********************************************************************
  *********************************************************************/
 
-static bool regprint_store_reg_keys( const char *key, REGSUBKEY_CTR *subkeys )
+static bool regprint_store_reg_keys( const char *key, struct regsubkey_ctr *subkeys )
 {
 	int i = match_registry_path( key );
 
diff --git a/source3/registry/reg_backend_prod_options.c b/source3/registry/reg_backend_prod_options.c
index 7ac5c5b4b9..3e9d32cd97 100644
--- a/source3/registry/reg_backend_prod_options.c
+++ b/source3/registry/reg_backend_prod_options.c
@@ -59,7 +59,7 @@ static int prod_options_fetch_values(const char *key, REGVAL_CTR *regvals)
 }
 
 static int prod_options_fetch_subkeys(const char *key,
-				      REGSUBKEY_CTR *subkey_ctr)
+				      struct regsubkey_ctr *subkey_ctr)
 {
 	return regdb_ops.fetch_subkeys(key, subkey_ctr);
 }
diff --git a/source3/registry/reg_backend_shares.c b/source3/registry/reg_backend_shares.c
index ee9e5dc5a1..a30ae34b4e 100644
--- a/source3/registry/reg_backend_shares.c
+++ b/source3/registry/reg_backend_shares.c
@@ -66,7 +66,7 @@ static char* trim_reg_path( const char *path )
  Caller is responsible for freeing memory to **subkeys
  *********************************************************************/
  
-static int shares_subkey_info( const char *key, REGSUBKEY_CTR *subkey_ctr )
+static int shares_subkey_info( const char *key, struct regsubkey_ctr *subkey_ctr )
 {
 	char 		*path;
 	bool		top_level = False;
@@ -134,7 +134,7 @@ static int shares_value_info( const char *key, REGVAL_CTR *val )
  (for now at least)
  *********************************************************************/
 
-static bool shares_store_subkey( const char *key, REGSUBKEY_CTR *subkeys )
+static bool shares_store_subkey( const char *key, struct regsubkey_ctr *subkeys )
 {
 	return False;
 }
diff --git a/source3/registry/reg_backend_smbconf.c b/source3/registry/reg_backend_smbconf.c
index 2e4a5f1c1d..10ee138e0e 100644
--- a/source3/registry/reg_backend_smbconf.c
+++ b/source3/registry/reg_backend_smbconf.c
@@ -25,12 +25,12 @@
 
 extern REGISTRY_OPS regdb_ops;		/* these are the default */
 
-static int smbconf_fetch_keys( const char *key, REGSUBKEY_CTR *subkey_ctr )
+static int smbconf_fetch_keys( const char *key, struct regsubkey_ctr *subkey_ctr )
 {
 	return regdb_ops.fetch_subkeys(key, subkey_ctr);
 }
 
-static bool smbconf_store_keys( const char *key, REGSUBKEY_CTR *subkeys )
+static bool smbconf_store_keys( const char *key, struct regsubkey_ctr *subkeys )
 {
 	return regdb_ops.store_subkeys(key, subkeys);
 }
diff --git a/source3/registry/reg_backend_tcpip_params.c b/source3/registry/reg_backend_tcpip_params.c
index db7df5dd8f..a6aa2fc2ea 100644
--- a/source3/registry/reg_backend_tcpip_params.c
+++ b/source3/registry/reg_backend_tcpip_params.c
@@ -56,7 +56,7 @@ static int tcpip_params_fetch_values(const char *key, REGVAL_CTR *regvals)
 }
 
 static int tcpip_params_fetch_subkeys(const char *key,
-					 REGSUBKEY_CTR *subkey_ctr)
+				      struct regsubkey_ctr *subkey_ctr)
 {
 	return regdb_ops.fetch_subkeys(key, subkey_ctr);
 }
diff --git a/source3/registry/reg_dispatcher.c b/source3/registry/reg_dispatcher.c
index c160622054..0db9e1b146 100644
--- a/source3/registry/reg_dispatcher.c
+++ b/source3/registry/reg_dispatcher.c
@@ -80,7 +80,7 @@ static WERROR construct_registry_sd(TALLOC_CTX *ctx, SEC_DESC **psd)
  High level wrapper function for storing registry subkeys
  ***********************************************************************/
 
-bool store_reg_keys( REGISTRY_KEY *key, REGSUBKEY_CTR *subkeys )
+bool store_reg_keys( REGISTRY_KEY *key, struct regsubkey_ctr *subkeys )
 {
 	if (key->ops && key->ops->store_subkeys)
 		return key->ops->store_subkeys(key->name, subkeys);
@@ -105,7 +105,7 @@ bool store_reg_values( REGISTRY_KEY *key, REGVAL_CTR *val )
  Initialize the TALLOC_CTX if necessary
  ***********************************************************************/
 
-int fetch_reg_keys( REGISTRY_KEY *key, REGSUBKEY_CTR *subkey_ctr )
+int fetch_reg_keys( REGISTRY_KEY *key, struct regsubkey_ctr *subkey_ctr )
 {
 	int result = -1;
 
@@ -216,7 +216,7 @@ WERROR regkey_set_secdesc(REGISTRY_KEY *key,
  * Check whether the in-memory version of the subkyes of a
  * registry key needs update from disk.
  */
-bool reg_subkeys_need_update(REGISTRY_KEY *key, REGSUBKEY_CTR *subkeys)
+bool reg_subkeys_need_update(REGISTRY_KEY *key, struct regsubkey_ctr *subkeys)
 {
 	if (key->ops && key->ops->subkeys_need_update)
 	{
diff --git a/source3/registry/reg_eventlog.c b/source3/registry/reg_eventlog.c
index 8994acf107..5617f212eb 100644
--- a/source3/registry/reg_eventlog.c
+++ b/source3/registry/reg_eventlog.c
@@ -35,7 +35,7 @@ bool eventlog_init_keys(void)
 	const char **elogs = lp_eventlog_list();
 	char *evtlogpath = NULL;
 	char *evtfilepath = NULL;
-	REGSUBKEY_CTR *subkeys;
+	struct regsubkey_ctr *subkeys;
 	REGVAL_CTR *values;
 	uint32 uiMaxSize;
 	uint32 uiRetention;
@@ -44,7 +44,7 @@ bool eventlog_init_keys(void)
 	TALLOC_CTX *ctx = talloc_tos();
 
 	while (elogs && *elogs) {
-		if (!(subkeys = TALLOC_ZERO_P(ctx, REGSUBKEY_CTR ) ) ) {
+		if (!(subkeys = TALLOC_ZERO_P(ctx, struct regsubkey_ctr ) ) ) {
 			DEBUG( 0, ( "talloc() failure!\n" ) );
 			return False;
 		}
@@ -70,7 +70,7 @@ bool eventlog_init_keys(void)
 		DEBUG( 5,
 		       ( "Adding key of [%s] to path of [%s]\n", *elogs,
 			 evtlogpath ) );
-		if (!(subkeys = TALLOC_ZERO_P(ctx, REGSUBKEY_CTR))) {
+		if (!(subkeys = TALLOC_ZERO_P(ctx, struct regsubkey_ctr))) {
 			DEBUG( 0, ( "talloc() failure!\n" ) );
 			return False;
 		}
@@ -197,7 +197,7 @@ bool eventlog_add_source( const char *eventlog, const char *sourcename,
 	const char **elogs = lp_eventlog_list(  );
 	char **wrklist, **wp;
 	char *evtlogpath = NULL;
-	REGSUBKEY_CTR *subkeys;
+	struct regsubkey_ctr *subkeys;
 	REGVAL_CTR *values;
 	REGISTRY_VALUE *rval;
 	UNISTR2 data;
@@ -315,7 +315,7 @@ bool eventlog_add_source( const char *eventlog, const char *sourcename,
 	TALLOC_FREE(values);
 	TALLOC_FREE(wrklist);	/*  */
 
-	if ( !( subkeys = TALLOC_ZERO_P(ctx, REGSUBKEY_CTR ) ) ) {
+	if ( !( subkeys = TALLOC_ZERO_P(ctx, struct regsubkey_ctr ) ) ) {
 		DEBUG( 0, ( "talloc() failure!\n" ) );
 		return False;
 	}
@@ -342,7 +342,7 @@ bool eventlog_add_source( const char *eventlog, const char *sourcename,
 
 	/* now allocate room for the source's subkeys */
 
-	if ( !( subkeys = TALLOC_ZERO_P(ctx, REGSUBKEY_CTR ) ) ) {
+	if ( !( subkeys = TALLOC_ZERO_P(ctx, struct regsubkey_ctr ) ) ) {
 		DEBUG( 0, ( "talloc() failure!\n" ) );
 		return False;
 	}
diff --git a/source3/registry/reg_objects.c b/source3/registry/reg_objects.c
index 47122ccad2..a9a4939034 100644
--- a/source3/registry/reg_objects.c
+++ b/source3/registry/reg_objects.c
@@ -40,7 +40,7 @@
  Add a new key to the array
  **********************************************************************/
 
-WERROR regsubkey_ctr_addkey( REGSUBKEY_CTR *ctr, const char *keyname )
+WERROR regsubkey_ctr_addkey( struct regsubkey_ctr *ctr, const char *keyname )
 {
 	char **newkeys;
 
@@ -77,7 +77,7 @@ WERROR regsubkey_ctr_addkey( REGSUBKEY_CTR *ctr, const char *keyname )
  Delete a key from the array
  **********************************************************************/
 
-int regsubkey_ctr_delkey( REGSUBKEY_CTR *ctr, const char *keyname )
+int regsubkey_ctr_delkey( struct regsubkey_ctr *ctr, const char *keyname )
 {
 	int i;
 
@@ -107,7 +107,7 @@ int regsubkey_ctr_delkey( REGSUBKEY_CTR *ctr, const char *keyname )
  Check for the existance of a key
  **********************************************************************/
 
-bool regsubkey_ctr_key_exists( REGSUBKEY_CTR *ctr, const char *keyname )
+bool regsubkey_ctr_key_exists( struct regsubkey_ctr *ctr, const char *keyname )
 {
 	int 	i;
 
@@ -127,7 +127,7 @@ bool regsubkey_ctr_key_exists( REGSUBKEY_CTR *ctr, const char *keyname )
  How many keys does the container hold ?
  **********************************************************************/
 
-int regsubkey_ctr_numkeys( REGSUBKEY_CTR *ctr )
+int regsubkey_ctr_numkeys( struct regsubkey_ctr *ctr )
 {
 	return ctr->num_subkeys;
 }
@@ -136,7 +136,7 @@ int regsubkey_ctr_numkeys( REGSUBKEY_CTR *ctr )
  Retreive a specific key string
  **********************************************************************/
 
-char* regsubkey_ctr_specific_key( REGSUBKEY_CTR *ctr, uint32 key_index )
+char* regsubkey_ctr_specific_key( struct regsubkey_ctr *ctr, uint32 key_index )
 {
 	if ( ! (key_index < ctr->num_subkeys) )
 		return NULL;
diff --git a/source3/registry/regfio.c b/source3/registry/regfio.c
index 5395f225f1..d002bd72e7 100644
--- a/source3/registry/regfio.c
+++ b/source3/registry/regfio.c
@@ -1693,7 +1693,7 @@ static int hashrec_cmp( REGF_HASH_REC *h1, REGF_HASH_REC *h2 )
 *******************************************************************/
 
  REGF_NK_REC* regfio_write_key( REGF_FILE *file, const char *name, 
-                               REGVAL_CTR *values, REGSUBKEY_CTR *subkeys, 
+                               REGVAL_CTR *values, struct regsubkey_ctr *subkeys,
                                SEC_DESC *sec_desc, REGF_NK_REC *parent )
 {
 	REGF_NK_REC *nk;
diff --git a/source3/services/services_db.c b/source3/services/services_db.c
index ef975cfbc4..2000ca9272 100644
--- a/source3/services/services_db.c
+++ b/source3/services/services_db.c
@@ -332,14 +332,14 @@ static void fill_service_values( const char *name, REGVAL_CTR *values )
 /********************************************************************
 ********************************************************************/
 
-static void add_new_svc_name( REGISTRY_KEY *key_parent, REGSUBKEY_CTR *subkeys,
+static void add_new_svc_name( REGISTRY_KEY *key_parent, struct regsubkey_ctr *subkeys,
                               const char *name )
 {
 	REGISTRY_KEY *key_service = NULL, *key_secdesc = NULL;
 	WERROR wresult;
 	char *path = NULL;
 	REGVAL_CTR *values = NULL;
-	REGSUBKEY_CTR *svc_subkeys = NULL;
+	struct regsubkey_ctr *svc_subkeys = NULL;
 	SEC_DESC *sd = NULL;
 	DATA_BLOB sd_blob;
 	NTSTATUS status;
@@ -366,7 +366,7 @@ static void add_new_svc_name( REGISTRY_KEY *key_parent, REGSUBKEY_CTR *subkeys,
 
 	/* add the 'Security' key */
 
-	if ( !(svc_subkeys = TALLOC_ZERO_P( key_service, REGSUBKEY_CTR )) ) {
+	if ( !(svc_subkeys = TALLOC_ZERO_P( key_service, struct regsubkey_ctr )) ) {
 		DEBUG(0,("add_new_svc_name: talloc() failed!\n"));
 		TALLOC_FREE( key_service );
 		return;
@@ -444,7 +444,7 @@ void svcctl_init_keys( void )
 {
 	const char **service_list = lp_svcctl_list();
 	int i;
-	REGSUBKEY_CTR *subkeys = NULL;
+	struct regsubkey_ctr *subkeys = NULL;
 	REGISTRY_KEY *key = NULL;
 	WERROR wresult;
 
@@ -461,7 +461,7 @@ void svcctl_init_keys( void )
 
 	/* lookup the available subkeys */
 
-	if ( !(subkeys = TALLOC_ZERO_P( key, REGSUBKEY_CTR )) ) {
+	if ( !(subkeys = TALLOC_ZERO_P( key, struct regsubkey_ctr )) ) {
 		DEBUG(0,("svcctl_init_keys: talloc() failed!\n"));
 		TALLOC_FREE( key );
 		return;
diff --git a/source3/utils/net_rpc_registry.c b/source3/utils/net_rpc_registry.c
index 005e3ca556..4fa5a2fa0a 100644
--- a/source3/utils/net_rpc_registry.c
+++ b/source3/utils/net_rpc_registry.c
@@ -971,11 +971,11 @@ static bool write_registry_tree( REGF_FILE *infile, REGF_NK_REC *nk,
 {
 	REGF_NK_REC *key, *subkey;
 	REGVAL_CTR *values = NULL;
-	REGSUBKEY_CTR *subkeys = NULL;
+	struct regsubkey_ctr *subkeys = NULL;
 	int i;
 	char *path = NULL;
 
-	if ( !( subkeys = TALLOC_ZERO_P( infile->mem_ctx, REGSUBKEY_CTR )) ) {
+	if ( !( subkeys = TALLOC_ZERO_P( infile->mem_ctx, struct regsubkey_ctr )) ) {
 		DEBUG(0,("write_registry_tree: talloc() failed!\n"));
 		return false;
 	}
@@ -993,7 +993,7 @@ static bool write_registry_tree( REGF_FILE *infile, REGF_NK_REC *nk,
 			(const char *)nk->values[i].data, (nk->values[i].data_size & ~VK_DATA_IN_OFFSET) );
 	}
 
-	/* copy subkeys into the REGSUBKEY_CTR */
+	/* copy subkeys into the struct regsubkey_ctr */
 
 	while ( (subkey = regfio_fetch_subkey( infile, nk )) ) {
 		regsubkey_ctr_addkey( subkeys, subkey->keyname );
diff --git a/source3/utils/profiles.c b/source3/utils/profiles.c
index bbbaaf089f..2c9bc36faf 100644
--- a/source3/utils/profiles.c
+++ b/source3/utils/profiles.c
@@ -118,7 +118,7 @@ static bool copy_registry_tree( REGF_FILE *infile, REGF_NK_REC *nk,
 	REGF_NK_REC *key, *subkey;
 	SEC_DESC *new_sd;
 	REGVAL_CTR *values;
-	REGSUBKEY_CTR *subkeys;
+	struct regsubkey_ctr *subkeys;
 	int i;
 	char *path;
 
@@ -132,7 +132,7 @@ static bool copy_registry_tree( REGF_FILE *infile, REGF_NK_REC *nk,
 	verbose_output("ACL for %s%s%s\n", parentpath, parent ? "\\" : "", nk->keyname);
 	swap_sid_in_acl( new_sd, &old_sid, &new_sid );
 
-	if ( !(subkeys = TALLOC_ZERO_P( NULL, REGSUBKEY_CTR )) ) {
+	if ( !(subkeys = TALLOC_ZERO_P( NULL, struct regsubkey_ctr )) ) {
 		DEBUG(0,("copy_registry_tree: talloc() failure!\n"));
 		return False;
 	}
@@ -150,7 +150,7 @@ static bool copy_registry_tree( REGF_FILE *infile, REGF_NK_REC *nk,
 			(const char *)nk->values[i].data, (nk->values[i].data_size & ~VK_DATA_IN_OFFSET) );
 	}
 
-	/* copy subkeys into the REGSUBKEY_CTR */
+	/* copy subkeys into the struct regsubkey_ctr */
 
 	while ( (subkey = regfio_fetch_subkey( infile, nk )) ) {
 		regsubkey_ctr_addkey( subkeys, subkey->keyname );