source4/lib/registry/common/reg_objects.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  RPC Pipe client / server routines
   4  *  Copyright (C) Gerald Carter                     2002.
   5  *  Copyright (C) Jelmer Vernooij                                       2003-2004.
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21
  22 /* Implementation of registry frontend view functions. */
  23
  24 #include "includes.h"
  25 #include "lib/registry/common/registry.h"
  26
  27 #undef DBGC_CLASS
  28 #define DBGC_CLASS DBGC_RPC_SRV
  29
  30 /***********************************************************************
  31  allocate memory for and duplicate a REG_VAL.
  32  This is malloc'd memory so the caller should free it when done
  33  **********************************************************************/
  34
  35 REG_VAL* reg_val_dup( REG_VAL *val )
  36 {
  37         REG_VAL         *copy = NULL;
  38
  39         if ( !val )
  40                 return NULL;
  41
  42         if ( !(copy = malloc( sizeof(REG_VAL) )) ) {
  43                 DEBUG(0,("dup_registry_value: malloc() failed!\n"));
  44                 return NULL;
  45         }
  46
  47         /* copy all the non-pointer initial data */
  48
  49         memcpy( copy, val, sizeof(REG_VAL) );
  50         if ( val->data_blk )
  51         {
  52                 if ( !(copy->data_blk = memdup( val->data_blk, val->data_len )) ) {
  53                         DEBUG(0,("dup_registry_value: memdup() failed for [%d] bytes!\n",
  54                                 val->data_len));
  55                         SAFE_FREE( copy );
  56                 }
  57         }
  58
  59         return copy;
  60 }
  61
  62 /**********************************************************************
  63  free the memory allocated to a REG_VAL
  64  *********************************************************************/
  65
  66 void reg_val_free( REG_VAL *val )
  67 {
  68         if ( !val )
  69                 return;
  70
  71         if(val->handle->functions->free_val_backend_data)
  72                 val->handle->functions->free_val_backend_data(val);
  73
  74         SAFE_FREE( val->data_blk );
  75         SAFE_FREE( val );
  76
  77         return;
  78 }
  79
  80 /**********************************************************************
  81  *********************************************************************/
  82
  83 uint8* reg_val_data_blk( REG_VAL *val )
  84 {
  85         return val->data_blk;
  86 }
  87
  88 /**********************************************************************
  89  *********************************************************************/
  90
  91 int reg_val_size( REG_VAL *val )
  92 {
  93         return val->data_len;
  94 }
  95
  96 /**********************************************************************
  97  *********************************************************************/
  98
  99 char *reg_val_name( REG_VAL *val )
 100 {
 101         return val->name;
 102 }
 103
 104 /**********************************************************************
 105  *********************************************************************/
 106
 107 uint32 reg_val_type( REG_VAL *val )
 108 {
 109         return val->data_type;
 110 }
 111
 112 /**********************************************************************
 113  *********************************************************************/
 114
 115 char *reg_key_name( REG_KEY *key )
 116 {
 117         return key->name;
 118 }
 119
 120 REG_KEY *reg_key_dup(REG_KEY *key)
 121 {
 122         key->ref++;
 123         return key;
 124 }
 125
 126 void reg_key_free(REG_KEY *key)
 127 {
 128         if(!key)
 129                 return;
 130
 131         key->ref--;
 132         if(key->ref) return;
 133
 134         if(key->handle->functions->free_key_backend_data)
 135                 key->handle->functions->free_key_backend_data(key);
 136
 137         if(key->cache_values) {
 138                 int i;
 139                 for(i = 0; i < key->cache_values_count; i++) {
 140                         reg_val_free(key->cache_values[i]);
 141                 }
 142                 SAFE_FREE(key->cache_values);
 143         }
 144
 145         if(key->cache_subkeys) {
 146                 int i;
 147                 for(i = 0; i < key->cache_subkeys_count; i++) {
 148                         reg_key_free(key->cache_subkeys[i]);
 149                 }
 150                 SAFE_FREE(key->cache_subkeys);
 151         }
 152
 153         SAFE_FREE(key->path);
 154         SAFE_FREE(key->name);
 155         SAFE_FREE(key);
 156 }
 157
 158 char *reg_val_get_path(REG_VAL *v)
 159 {
 160         /* FIXME */
 161         return NULL;
 162 }
 163
 164 const char *reg_key_get_path(REG_KEY *k)
 165 {
 166         SMB_REG_ASSERT(k);
 167         return k->path;
 168 }
 169
 170 /* For use by the backends _ONLY_ */
 171 REG_KEY *reg_key_new_abs(const char *path, REG_HANDLE *h, void *data)
 172 {
 173         REG_KEY *r = malloc(sizeof(REG_KEY));
 174         ZERO_STRUCTP(r);
 175         r->handle = h;
 176         r->path = strdup(path);
 177         r->name = strdup(strrchr(path, '\\')?strrchr(path,'\\')+1:path);
 178         r->backend_data = data;
 179         r->ref = 1;
 180         return r;
 181 }
 182
 183 REG_KEY *reg_key_new_rel(const char *name, REG_KEY *k, void *data)
 184 {
 185         REG_KEY *r = malloc(sizeof(REG_KEY));
 186         ZERO_STRUCTP(r);
 187         r->handle = k->handle;
 188         r->name = strdup(name);
 189         r->backend_data = data;
 190         r->ref = 1;
 191         return r;
 192 }
 193
 194 REG_VAL *reg_val_new(REG_KEY *parent, void *data)
 195 {
 196         REG_VAL *r = malloc(sizeof(REG_VAL));
 197         ZERO_STRUCTP(r);
 198         r->handle = parent->handle;
 199         r->backend_data = data;
 200         r->ref = 1;
 201         return r;
 202 }