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_TREE_ROOT
, ®db_ops
},
36 { KEY_PRINTING
, &printing_ops
},
41 /***********************************************************************
42 Open the registry database and initialize the REGISTRY_HOOK cache
43 ***********************************************************************/
45 BOOL
init_registry( void )
49 if ( !init_registry_db() ) {
50 DEBUG(0,("init_registry: failed to initialize the registry tdb!\n"));
54 /* build the cache tree of registry hooks */
58 for ( i
=0; reg_hooks
[i
].keyname
; i
++ ) {
59 if ( !reghook_cache_add(®_hooks
[i
]) )
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
)
122 ZERO_STRUCTP( &ctr
);
124 regsubkey_ctr_init( &ctr
);
126 if ( fetch_reg_keys( key
, &ctr
) == -1 )
129 if ( !(s
= regsubkey_ctr_specific_key( &ctr
, key_index
)) )
132 *subkey
= strdup( s
);
134 regsubkey_ctr_destroy( &ctr
);
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
)
149 if ( key
->hook
&& key
->hook
->ops
&& key
->hook
->ops
->value_fn
)
150 result
= key
->hook
->ops
->value_fn( key
->name
, val
);
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
160 WARNING!! Does modify the original string!
161 ***********************************************************************/
163 BOOL
reg_split_path( char *path
, char **base
, char **new_path
)
167 *new_path
= *base
= NULL
;
174 p
= strchr( path
, '\\' );
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
)
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
)
209 len
= strlen( keyname
);
211 if ( ctr
->subkeys
== 0 )
212 ctr
->subkeys
= talloc( ctr
->ctx
, 1 );
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 );
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
) )
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
)
252 talloc_destroy( ctr
->ctx
);
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
)
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
)
288 talloc_destroy( ctr
->ctx
);