fixed seg fault in registry frontend caused by trying to
[Samba.git] / source / registry / reg_frontend.c
blob6090245096490a44836d1f05d093e38723241e2c
1 /*
2 * Unix SMB/CIFS implementation.
3 * RPC Pipe client / server routines
4 * Copyright (C) Gerald Carter 2002.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 /* Implementation of registry frontend view functions. */
23 #include "includes.h"
25 #undef DBGC_CLASS
26 #define DBGC_CLASS DBGC_RPC_SRV
28 extern REGISTRY_OPS printing_ops;
29 extern REGISTRY_OPS regdb_ops; /* these are the default */
31 /* array of REGISTRY_HOOK's which are read into a tree for easy access */
34 REGISTRY_HOOK reg_hooks[] = {
35 { KEY_TREE_ROOT, &regdb_ops },
36 { KEY_PRINTING, &printing_ops },
37 { NULL, NULL }
41 /***********************************************************************
42 Open the registry database and initialize the REGISTRY_HOOK cache
43 ***********************************************************************/
45 BOOL init_registry( void )
47 int i;
49 if ( !init_registry_db() ) {
50 DEBUG(0,("init_registry: failed to initialize the registry tdb!\n"));
51 return False;
54 /* build the cache tree of registry hooks */
56 reghook_cache_init();
58 for ( i=0; reg_hooks[i].keyname; i++ ) {
59 if ( !reghook_cache_add(&reg_hooks[i]) )
60 return False;
63 reghook_dump_cache(20);
65 return True;
71 /***********************************************************************
72 High level wrapper function for storing registry subkeys
73 ***********************************************************************/
75 BOOL store_reg_keys( REGISTRY_KEY *key, REGSUBKEY_CTR *subkeys )
77 if ( key->hook && key->hook->ops && key->hook->ops->store_subkeys_fn )
78 return key->hook->ops->store_subkeys_fn( key->name, subkeys );
79 else
80 return False;
84 /***********************************************************************
85 High level wrapper function for storing registry values
86 ***********************************************************************/
88 BOOL store_reg_values( REGISTRY_KEY *key, REGVAL_CTR *val )
90 if ( key->hook && key->hook->ops && key->hook->ops->store_values_fn )
91 return key->hook->ops->store_values_fn( key->name, val );
92 else
93 return False;
97 /***********************************************************************
98 High level wrapper function for enumerating registry subkeys
99 Initialize the TALLOC_CTX if necessary
100 ***********************************************************************/
102 int fetch_reg_keys( REGISTRY_KEY *key, REGSUBKEY_CTR *subkey_ctr )
104 int result = -1;
106 if ( key->hook && key->hook->ops && key->hook->ops->subkey_fn )
107 result = key->hook->ops->subkey_fn( key->name, subkey_ctr );
109 return result;
112 /***********************************************************************
113 retreive a specific subkey specified by index. Caller is
114 responsible for freeing memory
115 ***********************************************************************/
117 BOOL fetch_reg_keys_specific( REGISTRY_KEY *key, char** subkey, uint32 key_index )
119 char *s;
120 REGSUBKEY_CTR ctr;
122 ZERO_STRUCTP( &ctr );
124 regsubkey_ctr_init( &ctr );
126 if ( fetch_reg_keys( key, &ctr) == -1 )
127 return False;
129 if ( !(s = regsubkey_ctr_specific_key( &ctr, key_index )) )
130 return False;
132 *subkey = strdup( s );
134 regsubkey_ctr_destroy( &ctr );
136 return True;
140 /***********************************************************************
141 High level wrapper function for enumerating registry values
142 Initialize the TALLOC_CTX if necessary
143 ***********************************************************************/
145 int fetch_reg_values( REGISTRY_KEY *key, REGVAL_CTR *val )
147 int result = -1;
149 if ( key->hook && key->hook->ops && key->hook->ops->value_fn )
150 result = key->hook->ops->value_fn( key->name, val );
152 return result;
155 /***********************************************************************
156 Utility function for splitting the base path of a registry path off
157 by setting base and new_path to the apprapriate offsets withing the
158 path.
160 WARNING!! Does modify the original string!
161 ***********************************************************************/
163 BOOL reg_split_path( char *path, char **base, char **new_path )
165 char *p;
167 *new_path = *base = NULL;
169 if ( !path)
170 return False;
172 *base = path;
174 p = strchr( path, '\\' );
176 if ( p ) {
177 *p = '\0';
178 *new_path = p+1;
181 return True;
186 * Utility functions for REGSUBKEY_CTR
189 /***********************************************************************
190 Init the talloc context held by a REGSUBKEY_CTR structure
191 **********************************************************************/
193 void regsubkey_ctr_init( REGSUBKEY_CTR *ctr )
195 if ( !ctr->ctx )
196 ctr->ctx = talloc_init();
199 /***********************************************************************
200 Add a new key to the array
201 **********************************************************************/
203 int regsubkey_ctr_addkey( REGSUBKEY_CTR *ctr, char *keyname )
205 uint32 len;
207 if ( keyname )
209 len = strlen( keyname );
211 if ( ctr->subkeys == 0 )
212 ctr->subkeys = talloc( ctr->ctx, 1 );
213 else
214 talloc_realloc( ctr->ctx, ctr->subkeys, ctr->num_subkeys+1 );
216 ctr->subkeys[ctr->num_subkeys] = talloc( ctr->ctx, len+1 );
217 strncpy( ctr->subkeys[ctr->num_subkeys], keyname, len+1 );
218 ctr->num_subkeys++;
221 return ctr->num_subkeys;
224 /***********************************************************************
225 How many keys does the container hold ?
226 **********************************************************************/
228 int regsubkey_ctr_numkeys( REGSUBKEY_CTR *ctr )
230 return ctr->num_subkeys;
233 /***********************************************************************
234 Retreive a specific key string
235 **********************************************************************/
237 char* regsubkey_ctr_specific_key( REGSUBKEY_CTR *ctr, uint32 key_index )
239 if ( ! (key_index < ctr->num_subkeys) )
240 return NULL;
242 return ctr->subkeys[key_index];
245 /***********************************************************************
246 free memory held by a REGSUBKEY_CTR structure
247 **********************************************************************/
249 void regsubkey_ctr_destroy( REGSUBKEY_CTR *ctr )
251 if ( ctr ) {
252 talloc_destroy( ctr->ctx );
253 ZERO_STRUCTP( ctr );
259 * Utility functions for REGVAL_CTR
262 /***********************************************************************
263 Init the talloc context held by a REGSUBKEY_CTR structure
264 **********************************************************************/
266 void regval_ctr_init( REGVAL_CTR *ctr )
268 if ( !ctr->ctx )
269 ctr->ctx = talloc_init();
272 /***********************************************************************
273 How many keys does the container hold ?
274 **********************************************************************/
276 int regval_ctr_numvals( REGVAL_CTR *ctr )
278 return ctr->num_values;
281 /***********************************************************************
282 free memory held by a REGVAL_CTR structure
283 **********************************************************************/
285 void regval_ctr_destroy( REGVAL_CTR *ctr )
287 if ( ctr ) {
288 talloc_destroy( ctr->ctx );
289 ZERO_STRUCTP( ctr );