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 REGISTRY_VALUE by struct regval_blob

Browse Source 
Michael
This commit is contained in:
Michael Adam 2009-03-23 22:27:59 +01:00
parent 221151a2a2
commit 8185d31fb0
15 changed files with 83 additions and 76 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
source3/include/proto.h
View File

@ -4628,7 +4628,7 @@ WERROR delete_all_printer_data( NT_PRINTER_INFO_LEVEL_2 *p2, const char *key );
WERROR delete_printer_data( NT_PRINTER_INFO_LEVEL_2 *p2, const char *key, const char *value );
WERROR add_printer_data( NT_PRINTER_INFO_LEVEL_2 *p2, const char *key, const char *value,
uint32 type, uint8 *data, int real_len );
REGISTRY_VALUE* get_printer_data( NT_PRINTER_INFO_LEVEL_2 *p2, const char *key, const char *value );
struct regval_blob* get_printer_data( NT_PRINTER_INFO_LEVEL_2 *p2, const char *key, const char *value );
WERROR mod_a_printer(NT_PRINTER_INFO_LEVEL *printer, uint32 level);
bool set_driver_init(NT_PRINTER_INFO_LEVEL *printer, uint32 level);
bool del_driver_init(const char *drivername);
@ -4906,23 +4906,26 @@ 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(struct regval_ctr *ctr);
REGISTRY_VALUE* dup_registry_value( REGISTRY_VALUE *val );
void free_registry_value( REGISTRY_VALUE *val );
uint8* regval_data_p( REGISTRY_VALUE *val );
uint32 regval_size( REGISTRY_VALUE *val );
char* regval_name( REGISTRY_VALUE *val );
uint32 regval_type( REGISTRY_VALUE *val );
REGISTRY_VALUE* regval_ctr_specific_value(struct regval_ctr *ctr, uint32 idx);
struct regval_blob* dup_registry_value(struct regval_blob *val);
void free_registry_value(struct regval_blob *val);
uint8* regval_data_p(struct regval_blob *val);
uint32 regval_size(struct regval_blob *val);
char* regval_name(struct regval_blob *val);
uint32 regval_type(struct regval_blob *val);
struct regval_blob* regval_ctr_specific_value(struct regval_ctr *ctr,
uint32 idx);
bool regval_ctr_key_exists(struct regval_ctr *ctr, const char *value);
REGISTRY_VALUE *regval_compose(TALLOC_CTX *ctx, const char *name, uint16 type,
const char *data_p, size_t size);
struct regval_blob *regval_compose(TALLOC_CTX *ctx, const char *name,
uint16 type,
const char *data_p, size_t size);
int regval_ctr_addvalue(struct regval_ctr *ctr, const char *name, uint16 type,
const char *data_p, size_t size);
int regval_ctr_copyvalue(struct regval_ctr *ctr, REGISTRY_VALUE *val);
int regval_ctr_copyvalue(struct regval_ctr *ctr, struct regval_blob *val);
int regval_ctr_delvalue(struct regval_ctr *ctr, const char *name);
REGISTRY_VALUE* regval_ctr_getvalue(struct regval_ctr *ctr, const char *name);
uint32 regval_dword( REGISTRY_VALUE *val );
char *regval_sz(REGISTRY_VALUE *val);
struct regval_blob* regval_ctr_getvalue(struct regval_ctr *ctr,
const char *name);
uint32 regval_dword(struct regval_blob *val);
char *regval_sz(struct regval_blob *val);
/* The following definitions come from registry/reg_perfcount.c */

6
source3/include/reg_objects.h
View File

