2 * Unix SMB/CIFS implementation.
3 * RPC Pipe client / server routines
4 * Copyright (C) Gerald Carter 2002.
5 * Copyright (C) Jelmer Vernooij 2003-2004.
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.
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.
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.
22 /* Implementation of registry frontend view functions. */
25 #include "lib/registry/common/registry.h"
28 #define DBGC_CLASS DBGC_RPC_SRV
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 **********************************************************************/
35 REG_VAL* reg_val_dup( REG_VAL *val )
42 if ( !(copy = malloc( sizeof(REG_VAL) )) ) {
43 DEBUG(0,("dup_registry_value: malloc() failed!\n"));
47 /* copy all the non-pointer initial data */
49 memcpy( copy, val, sizeof(REG_VAL) );
52 if ( !(copy->data_blk = memdup( val->data_blk, val->data_len )) ) {
53 DEBUG(0,("dup_registry_value: memdup() failed for [%d] bytes!\n",
62 /**********************************************************************
63 free the memory allocated to a REG_VAL
64 *********************************************************************/
66 void reg_val_free( REG_VAL *val )
71 if(val->handle->functions->free_val_backend_data)
72 val->handle->functions->free_val_backend_data(val);
74 SAFE_FREE( val->data_blk );
80 /**********************************************************************
81 *********************************************************************/
83 uint8* reg_val_data_blk( REG_VAL *val )
88 /**********************************************************************
89 *********************************************************************/
91 int reg_val_size( REG_VAL *val )
96 /**********************************************************************
97 *********************************************************************/
99 char *reg_val_name( REG_VAL *val )
104 /**********************************************************************
105 *********************************************************************/
107 uint32 reg_val_type( REG_VAL *val )
109 return val->data_type;
112 /**********************************************************************
113 *********************************************************************/
115 char *reg_key_name( REG_KEY *key )
120 REG_KEY *reg_key_dup(REG_KEY *key)
126 void reg_key_free(REG_KEY *key)
134 if(key->handle->functions->free_key_backend_data)
135 key->handle->functions->free_key_backend_data(key);
137 if(key->cache_values) {
139 for(i = 0; i < key->cache_values_count; i++) {
140 reg_val_free(key->cache_values[i]);
142 SAFE_FREE(key->cache_values);
145 if(key->cache_subkeys) {
147 for(i = 0; i < key->cache_subkeys_count; i++) {
148 reg_key_free(key->cache_subkeys[i]);
150 SAFE_FREE(key->cache_subkeys);
153 SAFE_FREE(key->path);
154 SAFE_FREE(key->name);
158 char *reg_val_get_path(REG_VAL *v)
164 char *reg_key_get_path(REG_KEY *k)
170 /* For use by the backends _ONLY_ */
171 REG_KEY *reg_key_new_abs(const char *path, REG_HANDLE *h, void *data)
173 REG_KEY *r = malloc(sizeof(REG_KEY));
176 r->path = strdup(path);
177 r->name = strdup(strrchr(path, '\\')?strrchr(path,'\\')+1:path);
178 r->backend_data = data;
183 REG_KEY *reg_key_new_rel(const char *name, REG_KEY *k, void *data)
185 REG_KEY *r = malloc(sizeof(REG_KEY));
187 r->handle = k->handle;
188 r->name = strdup(name);
189 r->backend_data = data;
194 REG_VAL *reg_val_new(REG_KEY *parent, void *data)
196 REG_VAL *r = malloc(sizeof(REG_VAL));
198 r->handle = parent->handle;
199 r->backend_data = data;