{
REGISTRY_KEY *regkey = NULL;
WERROR result = WERR_OK;
- REGSUBKEY_CTR subkeys;
+ REGSUBKEY_CTR *subkeys = NULL;
pstring subkeyname2;
int subkey_len;
if ( !(regkey->hook = reghook_cache_find( regkey->name )) ) {
DEBUG(0,("open_registry_key: Failed to assigned a REGISTRY_HOOK to [%s]\n",
regkey->name ));
- return WERR_BADFILE;
+ result = WERR_BADFILE;
+ goto done;
}
/* check if the path really exists; failed is indicated by -1 */
/* if the subkey count failed, bail out */
- regsubkey_ctr_init( &subkeys );
-
- if ( fetch_reg_keys( regkey, &subkeys ) == -1 ) {
+ if ( !(subkeys = TALLOC_ZERO_P( p->mem_ctx, REGSUBKEY_CTR )) ) {
+ result = WERR_NOMEM;
+ goto done;
+ }
+
+ if ( fetch_reg_keys( regkey, subkeys ) == -1 ) {
result = WERR_BADFILE;
goto done;
}
if ( !create_policy_hnd( p, hnd, free_regkey_info, regkey ) ) {
- result = WERR_BADFILE;
+ result = WERR_BADFILE;
goto done;
}
done:
/* clean up */
- regsubkey_ctr_destroy( &subkeys );
+ TALLOC_FREE( subkeys );
if ( ! NT_STATUS_IS_OK(result) )
SAFE_FREE( regkey );
{
int num_subkeys, i;
uint32 max_len;
- REGSUBKEY_CTR subkeys;
+ REGSUBKEY_CTR *subkeys;
uint32 len;
if ( !key )
return False;
- regsubkey_ctr_init( &subkeys );
-
- if ( fetch_reg_keys( key, &subkeys ) == -1 )
+ if ( !(subkeys = TALLOC_ZERO_P( NULL, REGSUBKEY_CTR )) )
+ return False;
+
+ if ( fetch_reg_keys( key, subkeys ) == -1 )
return False;
/* find the longest string */
max_len = 0;
- num_subkeys = regsubkey_ctr_numkeys( &subkeys );
+ num_subkeys = regsubkey_ctr_numkeys( subkeys );
for ( i=0; i<num_subkeys; i++ ) {
- len = strlen( regsubkey_ctr_specific_key(&subkeys, i) );
+ len = strlen( regsubkey_ctr_specific_key(subkeys, i) );
max_len = MAX(max_len, len);
}
*maxnum = num_subkeys;
*maxlen = max_len*2;
- regsubkey_ctr_destroy( &subkeys );
+ TALLOC_FREE( subkeys );
return True;
}
static BOOL get_value_information( REGISTRY_KEY *key, uint32 *maxnum,
uint32 *maxlen, uint32 *maxsize )
{
- REGVAL_CTR values;
+ REGVAL_CTR *values;
REGISTRY_VALUE *val;
uint32 sizemax, lenmax;
int i, num_values;
if ( !key )
return False;
- regval_ctr_init( &values );
+ if ( !(values = TALLOC_ZERO_P( NULL, REGVAL_CTR )) )
+ return False;
- if ( fetch_reg_values( key, &values ) == -1 )
+ if ( fetch_reg_values( key, values ) == -1 )
return False;
lenmax = sizemax = 0;
- num_values = regval_ctr_numvals( &values );
+ num_values = regval_ctr_numvals( values );
- val = regval_ctr_specific_value( &values, 0 );
+ val = regval_ctr_specific_value( values, 0 );
for ( i=0; i<num_values && val; i++ )
{
lenmax = MAX(lenmax, val->valuename ? strlen(val->valuename)+1 : 0 );
sizemax = MAX(sizemax, val->size );
- val = regval_ctr_specific_value( &values, i );
+ val = regval_ctr_specific_value( values, i );
}
*maxnum = num_values;
*maxlen = lenmax;
*maxsize = sizemax;
- regval_ctr_destroy( &values );
+ TALLOC_FREE( values );
return True;
}
/* check granted access first; what is the correct mask here? */
- if ( !(parent->access_granted & (SEC_RIGHTS_ENUM_SUBKEYS|SEC_RIGHTS_CREATE_SUBKEY)) )
+ if ( !(parent->access_granted & (SEC_RIGHTS_ENUM_SUBKEYS|SEC_RIGHTS_CREATE_SUBKEY|SEC_RIGHTS_QUERY_VALUE|SEC_RIGHTS_SET_VALUE)) )
return WERR_ACCESS_DENIED;
/* open the key first to get the appropriate REGISTRY_HOOK
fstring name;
REGISTRY_KEY *regkey = find_regkey_index_by_hnd( p, &q_u->pol );
REGISTRY_VALUE *val = NULL;
- REGVAL_CTR regvals;
+ REGVAL_CTR *regvals;
int i;
if ( !regkey )
DEBUG(5,("reg_info: looking up value: [%s]\n", name));
- regval_ctr_init( ®vals );
+ if ( !(regvals = TALLOC_P( p->mem_ctx, REGVAL_CTR )) )
+ return WERR_NOMEM;
for ( i=0; fetch_reg_values_specific(regkey, &val, i); i++ )
{
init_reg_r_query_value(q_u->ptr_buf, r_u, val, status);
- regval_ctr_destroy( ®vals );
+ TALLOC_FREE( regvals );
free_registry_value( val );
return status;
{
REGF_NK_REC *subkey;
REGISTRY_KEY registry_key;
- REGVAL_CTR values;
- REGSUBKEY_CTR subkeys;
+ REGVAL_CTR *values;
+ REGSUBKEY_CTR *subkeys;
int i;
pstring path;
WERROR result = WERR_OK;
/* now start parsing the values and subkeys */
- regsubkey_ctr_init( &subkeys );
- regval_ctr_init( &values );
+ if ( !(subkeys = TALLOC_ZERO_P( regfile->mem_ctx, REGSUBKEY_CTR )) )
+ return WERR_NOMEM;
+ if ( !(values = TALLOC_ZERO_P( subkeys, REGVAL_CTR )) )
+ return WERR_NOMEM;
+
/* copy values into the REGVAL_CTR */
for ( i=0; i<key->num_values; i++ ) {
- regval_ctr_addvalue( &values, key->values[i].valuename, key->values[i].type,
+ regval_ctr_addvalue( values, key->values[i].valuename, key->values[i].type,
key->values[i].data, (key->values[i].data_size & ~VK_DATA_IN_OFFSET) );
}
key->subkey_index = 0;
while ( (subkey = regfio_fetch_subkey( regfile, key )) ) {
- regsubkey_ctr_addkey( &subkeys, subkey->keyname );
+ regsubkey_ctr_addkey( subkeys, subkey->keyname );
}
/* write this key and values out */
- if ( !store_reg_values( ®istry_key, &values )
- || !store_reg_keys( ®istry_key, &subkeys ) )
+ if ( !store_reg_values( ®istry_key, values )
+ || !store_reg_keys( ®istry_key, subkeys ) )
{
DEBUG(0,("reg_load_tree: Failed to load %s!\n", topkeypath));
result = WERR_REG_IO_FAILURE;
}
- regval_ctr_destroy( &values );
- regsubkey_ctr_destroy( &subkeys );
+ TALLOC_FREE( subkeys );
if ( !W_ERROR_IS_OK(result) )
return result;
REGF_NK_REC *parent, SEC_DESC *sec_desc )
{
REGF_NK_REC *key;
- REGVAL_CTR values;
- REGSUBKEY_CTR subkeys;
+ REGVAL_CTR *values;
+ REGSUBKEY_CTR *subkeys;
int i, num_subkeys;
pstring key_tmp;
char *keyname, *parentpath;
/* lookup the values and subkeys */
- regsubkey_ctr_init( &subkeys );
- regval_ctr_init( &values );
-
- fetch_reg_keys( ®istry_key, &subkeys );
- fetch_reg_values( ®istry_key, &values );
+ if ( !(subkeys = TALLOC_ZERO_P( regfile->mem_ctx, REGSUBKEY_CTR )) )
+ return WERR_NOMEM;
+
+ if ( !(values = TALLOC_ZERO_P( subkeys, REGVAL_CTR )) )
+ return WERR_NOMEM;
+
+ fetch_reg_keys( ®istry_key, subkeys );
+ fetch_reg_values( ®istry_key, values );
/* write out this key */
- if ( !(key = regfio_write_key( regfile, keyname, &values, &subkeys, sec_desc, parent )) ) {
+ if ( !(key = regfio_write_key( regfile, keyname, values, subkeys, sec_desc, parent )) ) {
result = WERR_CAN_NOT_COMPLETE;
goto done;
}
/* write each one of the subkeys out */
- num_subkeys = regsubkey_ctr_numkeys( &subkeys );
+ num_subkeys = regsubkey_ctr_numkeys( subkeys );
for ( i=0; i<num_subkeys; i++ ) {
- subkeyname = regsubkey_ctr_specific_key( &subkeys, i );
+ subkeyname = regsubkey_ctr_specific_key( subkeys, i );
pstr_sprintf( subkeypath, "%s\\%s", keypath, subkeyname );
result = reg_write_tree( regfile, subkeypath, key, sec_desc );
if ( !W_ERROR_IS_OK(result) )
DEBUG(6,("reg_write_tree: wrote key [%s]\n", keypath ));
done:
- regval_ctr_destroy( &values );
- regsubkey_ctr_destroy( &subkeys );
+ TALLOC_FREE( subkeys );
return result;
}
REGISTRY_KEY *parent = find_regkey_index_by_hnd(p, &q_u->handle);
REGISTRY_KEY *newparent;
POLICY_HND newparent_handle;
- REGSUBKEY_CTR subkeys;
+ REGSUBKEY_CTR *subkeys;
BOOL write_result;
pstring name;
WERROR result;
goto done;
}
- regsubkey_ctr_init( &subkeys );
-
+ if ( !(subkeys = TALLOC_ZERO_P( p->mem_ctx, REGSUBKEY_CTR )) ) {
+ result = WERR_NOMEM;
+ goto done;
+ }
+
/* (4) lookup the current keys and add the new one */
- fetch_reg_keys( newparent, &subkeys );
- regsubkey_ctr_addkey( &subkeys, name );
+ fetch_reg_keys( newparent, subkeys );
+ regsubkey_ctr_addkey( subkeys, name );
/* now write to the registry backend */
- write_result = store_reg_keys( newparent, &subkeys );
-
- regsubkey_ctr_destroy( &subkeys );
+ write_result = store_reg_keys( newparent, subkeys );
+ TALLOC_FREE( subkeys );
+
if ( !write_result )
return WERR_REG_IO_FAILURE;
WERROR _reg_set_value(pipes_struct *p, REG_Q_SET_VALUE *q_u, REG_R_SET_VALUE *r_u)
{
REGISTRY_KEY *key = find_regkey_index_by_hnd(p, &q_u->handle);
- REGVAL_CTR values;
+ REGVAL_CTR *values;
BOOL write_result;
fstring valuename;
DEBUG(8,("_reg_set_value: Setting value for [%s:%s]\n", key->name, valuename));
- regval_ctr_init( &values );
+ if ( !(values = TALLOC_ZERO_P( p->mem_ctx, REGVAL_CTR )) )
+ return WERR_NOMEM;
/* lookup the current values and add the new one */
- fetch_reg_values( key, &values );
+ fetch_reg_values( key, values );
- regval_ctr_addvalue( &values, valuename, q_u->type, q_u->value.buffer, q_u->value.buf_len );
+ regval_ctr_addvalue( values, valuename, q_u->type, q_u->value.buffer, q_u->value.buf_len );
/* now write to the registry backend */
- write_result = store_reg_values( key, &values );
+ write_result = store_reg_values( key, values );
- regval_ctr_destroy( &values );
+ TALLOC_FREE( values );
if ( !write_result )
return WERR_REG_IO_FAILURE;
REGISTRY_KEY *parent = find_regkey_index_by_hnd(p, &q_u->handle);
REGISTRY_KEY *newparent;
POLICY_HND newparent_handle;
- REGSUBKEY_CTR subkeys;
+ REGSUBKEY_CTR *subkeys;
BOOL write_result;
pstring name;
WERROR result;
goto done;
}
- regsubkey_ctr_init( &subkeys );
+ if ( !(subkeys = TALLOC_ZERO_P( p->mem_ctx, REGSUBKEY_CTR )) ) {
+ result = WERR_NOMEM;
+ goto done;
+ }
/* lookup the current keys and delete the new one */
- fetch_reg_keys( newparent, &subkeys );
+ fetch_reg_keys( newparent, subkeys );
- regsubkey_ctr_delkey( &subkeys, name );
+ regsubkey_ctr_delkey( subkeys, name );
/* now write to the registry backend */
- write_result = store_reg_keys( newparent, &subkeys );
+ write_result = store_reg_keys( newparent, subkeys );
- regsubkey_ctr_destroy( &subkeys );
+ TALLOC_FREE( subkeys );
result = write_result ? WERR_OK : WERR_REG_IO_FAILURE;
WERROR _reg_delete_value(pipes_struct *p, REG_Q_DELETE_VALUE *q_u, REG_R_DELETE_VALUE *r_u)
{
REGISTRY_KEY *key = find_regkey_index_by_hnd(p, &q_u->handle);
- REGVAL_CTR values;
+ REGVAL_CTR *values;
BOOL write_result;
fstring valuename;
DEBUG(8,("_reg_delete_value: Setting value for [%s:%s]\n", key->name, valuename));
- regval_ctr_init( &values );
+ if ( !(values = TALLOC_ZERO_P( p->mem_ctx, REGVAL_CTR )) )
+ return WERR_NOMEM;
/* lookup the current values and add the new one */
- fetch_reg_values( key, &values );
+ fetch_reg_values( key, values );
- regval_ctr_delvalue( &values, valuename );
+ regval_ctr_delvalue( values, valuename );
/* now write to the registry backend */
- write_result = store_reg_values( key, &values );
+ write_result = store_reg_values( key, values );
- regval_ctr_destroy( &values );
+ TALLOC_FREE( values );
if ( !write_result )
return WERR_REG_IO_FAILURE;
git.samba.org / ira / wip.git / blobdiff