@ -23,13 +23,13 @@
/* structure to contain registry values */
typedef struct {
struct regval_blob {
fstring valuename;
uint16 type;
/* this should be encapsulated in an RPC_DATA_BLOB */
uint32 size; /* in bytes */
uint8 *data_p;
} REGISTRY_VALUE;
};
/*
* A REG_SZ string is not necessarily NULL terminated. When retrieving it from
@ -60,7 +60,7 @@ struct registry_value {
struct regval_ctr {
uint32 num_values;
REGISTRY_VALUE **values;
struct regval_blob **values;
int seqnum;
};

16
source3/libads/ldap_printer.c
View File

@ -118,7 +118,7 @@ ADS_STATUS ads_add_printer_entry(ADS_STRUCT *ads, char *prt_dn,
map a REG_SZ to an ldap mod
*/
static bool map_sz(TALLOC_CTX *ctx, ADS_MODLIST *mods,
const REGISTRY_VALUE *value)
const struct regval_blob *value)
{
char *str_value = NULL;
size_t converted_size;
@ -145,7 +145,7 @@ static bool map_sz(TALLOC_CTX *ctx, ADS_MODLIST *mods,
map a REG_DWORD to an ldap mod
*/
static bool map_dword(TALLOC_CTX *ctx, ADS_MODLIST *mods,
const REGISTRY_VALUE *value)
const struct regval_blob *value)
{
char *str_value = NULL;
ADS_STATUS status;
@ -164,7 +164,7 @@ static bool map_dword(TALLOC_CTX *ctx, ADS_MODLIST *mods,
map a boolean REG_BINARY to an ldap mod
*/
static bool map_bool(TALLOC_CTX *ctx, ADS_MODLIST *mods,
const REGISTRY_VALUE *value)
const struct regval_blob *value)
{
char *str_value;
ADS_STATUS status;
@ -184,7 +184,7 @@ static bool map_bool(TALLOC_CTX *ctx, ADS_MODLIST *mods,
map a REG_MULTI_SZ to an ldap mod
*/
static bool map_multi_sz(TALLOC_CTX *ctx, ADS_MODLIST *mods,
const REGISTRY_VALUE *value)
const struct regval_blob *value)
{
char **str_values = NULL;
size_t converted_size;
@ -225,14 +225,14 @@ static bool map_multi_sz(TALLOC_CTX *ctx, ADS_MODLIST *mods,
struct valmap_to_ads {
const char *valname;
bool (*fn)(TALLOC_CTX *, ADS_MODLIST *, const REGISTRY_VALUE *);
bool (*fn)(TALLOC_CTX *, ADS_MODLIST *, const struct regval_blob *);
};
/*
map a REG_SZ to an ldap mod
*/
static void map_regval_to_ads(TALLOC_CTX *ctx, ADS_MODLIST *mods,
REGISTRY_VALUE *value)
struct regval_blob *value)
{
const struct valmap_to_ads map[] = {
{SPOOL_REG_ASSETNUMBER, map_sz},
@ -344,7 +344,7 @@ WERROR get_remote_printer_publishing_data(struct rpc_pipe_client *cli,
} else {
/* Have the data we need now, so start building */
for (i=0; i < count; i++) {
REGISTRY_VALUE v;
struct regval_blob v;
DATA_BLOB blob;
result = push_spoolss_PrinterData(mem_ctx, &blob,
@ -371,7 +371,7 @@ WERROR get_remote_printer_publishing_data(struct rpc_pipe_client *cli,
printername, win_errstr(result)));
} else {
for (i=0; i < count; i++) {
REGISTRY_VALUE v;
struct regval_blob v;
DATA_BLOB blob = data_blob_null;
result = push_spoolss_PrinterData(mem_ctx, &blob,

8
source3/printing/nt_printing.c
View File

@ -2473,7 +2473,7 @@ static int pack_values(NT_PRINTER_DATA *data, uint8 *buf, int buflen)
{
int len = 0;
int i, j;
REGISTRY_VALUE *val;
struct regval_blob *val;
struct regval_ctr *val_ctr;
char *path = NULL;
int num_values;
@ -3470,7 +3470,7 @@ bool is_printer_published(Printer_entry *print_hnd, int snum,
{
NT_PRINTER_INFO_LEVEL *printer = NULL;
struct regval_ctr *ctr;
REGISTRY_VALUE *guid_val;
struct regval_blob *guid_val;
WERROR win_rc;
int i;
bool ret = False;
@ -3690,7 +3690,7 @@ WERROR add_printer_data( NT_PRINTER_INFO_LEVEL_2 *p2, const char *key, const cha
/****************************************************************************
***************************************************************************/
REGISTRY_VALUE* get_printer_data( NT_PRINTER_INFO_LEVEL_2 *p2, const char *key, const char *value )
struct regval_blob* get_printer_data( NT_PRINTER_INFO_LEVEL_2 *p2, const char *key, const char *value )
{
int key_index;
@ -3717,7 +3717,7 @@ static int unpack_values(NT_PRINTER_DATA *printer_data, const uint8 *buf, int bu
char *str;
int size;
uint8 *data_p;
REGISTRY_VALUE *regval_p;
struct regval_blob *regval_p;
int key_index;
/* add the "PrinterDriverData" key first for performance reasons */

2
source3/registry/reg_backend_db.c
View File

@ -1447,7 +1447,7 @@ static int regdb_pack_values(struct regval_ctr *values, uint8 *buf, int buflen)
{
int len = 0;
int i;
REGISTRY_VALUE *val;
struct regval_blob *val;
int num_values;
if ( !values )

4
source3/registry/reg_backend_printing.c
View File

@ -598,7 +598,7 @@ static void convert_values_to_printer_info_2(NT_PRINTER_INFO_LEVEL_2 *printer2,
{
int num_values = regval_ctr_numvals( values );
uint32 value_index;
REGISTRY_VALUE *val;
struct regval_blob *val;
int i;
for ( i=0; i<num_values; i++ ) {
@ -702,7 +702,7 @@ static bool key_printers_store_values(const char *key, struct regval_ctr *values
else {
int num_values = regval_ctr_numvals( values );
int i;
REGISTRY_VALUE *val;
struct regval_blob *val;
delete_printer_key( printer->info_2->data, keyname );

2
source3/registry/reg_eventlog.c
View File

@ -202,7 +202,7 @@ bool eventlog_add_source( const char *eventlog, const char *sourcename,
char *evtlogpath = NULL;
struct regsubkey_ctr *subkeys;
struct regval_ctr *values;
REGISTRY_VALUE *rval;
struct regval_blob *rval;
UNISTR2 data;
uint16 *msz_wp;
int mbytes, ii;

49
source3/registry/reg_objects.c
View File

@ -279,25 +279,25 @@ int regval_ctr_numvals(struct regval_ctr *ctr)
}
/***********************************************************************
allocate memory for and duplicate a REGISTRY_VALUE.
allocate memory for and duplicate a struct regval_blob.
This is malloc'd memory so the caller should free it when done
**********************************************************************/
REGISTRY_VALUE* dup_registry_value( REGISTRY_VALUE *val )
struct regval_blob* dup_registry_value(struct regval_blob *val)
{
REGISTRY_VALUE *copy = NULL;
struct regval_blob *copy = NULL;
if ( !val )
return NULL;
if ( !(copy = SMB_MALLOC_P( REGISTRY_VALUE)) ) {
if ( !(copy = SMB_MALLOC_P( struct regval_blob)) ) {
DEBUG(0,("dup_registry_value: malloc() failed!\n"));
return NULL;
}
/* copy all the non-pointer initial data */
memcpy( copy, val, sizeof(REGISTRY_VALUE) );
memcpy( copy, val, sizeof(struct regval_blob) );
copy->size = 0;
copy->data_p = NULL;
@ -318,10 +318,10 @@ REGISTRY_VALUE* dup_registry_value( REGISTRY_VALUE *val )
}
/**********************************************************************
free the memory allocated to a REGISTRY_VALUE
free the memory allocated to a struct regval_blob
*********************************************************************/
void free_registry_value( REGISTRY_VALUE *val )
void free_registry_value(struct regval_blob *val)
{
if ( !val )
return;
@ -335,7 +335,7 @@ void free_registry_value( REGISTRY_VALUE *val )
/**********************************************************************
*********************************************************************/
uint8* regval_data_p( REGISTRY_VALUE *val )
uint8* regval_data_p(struct regval_blob *val)
{
return val->data_p;
}
@ -343,7 +343,7 @@ uint8* regval_data_p( REGISTRY_VALUE *val )
/**********************************************************************
*********************************************************************/
uint32 regval_size( REGISTRY_VALUE *val )
uint32 regval_size(struct regval_blob *val)
{
return val->size;
}
@ -351,7 +351,7 @@ uint32 regval_size( REGISTRY_VALUE *val )
/**********************************************************************
*********************************************************************/
char* regval_name( REGISTRY_VALUE *val )
char* regval_name(struct regval_blob *val)
{
return val->valuename;
}
@ -359,7 +359,7 @@ char* regval_name( REGISTRY_VALUE *val )
/**********************************************************************
*********************************************************************/
uint32 regval_type( REGISTRY_VALUE *val )
uint32 regval_type(struct regval_blob *val)
{
return val->type;
}
@ -369,7 +369,8 @@ uint32 regval_type( REGISTRY_VALUE *val )
since this memory will go away when the ctr is free()'d
**********************************************************************/
REGISTRY_VALUE* regval_ctr_specific_value(struct regval_ctr *ctr, uint32 idx)
struct regval_blob *regval_ctr_specific_value(struct regval_ctr *ctr,
uint32 idx)
{
if ( !(idx < ctr->num_values) )
return NULL;
@ -394,13 +395,14 @@ bool regval_ctr_key_exists(struct regval_ctr *ctr, const char *value)
}
/***********************************************************************
* compose a REGISTRY_VALUE from input data
* compose a struct regval_blob from input data
**********************************************************************/
REGISTRY_VALUE *regval_compose(TALLOC_CTX *ctx, const char *name, uint16 type,
const char *data_p, size_t size)
struct regval_blob *regval_compose(TALLOC_CTX *ctx, const char *name,
uint16 type,
const char *data_p, size_t size)
{
REGISTRY_VALUE *regval = TALLOC_P(ctx, REGISTRY_VALUE);
struct regval_blob *regval = TALLOC_P(ctx, struct regval_blob);
if (regval == NULL) {
return NULL;
@ -439,10 +441,10 @@ int regval_ctr_addvalue(struct regval_ctr *ctr, const char *name, uint16 type,
/* allocate a slot in the array of pointers */
if ( ctr->num_values == 0 ) {
ctr->values = TALLOC_P( ctr, REGISTRY_VALUE *);
ctr->values = TALLOC_P( ctr, struct regval_blob *);
} else {
ctr->values = TALLOC_REALLOC_ARRAY(ctr, ctr->values,
REGISTRY_VALUE *,
struct regval_blob *,
ctr->num_values+1);
}
@ -468,7 +470,7 @@ int regval_ctr_addvalue(struct regval_ctr *ctr, const char *name, uint16 type,
Add a new registry value to the array
**********************************************************************/
int regval_ctr_copyvalue(struct regval_ctr *ctr, REGISTRY_VALUE *val)
int regval_ctr_copyvalue(struct regval_ctr *ctr, struct regval_blob *val)
{
if ( val ) {
regval_ctr_addvalue(ctr, val->valuename, val->type,
@ -501,7 +503,7 @@ int regval_ctr_delvalue(struct regval_ctr *ctr, const char *name)
ctr->num_values--;
if ( i < ctr->num_values )
memmove(&ctr->values[i], &ctr->values[i+1],
sizeof(REGISTRY_VALUE*)*(ctr->num_values-i));
sizeof(struct regval_blob*)*(ctr->num_values-i));
return ctr->num_values;
}
@ -511,7 +513,8 @@ int regval_ctr_delvalue(struct regval_ctr *ctr, const char *name)
No need to free memory since it is talloc'd.
**********************************************************************/
REGISTRY_VALUE* regval_ctr_getvalue(struct regval_ctr *ctr, const char *name)
struct regval_blob* regval_ctr_getvalue(struct regval_ctr *ctr,
const char *name)
{
int i;
@ -529,7 +532,7 @@ REGISTRY_VALUE* regval_ctr_getvalue(struct regval_ctr *ctr, const char *name)
return the data_p as a uint32
**********************************************************************/
uint32 regval_dword( REGISTRY_VALUE *val )
uint32 regval_dword(struct regval_blob *val)
{
uint32 data;
@ -542,7 +545,7 @@ uint32 regval_dword( REGISTRY_VALUE *val )
return the data_p as a character string
**********************************************************************/
char *regval_sz(REGISTRY_VALUE *val)
char *regval_sz(struct regval_blob *val)
{
char *data = NULL;

5
source3/registry/regfio.c
View File

@ -1657,7 +1657,8 @@ static uint32 nk_record_data_size( REGF_NK_REC *nk )
/*******************************************************************
*******************************************************************/
static bool create_vk_record( REGF_FILE *file, REGF_VK_REC *vk, REGISTRY_VALUE *value )
static bool create_vk_record(REGF_FILE *file, REGF_VK_REC *vk,
struct regval_blob *value)
{
char *name = regval_name(value);
REGF_HBIN *data_hbin;
@ -1894,7 +1895,7 @@ static int hashrec_cmp( REGF_HASH_REC *h1, REGF_HASH_REC *h2 )
for ( i=0; i<nk->num_values; i++ ) {
uint32 vk_size, namelen, datalen;
REGISTRY_VALUE *r;
struct regval_blob *r;
r = regval_ctr_specific_value( values, i );
create_vk_record( file, &nk->values[i], r );

2
source3/rpc_server/srv_ntsvcs_nt.c
View File

@ -125,7 +125,7 @@ WERROR _PNP_GetDeviceRegProp(pipes_struct *p,
{
char *ptr;
struct regval_ctr *values;
REGISTRY_VALUE *val;
struct regval_blob *val;
switch( r->in.property ) {
case DEV_REGPROP_DESC:

10
source3/rpc_server/srv_spoolss_nt.c
View File

@ -2547,7 +2547,7 @@ WERROR _spoolss_GetPrinterData(pipes_struct *p,
r->out.data->value = printer->info_2->changeid;
result = WERR_OK;
} else {
REGISTRY_VALUE *v;
struct regval_blob *v;
DATA_BLOB blob;
v = get_printer_data(printer->info_2,
@ -7944,7 +7944,7 @@ WERROR _spoolss_EnumPrinterData(pipes_struct *p,
Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
int snum;
WERROR result;
REGISTRY_VALUE *val = NULL;
struct regval_blob *val = NULL;
NT_PRINTER_DATA *p_data;
int i, key_index, num_values;
int name_length;
@ -9026,7 +9026,7 @@ WERROR _spoolss_GetPrinterDataEx(pipes_struct *p,
{
Printer_entry *Printer = find_printer_index_by_hnd(p, r->in.handle);
REGISTRY_VALUE *val = NULL;
struct regval_blob *val = NULL;
NT_PRINTER_INFO_LEVEL *printer = NULL;
int snum = 0;
WERROR result = WERR_OK;
@ -9390,7 +9390,7 @@ WERROR _spoolss_DeletePrinterKey(pipes_struct *p,
****************************************************************/
static WERROR registry_value_to_printer_enum_value(TALLOC_CTX *mem_ctx,
REGISTRY_VALUE *v,
struct regval_blob *v,
struct spoolss_PrinterEnumValues *r)
{
WERROR result;
@ -9507,7 +9507,7 @@ WERROR _spoolss_EnumPrinterDataEx(pipes_struct *p,
for (i=0; i < count; i++) {
REGISTRY_VALUE *val;
struct regval_blob *val;
/* lookup the registry value */

2
source3/rpc_server/srv_svcctl_nt.c
View File

@ -635,7 +635,7 @@ static WERROR fill_svc_config( TALLOC_CTX *ctx, const char *name,
NT_USER_TOKEN *token )
{
struct regval_ctr *values;
REGISTRY_VALUE *val;
struct regval_blob *val;
/* retrieve the registry values for this service */

6
source3/rpcclient/cmd_spoolss.c
View File

@ -642,7 +642,7 @@ static WERROR cmd_spoolss_getprinter(struct rpc_pipe_client *cli,
/****************************************************************************
****************************************************************************/
static void display_reg_value(REGISTRY_VALUE value)
static void display_reg_value(struct regval_blob value)
{
char *text = NULL;
@ -821,7 +821,7 @@ static WERROR cmd_spoolss_getprinterdataex(struct rpc_pipe_client *cli,
NTSTATUS status;
fstring printername;
const char *valuename, *keyname;
REGISTRY_VALUE value;
struct regval_blob value;
enum winreg_Type type;
uint8_t *buffer = NULL;
@ -2574,7 +2574,7 @@ static WERROR cmd_spoolss_enum_data(struct rpc_pipe_client *cli,
&data_needed,
&result);
if (NT_STATUS_IS_OK(status) && W_ERROR_IS_OK(result)) {
REGISTRY_VALUE v;
struct regval_blob v;
fstrcpy(v.valuename, value_name);
v.type = type;
v.size = data_offered;

6
source3/services/services_db.c
View File

@ -506,7 +506,7 @@ SEC_DESC *svcctl_get_secdesc( TALLOC_CTX *ctx, const char *name, NT_USER_TOKEN *
{
REGISTRY_KEY *key = NULL;
struct regval_ctr *values = NULL;
REGISTRY_VALUE *val = NULL;
struct regval_blob *val = NULL;
SEC_DESC *ret_sd = NULL;
char *path= NULL;
WERROR wresult;
@ -621,7 +621,7 @@ const char *svcctl_lookup_dispname(TALLOC_CTX *ctx, const char *name, NT_USER_TO
char *display_name = NULL;
REGISTRY_KEY *key = NULL;
struct regval_ctr *values = NULL;
REGISTRY_VALUE *val = NULL;
struct regval_blob *val = NULL;
char *path = NULL;
WERROR wresult;
@ -671,7 +671,7 @@ const char *svcctl_lookup_description(TALLOC_CTX *ctx, const char *name, NT_USER
char *description = NULL;
REGISTRY_KEY *key = NULL;
struct regval_ctr *values = NULL;
REGISTRY_VALUE *val = NULL;
struct regval_blob *val = NULL;
char *path = NULL;
WERROR wresult;

10
source3/utils/net_rpc_printer.c
View File

@ -77,7 +77,7 @@ static void display_print_driver3(struct spoolss_DriverInfo3 *r)
printf("\tDefaultdatatype: [%s]\n\n", r->default_datatype);
}
static void display_reg_value(const char *subkey, REGISTRY_VALUE value)
static void display_reg_value(const char *subkey, struct regval_blob value)
{
char *text;
@ -892,7 +892,7 @@ static bool net_spoolss_setprinterdataex(struct rpc_pipe_client *pipe_hnd,
TALLOC_CTX *mem_ctx,
struct policy_handle *hnd,
const char *keyname,
REGISTRY_VALUE *value)
struct regval_blob *value)
{
WERROR result;
NTSTATUS status;
@ -2318,7 +2318,7 @@ NTSTATUS rpc_printer_migrate_settings_internals(struct net_context *c,
/* loop for all reg_keys */
if (NT_STATUS_IS_OK(nt_status) && W_ERROR_IS_OK(result)) {
REGISTRY_VALUE v;
struct regval_blob v;
DATA_BLOB blob;
union spoolss_PrinterData printer_data;
@ -2385,7 +2385,7 @@ NTSTATUS rpc_printer_migrate_settings_internals(struct net_context *c,
for (j=0; j < count; j++) {
REGISTRY_VALUE value;
struct regval_blob value;
UNISTR2 data;
/* although samba replies with sane data in most cases we
@ -2459,7 +2459,7 @@ NTSTATUS rpc_printer_migrate_settings_internals(struct net_context *c,
} else {
REGISTRY_VALUE v;
struct regval_blob v;
DATA_BLOB blob;
result = push_spoolss_PrinterData(mem_ctx, &blob,