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

Signed-off-by: Michael Adam <obnox@samba.org>

diff --git a/source/include/proto.h b/source/include/proto.h
index 0467588c20a3403a87e74554dd107adf3a4948ce..9d932a2dee0d817ad1ae5bc9d5b6d276bb09bcde 100644 (file)
--- a/source/include/proto.h
+++ b/source/include/proto.h
@@ -6725,11 +6725,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  */
@@ -6765,9 +6765,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 );
@@ -6775,7 +6775,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  */
@@ -6801,11 +6801,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/source/include/reg_objects.h b/source/include/reg_objects.h
index d9159dd464ded4f62cf4a198ae1bd3536f3810a1..6081eb482cf855b1e2f2a5352fdeda4614e53fde 100644 (file)
--- a/source/include/reg_objects.h
+++ b/source/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/source/include/regfio.h b/source/include/regfio.h
index 63516a358dc3621cd8d3ab6c25ce3e3a7d6b5ad1..0e957d51e51be5c76cda083f9ab648161ad7f6ae 100644 (file)
--- a/source/include/regfio.h
+++ b/source/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/source/registry/reg_api.c b/source/registry/reg_api.c
index 4db4f3c5e4f72a8b88e8243782b61cb48f630006..bea8664f8e844eeb63f2c5b8d406a922a15b1c83 100644 (file)
--- a/source/registry/reg_api.c
+++ b/source/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/source/registry/reg_backend_current_version.c b/source/registry/reg_backend_current_version.c
index 04cc0ebfa723513b53993a3e20836cde5c69ecf5..f76840ee227c79dc591b2125540faea132ab2ed1 100644 (file)
--- a/source/registry/reg_backend_current_version.c
+++ b/source/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/source/registry/reg_backend_db.c b/source/registry/reg_backend_db.c
index fa69d0845c1d0a1b5029bf72081e8cb35136909d..453ff46d5a306e12ce5f50ba11ad693f65f58153 100644 (file)
--- a/source/registry/reg_backend_db.c
+++ b/source/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/source/registry/reg_backend_hkpt_params.c b/source/registry/reg_backend_hkpt_params.c
index 2ed5e78e1ca0b1a2b14cb340fa92ae29b5f87639..c67f7b3ea4486ad5314657fb366e5e7de20cef51 100644 (file)
--- a/source/registry/reg_backend_hkpt_params.c
+++ b/source/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/source/registry/reg_backend_netlogon_params.c b/source/registry/reg_backend_netlogon_params.c
index 71f88144c831ae7c04da833e574f63f1496a0fb4..17abf038a6a307afd5407e589a8f5b84ef1d24a8 100644 (file)
--- a/source/registry/reg_backend_netlogon_params.c
+++ b/source/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/source/registry/reg_backend_perflib.c b/source/registry/reg_backend_perflib.c
index 999bca2682965b5d4807309d8667287d36d06b5d..e23c87efe8b93e7dc1262c32b51fb09dd90f3176 100644 (file)
--- a/source/registry/reg_backend_perflib.c
+++ b/source/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/source/registry/reg_backend_printing.c b/source/registry/reg_backend_printing.c
index 5c1e6eb54305144b2d6e9a3b3855a824a6708b72..192bc78e09f864d0a9e17c546a9d5a938bd20a42 100644 (file)
--- a/source/registry/reg_backend_printing.c
+++ b/source/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/source/registry/reg_backend_prod_options.c b/source/registry/reg_backend_prod_options.c
index 7ac5c5b4b9d8f7e24fb36a090a8f1242bbaa182e..3e9d32cd9791b327e19d9fceccdb2015f4a8c8d3 100644 (file)
--- a/source/registry/reg_backend_prod_options.c
+++ b/source/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/source/registry/reg_backend_shares.c b/source/registry/reg_backend_shares.c
index ee9e5dc5a1848e675e34c1bcc85795567f3ad3d7..a30ae34b4e2ab76ea804c62dc8ca58fbeb77ed2e 100644 (file)
--- a/source/registry/reg_backend_shares.c
+++ b/source/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/source/registry/reg_backend_smbconf.c b/source/registry/reg_backend_smbconf.c
index 2e4a5f1c1d7ec84e9113177e398fa01d2627321f..10ee138e0eb1b8447d1fdc9f8511ed8be0ed4a6c 100644 (file)
--- a/source/registry/reg_backend_smbconf.c
+++ b/source/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/source/registry/reg_backend_tcpip_params.c b/source/registry/reg_backend_tcpip_params.c
index db7df5dd8ffecb1cdf8ad79c5a6a48d7bf89bd16..a6aa2fc2eaf118c50460ad07aa8440373eb1ad3c 100644 (file)
--- a/source/registry/reg_backend_tcpip_params.c
+++ b/source/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/source/registry/reg_dispatcher.c b/source/registry/reg_dispatcher.c
index c16062205409193eb16d3663bba331813772f0a5..0db9e1b14662e15526af4db681114603fe68007c 100644 (file)
--- a/source/registry/reg_dispatcher.c
+++ b/source/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/source/registry/reg_eventlog.c b/source/registry/reg_eventlog.c
index 8994acf107ec43d1b7a7f6bee9a7469eebcb3c2c..5617f212eb31892a290edf45009f999aabc68db2 100644 (file)
--- a/source/registry/reg_eventlog.c
+++ b/source/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/source/registry/reg_objects.c b/source/registry/reg_objects.c
index 47122ccad2a20739e0c1483403eed89300b7e099..a9a4939034899be8ab4c0c6433db62dc7539402f 100644 (file)
--- a/source/registry/reg_objects.c
+++ b/source/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/source/registry/regfio.c b/source/registry/regfio.c
index b6e822955c5d6ddec17d514406877ae20b140dca..b8395d0c03cbacad24aec6ad85651976c6b4e31f 100644 (file)
--- a/source/registry/regfio.c
+++ b/source/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/source/services/services_db.c b/source/services/services_db.c
index 35c071fdf6c0131d3ba1e1a067d8208641c67642..43b714d37ededcddbee7484a5b07c2d20c9d811c 100644 (file)
--- a/source/services/services_db.c
+++ b/source/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/source/utils/net_rpc_registry.c b/source/utils/net_rpc_registry.c
index 124af00b57dff2fcd289e36fd7d3605e73af8dca..72ca31e56413ba93ae5fdbfd24904e930bbb03e6 100644 (file)
--- a/source/utils/net_rpc_registry.c
+++ b/source/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/source/utils/profiles.c b/source/utils/profiles.c
index bbbaaf089f81672923b1ea327452d98588657d60..2c9bc36fafaedb5d7ca052a2d2e61067406f69db 100644 (file)
--- a/source/utils/profiles.c
+++ b/source/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 );