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         val->ref++;
  38         return val;
  39 }
  40
  41 /**********************************************************************
  42  free the memory allocated to a REG_VAL
  43  *********************************************************************/
  44
  45 void reg_val_free( REG_VAL *val )
  46 {
  47         if ( !val )
  48                 return;
  49
  50         if(val->handle->functions->free_val_backend_data)
  51                 val->handle->functions->free_val_backend_data(val);
  52
  53         talloc_destroy( val->mem_ctx );
  54
  55         return;
  56 }
  57
  58 /**********************************************************************
  59  *********************************************************************/
  60
  61 uint8* reg_val_data_blk( REG_VAL *val )
  62 {
  63         return val->data_blk;
  64 }
  65
  66 /**********************************************************************
  67  *********************************************************************/
  68
  69 int reg_val_size( REG_VAL *val )
  70 {
  71         return val->data_len;
  72 }
  73
  74 /**********************************************************************
  75  *********************************************************************/
  76
  77 char *reg_val_name( REG_VAL *val )
  78 {
  79         return val->name;
  80 }
  81
  82 /**********************************************************************
  83  *********************************************************************/
  84
  85 uint32 reg_val_type( REG_VAL *val )
  86 {
  87         return val->data_type;
  88 }
  89
  90 /**********************************************************************
  91  *********************************************************************/
  92
  93 char *reg_key_name( REG_KEY *key )
  94 {
  95         return key->name;
  96 }
  97
  98 REG_KEY *reg_key_dup(REG_KEY *key)
  99 {
 100         key->ref++;
 101         return key;
 102 }
 103
 104 void reg_key_free(REG_KEY *key)
 105 {
 106         if(!key)
 107                 return;
 108
 109         key->ref--;
 110         if(key->ref) return;
 111
 112         if(key->handle->functions->free_key_backend_data)
 113                 key->handle->functions->free_key_backend_data(key);
 114
 115         if(key->cache_values) {
 116                 int i;
 117                 for(i = 0; i < key->cache_values_count; i++) {
 118                         reg_val_free(key->cache_values[i]);
 119                 }
 120         }
 121
 122         if(key->cache_subkeys) {
 123                 int i;
 124                 for(i = 0; i < key->cache_subkeys_count; i++) {
 125                         reg_key_free(key->cache_subkeys[i]);
 126                 }
 127         }
 128
 129         talloc_destroy(key->mem_ctx);
 130 }
 131
 132 char *reg_val_get_path(REG_VAL *v)
 133 {
 134         /* FIXME */
 135         return NULL;
 136 }
 137
 138 const char *reg_key_get_path(REG_KEY *k)
 139 {
 140         SMB_REG_ASSERT(k);
 141         return k->path;
 142 }
 143
 144 /* For use by the backends _ONLY_ */
 145 REG_KEY *reg_key_new_abs(const char *path, REG_HANDLE *h, void *data)
 146 {
 147         REG_KEY *r;
 148         TALLOC_CTX *mem_ctx = talloc_init(path);
 149         r = talloc(mem_ctx, sizeof(REG_KEY));
 150         ZERO_STRUCTP(r);
 151         r->handle = h;
 152         r->mem_ctx = mem_ctx;
 153         r->path = talloc_strdup(mem_ctx, path);
 154         r->name = talloc_strdup(mem_ctx, strrchr(path, '\\')?strrchr(path,'\\')+1:path);
 155         r->backend_data = data;
 156         r->ref = 1;
 157         return r;
 158 }
 159
 160 REG_KEY *reg_key_new_rel(const char *name, REG_KEY *k, void *data)
 161 {
 162         REG_KEY *r;
 163         TALLOC_CTX *mem_ctx = talloc_init(name);
 164         r = talloc(mem_ctx, sizeof(REG_KEY));
 165         ZERO_STRUCTP(r);
 166         r->handle = k->handle;
 167         r->name = talloc_strdup(mem_ctx, name);
 168         r->backend_data = data;
 169         r->mem_ctx = mem_ctx;
 170         r->ref = 1;
 171         return r;
 172 }
 173
 174 REG_VAL *reg_val_new(REG_KEY *parent, void *data)
 175 {
 176         REG_VAL *r;
 177         TALLOC_CTX *mem_ctx = talloc_init("value");
 178         r = talloc(mem_ctx, sizeof(REG_VAL));
 179         ZERO_STRUCTP(r);
 180         r->mem_ctx = mem_ctx;
 181         r->handle = parent->handle;
 182         r->backend_data = data;
 183         r->ref = 1;
 184         return r;
 185 }