s3:registry: replace typedef REGISTRY_VALUE by struct regval_blob

Michael

15 files changed, 83 insertions, 76 deletions

diff --git a/source3/include/proto.h b/source3/include/proto.h
index d39c3de607..7fa8f03766 100644
--- a/source3/include/proto.h
+++ b/source3/include/proto.h
@@ -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  */
 
diff --git a/source3/include/reg_objects.h b/source3/include/reg_objects.h
index 029f8544d6..0badf223ae 100644
--- a/source3/include/reg_objects.h
+++ b/source3/include/reg_objects.h
@@ -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;
 };
 
diff --git a/source3/libads/ldap_printer.c b/source3/libads/ldap_printer.c
index c1bfd75d88..a5290292a5 100644
--- a/source3/libads/ldap_printer.c
+++ b/source3/libads/ldap_printer.c
@@ -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,
diff --git a/source3/printing/nt_printing.c b/source3/printing/nt_printing.c
index 49e28403e2..d6054f2c08 100644
--- a/source3/printing/nt_printing.c
+++ b/source3/printing/nt_printing.c
@@ -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 */
diff --git a/source3/registry/reg_backend_db.c b/source3/registry/reg_backend_db.c
index 82cf7cae39..5229f154ac 100644
--- a/source3/registry/reg_backend_db.c
+++ b/source3/registry/reg_backend_db.c
@@ -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 )
diff --git a/source3/registry/reg_backend_printing.c b/source3/registry/reg_backend_printing.c
index 01d2a6deb1..0854d7d8fc 100644
--- a/source3/registry/reg_backend_printing.c
+++ b/source3/registry/reg_backend_printing.c
@@ -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 );
 		
diff --git a/source3/registry/reg_eventlog.c b/source3/registry/reg_eventlog.c
index fbeef9acad..45ade52102 100644
--- a/source3/registry/reg_eventlog.c
+++ b/source3/registry/reg_eventlog.c
@@ -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;
diff --git a/source3/registry/reg_objects.c b/source3/registry/reg_objects.c
index 79539598ab..5ae1cd8aa7 100644
--- a/source3/registry/reg_objects.c
+++ b/source3/registry/reg_objects.c
@@ -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;
 
diff --git a/source3/registry/regfio.c b/source3/registry/regfio.c
index 006db7627c..cc6a6f4103 100644
--- a/source3/registry/regfio.c
+++ b/source3/registry/regfio.c
@@ -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 );
diff --git a/source3/rpc_server/srv_ntsvcs_nt.c b/source3/rpc_server/srv_ntsvcs_nt.c
index 474cde2b3e..553707bfe5 100644
--- a/source3/rpc_server/srv_ntsvcs_nt.c
+++ b/source3/rpc_server/srv_ntsvcs_nt.c
@@ -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:
diff --git a/source3/rpc_server/srv_spoolss_nt.c b/source3/rpc_server/srv_spoolss_nt.c
index 9ad509efbb..a4c994a193 100644
--- a/source3/rpc_server/srv_spoolss_nt.c
+++ b/source3/rpc_server/srv_spoolss_nt.c
@@ -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 */
 
diff --git a/source3/rpc_server/srv_svcctl_nt.c b/source3/rpc_server/srv_svcctl_nt.c
index ebb254571a..f5b7b61020 100644
--- a/source3/rpc_server/srv_svcctl_nt.c
+++ b/source3/rpc_server/srv_svcctl_nt.c
@@ -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 */
 
diff --git a/source3/rpcclient/cmd_spoolss.c b/source3/rpcclient/cmd_spoolss.c
index b7ea9640d2..aefaa04a9f 100644
--- a/source3/rpcclient/cmd_spoolss.c
+++ b/source3/rpcclient/cmd_spoolss.c
@@ -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;
diff --git a/source3/services/services_db.c b/source3/services/services_db.c
index 1c9495f732..8f3803f30e 100644
--- a/source3/services/services_db.c
+++ b/source3/services/services_db.c
@@ -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;
 
diff --git a/source3/utils/net_rpc_printer.c b/source3/utils/net_rpc_printer.c
index ea613e7886..baaf8e9fa3 100644
--- a/source3/utils/net_rpc_printer.c
+++ b/source3/utils/net_rpc_printer.c
@@ -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,