s3:registry: replace typedef REGISTRY_VALUE by struct regval_blob

Michael

diff --git a/source3/include/proto.h b/source3/include/proto.h
index d39c3de6071414daa0bbaa02df2c880840f4951e..7fa8f03766a81d13ab65b0bf3fe1f8ca511276f5 100644 (file)
--- 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 029f8544d6d42ca2dc07547de2992907dc782a26..0badf223ae6bf3d4e86314a05a662223cdb8418f 100644 (file)
--- 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 c1bfd75d887010c1d51a0533c4a68551b364adb0..a5290292a5d9899cdc992fc43004790a0c69075c 100644 (file)
--- 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 49e28403e24da47661d6fe0f5e7d54de750083ba..d6054f2c083d8b1c6e052500d55579d2be16017c 100644 (file)
--- 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 82cf7cae395c77fee0ed0d5ae437dc5b2e1c0c12..5229f154acf7187472870993e822af6bafe942f1 100644 (file)
--- 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 01d2a6deb1b5e5d914594dd63066a679a715eca7..0854d7d8fc5bbed517fad116a6d8066929566fe9 100644 (file)
--- 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 fbeef9acad85296553be365dd008ed7c33d5d747..45ade5210291ba6df17c70c8dc540312cba0f686 100644 (file)
--- 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 79539598ab92044629f8732906164f7cc3cb07cd..5ae1cd8aa7dec7f6b9585fb6cf295cef2e32b838 100644 (file)
--- 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 006db7627c084b4e52404ac145fa615371d88cb4..cc6a6f4103e71f8a37e65ae231b7c443a58c2cbf 100644 (file)
--- 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 474cde2b3e2d1f5209a2e03016d62d922bd9fc88..553707bfe5f55db76b258436db079b94d381eec7 100644 (file)
--- 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 9ad509efbb6001746d4054a01d621313f6e7e7dd..a4c994a19333cadc45a52bb691c2d28d82cca73a 100644 (file)
--- 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 ebb254571a6da1128334cd0ad26315e2e998a0ad..f5b7b6102079def9dd0df3a6af28d97ad2fe2ece 100644 (file)
--- 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 b7ea9640d240c0ed134d11809df9a0ff967d736f..aefaa04a9f1b63800a409ce27492c102dbd4c00c 100644 (file)
--- 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 1c9495f7321ea2a67586f2af27f481ffea094e48..8f3803f30e50da1a20557c3f9192c75cc6e3fe02 100644 (file)
--- 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 ea613e7886c146f875763d494074c898384f3476..baaf8e9fa3477beb4a7fcc7c871908c679c785fe 100644 (file)
--- 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,