source: trunk-3.0/source/registry/reg_objects.c@ 101

Last change on this file since 101 was 39, checked in by Paul Smedley, 18 years ago

Upgrade source to 3.0.25a
File size: 12.2 KB
Line 
1/*
2 * Unix SMB/CIFS implementation.
3 * Virtual Windows Registry Layer
4 * Copyright (C) Gerald Carter 2002-2005
5 *
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.
10 *
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.
15 *
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.
19 */
20
21/* Implementation of registry frontend view functions. */
22
23#include "includes.h"
24
25#undef DBGC_CLASS
26#define DBGC_CLASS DBGC_RPC_SRV
27
28/**********************************************************************
29
30 Note that the REGSUB_CTR and REGVAL_CTR objects *must* be talloc()'d
31 since the methods use the object pointer as the talloc context for
32 internal private data.
33
34 There is no longer a regXXX_ctr_intit() and regXXX_ctr_destroy()
35 pair of functions. Simply TALLOC_ZERO_P() and TALLOC_FREE() the
36 object.
37
38 **********************************************************************/
39
40/***********************************************************************
41 Add a new key to the array
42 **********************************************************************/
43
44int regsubkey_ctr_addkey( REGSUBKEY_CTR *ctr, const char *keyname )
45{
46 if ( !keyname )
47 return ctr->num_subkeys;
48
49 /* make sure the keyname is not already there */
50
51 if ( regsubkey_ctr_key_exists( ctr, keyname ) )
52 return ctr->num_subkeys;
53
54 /* allocate a space for the char* in the array */
55
56 if (ctr->subkeys == NULL) {
57 ctr->subkeys = TALLOC_P(ctr, char *);
58 } else {
59 ctr->subkeys = TALLOC_REALLOC_ARRAY(ctr, ctr->subkeys, char *, ctr->num_subkeys+1);
60 }
61
62 if (!ctr->subkeys) {
63 ctr->num_subkeys = 0;
64 return 0;
65 }
66
67 /* allocate the string and save it in the array */
68
69 ctr->subkeys[ctr->num_subkeys] = talloc_strdup( ctr, keyname );
70 ctr->num_subkeys++;
71
72 return ctr->num_subkeys;
73}
74
75 /***********************************************************************
76 Add a new key to the array
77 **********************************************************************/
78
79int regsubkey_ctr_delkey( REGSUBKEY_CTR *ctr, const char *keyname )
80{
81 int i;
82
83 if ( !keyname )
84 return ctr->num_subkeys;
85
86 /* make sure the keyname is actually already there */
87
88 for ( i=0; i<ctr->num_subkeys; i++ ) {
89 if ( strequal( ctr->subkeys[i], keyname ) )
90 break;
91 }
92
93 if ( i == ctr->num_subkeys )
94 return ctr->num_subkeys;
95
96 /* update if we have any keys left */
97 ctr->num_subkeys--;
98 if ( i < ctr->num_subkeys )
99 memmove( &ctr->subkeys[i], &ctr->subkeys[i+1], sizeof(char*) * (ctr->num_subkeys-i) );
100
101 return ctr->num_subkeys;
102}
103
104/***********************************************************************
105 Check for the existance of a key
106 **********************************************************************/
107
108BOOL regsubkey_ctr_key_exists( REGSUBKEY_CTR *ctr, const char *keyname )
109{
110 int i;
111
112 if (!ctr->subkeys) {
113 return False;
114 }
115
116 for ( i=0; i<ctr->num_subkeys; i++ ) {
117 if ( strequal( ctr->subkeys[i],keyname ) )
118 return True;
119 }
120
121 return False;
122}
123
124/***********************************************************************
125 How many keys does the container hold ?
126 **********************************************************************/
127
128int regsubkey_ctr_numkeys( REGSUBKEY_CTR *ctr )
129{
130 return ctr->num_subkeys;
131}
132
133/***********************************************************************
134 Retreive a specific key string
135 **********************************************************************/
136
137char* regsubkey_ctr_specific_key( REGSUBKEY_CTR *ctr, uint32 key_index )
138{
139 if ( ! (key_index < ctr->num_subkeys) )
140 return NULL;
141
142 return ctr->subkeys[key_index];
143}
144
145/*
146 * Utility functions for REGVAL_CTR
147 */
148
149/***********************************************************************
150 How many keys does the container hold ?
151 **********************************************************************/
152
153int regval_ctr_numvals( REGVAL_CTR *ctr )
154{
155 return ctr->num_values;
156}
157
158/***********************************************************************
159 allocate memory for and duplicate a REGISTRY_VALUE.
160 This is malloc'd memory so the caller should free it when done
161 **********************************************************************/
162
163REGISTRY_VALUE* dup_registry_value( REGISTRY_VALUE *val )
164{
165 REGISTRY_VALUE *copy = NULL;
166
167 if ( !val )
168 return NULL;
169
170 if ( !(copy = SMB_MALLOC_P( REGISTRY_VALUE)) ) {
171 DEBUG(0,("dup_registry_value: malloc() failed!\n"));
172 return NULL;
173 }
174
175 /* copy all the non-pointer initial data */
176
177 memcpy( copy, val, sizeof(REGISTRY_VALUE) );
178
179 copy->size = 0;
180 copy->data_p = NULL;
181
182 if ( val->data_p && val->size )
183 {
184 if ( !(copy->data_p = (uint8 *)memdup( val->data_p,
185 val->size )) ) {
186 DEBUG(0,("dup_registry_value: memdup() failed for [%d] bytes!\n",
187 val->size));
188 SAFE_FREE( copy );
189 return NULL;
190 }
191 copy->size = val->size;
192 }
193
194 return copy;
195}
196
197/**********************************************************************
198 free the memory allocated to a REGISTRY_VALUE
199 *********************************************************************/
200
201void free_registry_value( REGISTRY_VALUE *val )
202{
203 if ( !val )
204 return;
205
206 SAFE_FREE( val->data_p );
207 SAFE_FREE( val );
208
209 return;
210}
211
212/**********************************************************************
213 *********************************************************************/
214
215uint8* regval_data_p( REGISTRY_VALUE *val )
216{
217 return val->data_p;
218}
219
220/**********************************************************************
221 *********************************************************************/
222
223uint32 regval_size( REGISTRY_VALUE *val )
224{
225 return val->size;
226}
227
228/**********************************************************************
229 *********************************************************************/
230
231char* regval_name( REGISTRY_VALUE *val )
232{
233 return val->valuename;
234}
235
236/**********************************************************************
237 *********************************************************************/
238
239uint32 regval_type( REGISTRY_VALUE *val )
240{
241 return val->type;
242}
243
244/***********************************************************************
245 Retreive a pointer to a specific value. Caller shoud dup the structure
246 since this memory will go away when the ctr is free()'d
247 **********************************************************************/
248
249REGISTRY_VALUE* regval_ctr_specific_value( REGVAL_CTR *ctr, uint32 idx )
250{
251 if ( !(idx < ctr->num_values) )
252 return NULL;
253
254 return ctr->values[idx];
255}
256
257/***********************************************************************
258 Check for the existance of a value
259 **********************************************************************/
260
261BOOL regval_ctr_key_exists( REGVAL_CTR *ctr, const char *value )
262{
263 int i;
264
265 for ( i=0; i<ctr->num_values; i++ ) {
266 if ( strequal( ctr->values[i]->valuename, value) )
267 return True;
268 }
269
270 return False;
271}
272/***********************************************************************
273 Add a new registry value to the array
274 **********************************************************************/
275
276int regval_ctr_addvalue( REGVAL_CTR *ctr, const char *name, uint16 type,
277 const char *data_p, size_t size )
278{
279 if ( !name )
280 return ctr->num_values;
281
282 /* Delete the current value (if it exists) and add the new one */
283
284 regval_ctr_delvalue( ctr, name );
285
286 /* allocate a slot in the array of pointers */
287
288 if ( ctr->num_values == 0 ) {
289 ctr->values = TALLOC_P( ctr, REGISTRY_VALUE *);
290 } else {
291 ctr->values = TALLOC_REALLOC_ARRAY( ctr, ctr->values, REGISTRY_VALUE *, ctr->num_values+1 );
292 }
293
294 if (!ctr->values) {
295 ctr->num_values = 0;
296 return 0;
297 }
298
299 /* allocate a new value and store the pointer in the arrya */
300
301 ctr->values[ctr->num_values] = TALLOC_P( ctr, REGISTRY_VALUE);
302 if (!ctr->values[ctr->num_values]) {
303 ctr->num_values = 0;
304 return 0;
305 }
306
307 /* init the value */
308
309 fstrcpy( ctr->values[ctr->num_values]->valuename, name );
310 ctr->values[ctr->num_values]->type = type;
311 if (size) {
312 ctr->values[ctr->num_values]->data_p = (uint8 *)TALLOC_MEMDUP(
313 ctr, data_p, size );
314 if (!ctr->values[ctr->num_values]->data_p) {
315 ctr->num_values = 0;
316 return 0;
317 }
318 } else {
319 ctr->values[ctr->num_values]->data_p = NULL;
320 }
321 ctr->values[ctr->num_values]->size = size;
322 ctr->num_values++;
323
324 return ctr->num_values;
325}
326
327/***********************************************************************
328 Add a new registry value to the array
329 **********************************************************************/
330
331int regval_ctr_copyvalue( REGVAL_CTR *ctr, REGISTRY_VALUE *val )
332{
333 if ( val ) {
334 /* allocate a slot in the array of pointers */
335
336 if ( ctr->num_values == 0 ) {
337 ctr->values = TALLOC_P( ctr, REGISTRY_VALUE *);
338 } else {
339 ctr->values = TALLOC_REALLOC_ARRAY( ctr, ctr->values, REGISTRY_VALUE *, ctr->num_values+1 );
340 }
341
342 if (!ctr->values) {
343 ctr->num_values = 0;
344 return 0;
345 }
346
347 /* allocate a new value and store the pointer in the arrya */
348
349 ctr->values[ctr->num_values] = TALLOC_P( ctr, REGISTRY_VALUE);
350 if (!ctr->values[ctr->num_values]) {
351 ctr->num_values = 0;
352 return 0;
353 }
354
355 /* init the value */
356
357 fstrcpy( ctr->values[ctr->num_values]->valuename, val->valuename );
358 ctr->values[ctr->num_values]->type = val->type;
359 if (val->size) {
360 ctr->values[ctr->num_values]->data_p = (uint8 *)TALLOC_MEMDUP(
361 ctr, val->data_p, val->size );
362 if (!ctr->values[ctr->num_values]->data_p) {
363 ctr->num_values = 0;
364 return 0;
365 }
366 } else {
367 ctr->values[ctr->num_values]->data_p = NULL;
368 }
369 ctr->values[ctr->num_values]->size = val->size;
370 ctr->num_values++;
371 }
372
373 return ctr->num_values;
374}
375
376/***********************************************************************
377 Delete a single value from the registry container.
378 No need to free memory since it is talloc'd.
379 **********************************************************************/
380
381int regval_ctr_delvalue( REGVAL_CTR *ctr, const char *name )
382{
383 int i;
384
385 for ( i=0; i<ctr->num_values; i++ ) {
386 if ( strequal( ctr->values[i]->valuename, name ) )
387 break;
388 }
389
390 /* just return if we don't find it */
391
392 if ( i == ctr->num_values )
393 return ctr->num_values;
394
395 /* If 'i' was not the last element, just shift everything down one */
396 ctr->num_values--;
397 if ( i < ctr->num_values )
398 memmove( &ctr->values[i], &ctr->values[i+1], sizeof(REGISTRY_VALUE*)*(ctr->num_values-i) );
399
400 return ctr->num_values;
401}
402
403/***********************************************************************
404 Retrieve single value from the registry container.
405 No need to free memory since it is talloc'd.
406 **********************************************************************/
407
408REGISTRY_VALUE* regval_ctr_getvalue( REGVAL_CTR *ctr, const char *name )
409{
410 int i;
411
412 /* search for the value */
413
414 for ( i=0; i<ctr->num_values; i++ ) {
415 if ( strequal( ctr->values[i]->valuename, name ) )
416 return ctr->values[i];
417 }
418
419 return NULL;
420}
421
422/***********************************************************************
423 return the data_p as a uint32
424 **********************************************************************/
425
426uint32 regval_dword( REGISTRY_VALUE *val )
427{
428 uint32 data;
429
430 data = IVAL( regval_data_p(val), 0 );
431
432 return data;
433}
434
435/***********************************************************************
436 return the data_p as a character string
437 **********************************************************************/
438
439char* regval_sz( REGISTRY_VALUE *val )
440{
441 static pstring data;
442
443 rpcstr_pull( data, regval_data_p(val), sizeof(data), regval_size(val), 0 );
444
445 return data;
446}
Note: See TracBrowser for help on using the repository browser.