sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2025-03-27 22:50:26 +03:00
Code

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

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

Michael
This commit is contained in:
Michael Adam 2009-02-24 15:19:18 +01:00
parent b56f449d6b
commit 58fc61217d
21 changed files with 85 additions and 85 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
source3/include/proto.h
View File

@ -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 );

12
source3/include/reg_objects.h
View File

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

2
source3/include/regfio.h
View File

@ -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 );

16
source3/registry/reg_api.c
View File

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

2
source3/registry/reg_backend_current_version.c
View File

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

26
source3/registry/reg_backend_db.c
View File

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

2
source3/registry/reg_backend_hkpt_params.c
View File

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

2
source3/registry/reg_backend_netlogon_params.c
View File

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

2
source3/registry/reg_backend_perflib.c
View File

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

20
source3/registry/reg_backend_printing.c
View File

@ -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 );

2
source3/registry/reg_backend_prod_options.c
View File

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

4
source3/registry/reg_backend_shares.c
View File

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

4
source3/registry/reg_backend_smbconf.c
View File

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

2
source3/registry/reg_backend_tcpip_params.c
View File

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

6
source3/registry/reg_dispatcher.c
View File

@ -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)
{

12
source3/registry/reg_eventlog.c
View File

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

10
source3/registry/reg_objects.c
View File

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

2
source3/registry/regfio.c
View File

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

10
source3/services/services_db.c
View File

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

6
source3/utils/net_rpc_registry.c
View File

@ -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 );

6
source3/utils/profiles.c
View File

@ -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 );