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