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. */
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_PRINTING, &printing_ops },
40 /***********************************************************************
41 Open the registry database and initialize the REGISTRY_HOOK cache
42 ***********************************************************************/
44 BOOL init_registry( void )
48 if ( !init_registry_db() ) {
49 DEBUG(0,("init_registry: failed to initialize the registry tdb!\n"));
53 /* build the cache tree of registry hooks */
57 for ( i=0; reg_hooks[i].keyname; i++ ) {
58 if ( !reghook_cache_add(®_hooks[i]) )
62 if ( DEBUGLEVEL >= 20 )
63 reghook_dump_cache(20);
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 );
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 );
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 )
106 if ( key->hook && key->hook->ops && key->hook->ops->subkey_fn )
107 result = key->hook->ops->subkey_fn( key->name, subkey_ctr );
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 static REGSUBKEY_CTR ctr;
120 static pstring save_path;
121 static BOOL ctr_init = False;
126 /* simple caching for performance; very basic heuristic */
129 DEBUG(8,("fetch_reg_keys_specific: Initializing cache of subkeys for [%s]\n", key->name));
130 ZERO_STRUCTP( &ctr );
131 regsubkey_ctr_init( &ctr );
133 pstrcpy( save_path, key->name );
135 if ( fetch_reg_keys( key, &ctr) == -1 )
140 /* clear the cache when key_index == 0 or the path has changed */
141 else if ( !key_index || StrCaseCmp( save_path, key->name) ) {
143 DEBUG(8,("fetch_reg_keys_specific: Updating cache of subkeys for [%s]\n", key->name));
145 regsubkey_ctr_destroy( &ctr );
146 regsubkey_ctr_init( &ctr );
148 pstrcpy( save_path, key->name );
150 if ( fetch_reg_keys( key, &ctr) == -1 )
154 if ( !(s = regsubkey_ctr_specific_key( &ctr, key_index )) )
157 *subkey = strdup( s );
163 /***********************************************************************
164 High level wrapper function for enumerating registry values
165 Initialize the TALLOC_CTX if necessary
166 ***********************************************************************/
168 int fetch_reg_values( REGISTRY_KEY *key, REGVAL_CTR *val )
172 if ( key->hook && key->hook->ops && key->hook->ops->value_fn )
173 result = key->hook->ops->value_fn( key->name, val );
179 /***********************************************************************
180 retreive a specific subkey specified by index. Caller is
181 responsible for freeing memory
182 ***********************************************************************/
184 BOOL fetch_reg_values_specific( REGISTRY_KEY *key, REGISTRY_VALUE **val, uint32 val_index )
186 static REGVAL_CTR ctr;
187 static pstring save_path;
188 static BOOL ctr_init = False;
193 /* simple caching for performance; very basic heuristic */
196 DEBUG(8,("fetch_reg_values_specific: Initializing cache of values for [%s]\n", key->name));
198 ZERO_STRUCTP( &ctr );
199 regval_ctr_init( &ctr );
201 pstrcpy( save_path, key->name );
203 if ( fetch_reg_values( key, &ctr) == -1 )
208 /* clear the cache when val_index == 0 or the path has changed */
209 else if ( !val_index || StrCaseCmp(save_path, key->name) ) {
211 DEBUG(8,("fetch_reg_values_specific: Updating cache of values for [%s]\n", key->name));
213 regval_ctr_destroy( &ctr );
214 regval_ctr_init( &ctr );
216 pstrcpy( save_path, key->name );
218 if ( fetch_reg_values( key, &ctr) == -1 )
222 if ( !(v = regval_ctr_specific_value( &ctr, val_index )) )
225 *val = dup_registry_value( v );
230 /***********************************************************************
231 Utility function for splitting the base path of a registry path off
232 by setting base and new_path to the apprapriate offsets withing the
235 WARNING!! Does modify the original string!
236 ***********************************************************************/
238 BOOL reg_split_path( char *path, char **base, char **new_path )
242 *new_path = *base = NULL;
249 p = strchr( path, '\\' );