import HEAD into svn+ssh://svn.samba.org/home/svn/samba/trunk
[metze/old/v3-2-winbind-ndr.git] / source / registry / reg_objects.c
1 /* 
2  *  Unix SMB/CIFS implementation.
3  *  RPC Pipe client / server routines
4  *  Copyright (C) Gerald Carter                     2002.
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  Init the talloc context held by a REGSUBKEY_CTR structure
31  **********************************************************************/
32
33 void regsubkey_ctr_init( REGSUBKEY_CTR *ctr )
34 {
35         if ( !ctr->ctx )
36                 ctr->ctx = talloc_init("regsubkey_ctr_init for ctr %p", ctr);
37 }
38
39 /***********************************************************************
40  Add a new key to the array
41  **********************************************************************/
42
43 int regsubkey_ctr_addkey( REGSUBKEY_CTR *ctr, const char *keyname )
44 {
45         uint32 len;
46         char **pp;
47         
48         if ( keyname )
49         {
50                 len = strlen( keyname );
51
52                 /* allocate a space for the char* in the array */
53                 
54                 if (  ctr->subkeys == 0 )
55                         ctr->subkeys = talloc( ctr->ctx, sizeof(char*) );
56                 else {
57                         pp = talloc_realloc( ctr->ctx, ctr->subkeys, sizeof(char*)*(ctr->num_subkeys+1) );
58                         if ( pp )
59                                 ctr->subkeys = pp;
60                 }
61
62                 /* allocate the string and save it in the array */
63                 
64                 ctr->subkeys[ctr->num_subkeys] = talloc( ctr->ctx, len+1 );
65                 strncpy( ctr->subkeys[ctr->num_subkeys], keyname, len+1 );
66                 ctr->num_subkeys++;
67         }
68         
69         return ctr->num_subkeys;
70 }
71  
72 /***********************************************************************
73  How many keys does the container hold ?
74  **********************************************************************/
75
76 int regsubkey_ctr_numkeys( REGSUBKEY_CTR *ctr )
77 {
78         return ctr->num_subkeys;
79 }
80
81 /***********************************************************************
82  Retreive a specific key string
83  **********************************************************************/
84
85 char* regsubkey_ctr_specific_key( REGSUBKEY_CTR *ctr, uint32 key_index )
86 {
87         if ( ! (key_index < ctr->num_subkeys) )
88                 return NULL;
89                 
90         return ctr->subkeys[key_index];
91 }
92
93 /***********************************************************************
94  free memory held by a REGSUBKEY_CTR structure
95  **********************************************************************/
96
97 void regsubkey_ctr_destroy( REGSUBKEY_CTR *ctr )
98 {
99         if ( ctr ) {
100                 talloc_destroy( ctr->ctx );     
101                 ZERO_STRUCTP( ctr );
102         }
103 }
104
105
106 /*
107  * Utility functions for REGVAL_CTR
108  */
109
110 /***********************************************************************
111  Init the talloc context held by a REGSUBKEY_CTR structure
112  **********************************************************************/
113
114 void regval_ctr_init( REGVAL_CTR *ctr )
115 {
116         if ( !ctr->ctx )
117                 ctr->ctx = talloc_init("regval_ctr_init for ctr %p", ctr);
118 }
119
120 /***********************************************************************
121  How many keys does the container hold ?
122  **********************************************************************/
123
124 int regval_ctr_numvals( REGVAL_CTR *ctr )
125 {
126         return ctr->num_values;
127 }
128
129 /***********************************************************************
130  allocate memory for and duplicate a REGISTRY_VALUE.
131  This is malloc'd memory so the caller should free it when done
132  **********************************************************************/
133
134 REGISTRY_VALUE* dup_registry_value( REGISTRY_VALUE *val )
135 {
136         REGISTRY_VALUE  *copy = NULL;
137         
138         if ( !val )
139                 return NULL;
140         
141         if ( !(copy = malloc( sizeof(REGISTRY_VALUE) )) ) {
142                 DEBUG(0,("dup_registry_value: malloc() failed!\n"));
143                 return NULL;
144         }
145         
146         /* copy all the non-pointer initial data */
147         
148         memcpy( copy, val, sizeof(REGISTRY_VALUE) );
149         if ( val->data_p ) 
150         {
151                 if ( !(copy->data_p = memdup( val->data_p, val->size )) ) {
152                         DEBUG(0,("dup_registry_value: memdup() failed for [%d] bytes!\n",
153                                 val->size));
154                         SAFE_FREE( copy );
155                 }
156         }
157         
158         return copy;    
159 }
160
161 /**********************************************************************
162  free the memory allocated to a REGISTRY_VALUE 
163  *********************************************************************/
164  
165 void free_registry_value( REGISTRY_VALUE *val )
166 {
167         if ( !val )
168                 return;
169                 
170         SAFE_FREE( val->data_p );
171         SAFE_FREE( val );
172         
173         return;
174 }
175
176 /**********************************************************************
177  *********************************************************************/
178
179 uint8* regval_data_p( REGISTRY_VALUE *val )
180 {
181         return val->data_p;
182 }
183
184 /**********************************************************************
185  *********************************************************************/
186
187 int regval_size( REGISTRY_VALUE *val )
188 {
189         return val->size;
190 }
191
192 /**********************************************************************
193  *********************************************************************/
194
195 char* regval_name( REGISTRY_VALUE *val )
196 {
197         return val->valuename;
198 }
199
200 /**********************************************************************
201  *********************************************************************/
202
203 uint32 regval_type( REGISTRY_VALUE *val )
204 {
205         return val->type;
206 }
207
208 /***********************************************************************
209  Retreive a pointer to a specific value.  Caller shoud dup the structure
210  since this memory may go away with a regval_ctr_destroy()
211  **********************************************************************/
212
213 REGISTRY_VALUE* regval_ctr_specific_value( REGVAL_CTR *ctr, uint32 idx )
214 {
215         if ( !(idx < ctr->num_values) )
216                 return NULL;
217                 
218         return ctr->values[idx];
219 }
220
221 /***********************************************************************
222  Retrive the TALLOC_CTX associated with a REGISTRY_VALUE 
223  **********************************************************************/
224
225 TALLOC_CTX* regval_ctr_getctx( REGVAL_CTR *val )
226 {
227         if ( !val )
228                 return NULL;
229
230         return val->ctx;
231 }
232
233 /***********************************************************************
234  Add a new registry value to the array
235  **********************************************************************/
236
237 int regval_ctr_addvalue( REGVAL_CTR *ctr, const char *name, uint16 type, 
238                          const char *data_p, size_t size )
239 {
240         REGISTRY_VALUE **ppreg;
241         
242         if ( name )
243         {
244                 /* allocate a slot in the array of pointers */
245                 
246                 if (  ctr->num_values == 0 )
247                         ctr->values = talloc( ctr->ctx, sizeof(REGISTRY_VALUE*) );
248                 else {
249                         ppreg = talloc_realloc( ctr->ctx, ctr->values, sizeof(REGISTRY_VALUE*)*(ctr->num_values+1) );
250                         if ( ppreg )
251                                 ctr->values = ppreg;
252                 }
253
254                 /* allocate a new value and store the pointer in the arrya */
255                 
256                 ctr->values[ctr->num_values] = talloc( ctr->ctx, sizeof(REGISTRY_VALUE) );
257
258                 /* init the value */
259         
260                 fstrcpy( ctr->values[ctr->num_values]->valuename, name );
261                 ctr->values[ctr->num_values]->type = type;
262                 ctr->values[ctr->num_values]->data_p = talloc_memdup( ctr->ctx, data_p, size );
263                 ctr->values[ctr->num_values]->size = size;
264                 ctr->num_values++;
265         }
266
267         return ctr->num_values;
268 }
269
270 /***********************************************************************
271  Add a new registry value to the array
272  **********************************************************************/
273
274 int regval_ctr_copyvalue( REGVAL_CTR *ctr, REGISTRY_VALUE *val )
275 {
276         REGISTRY_VALUE **ppreg;
277         
278         if ( val )
279         {
280                 /* allocate a slot in the array of pointers */
281                 
282                 if (  ctr->num_values == 0 )
283                         ctr->values = talloc( ctr->ctx, sizeof(REGISTRY_VALUE*) );
284                 else {
285                         ppreg = talloc_realloc( ctr->ctx, ctr->values, sizeof(REGISTRY_VALUE*)*(ctr->num_values+1) );
286                         if ( ppreg )
287                                 ctr->values = ppreg;
288                 }
289
290                 /* allocate a new value and store the pointer in the arrya */
291                 
292                 ctr->values[ctr->num_values] = talloc( ctr->ctx, sizeof(REGISTRY_VALUE) );
293
294                 /* init the value */
295         
296                 fstrcpy( ctr->values[ctr->num_values]->valuename, val->valuename );
297                 ctr->values[ctr->num_values]->type = val->type;
298                 ctr->values[ctr->num_values]->data_p = talloc_memdup( ctr->ctx, val->data_p, val->size );
299                 ctr->values[ctr->num_values]->size = val->size;
300                 ctr->num_values++;
301         }
302
303         return ctr->num_values;
304 }
305
306 /***********************************************************************
307  Delete a single value from the registry container.
308  No need to free memory since it is talloc'd.
309  **********************************************************************/
310
311 int regval_ctr_delvalue( REGVAL_CTR *ctr, const char *name )
312 {
313         int     i;
314         
315         /* search for the value */
316         if (!(ctr->num_values))
317                 return 0;
318         
319         for ( i=0; i<ctr->num_values; i++ ) {
320                 if ( strcmp( ctr->values[i]->valuename, name ) == 0)
321                         break;
322         }
323         
324         /* just return if we don't find it */
325         
326         if ( i == ctr->num_values )
327                 return ctr->num_values;
328         
329         /* just shift everything down one */
330         
331         for ( /* use previous i */; i<(ctr->num_values-1); i++ )
332                 memcpy( ctr->values[i], ctr->values[i+1], sizeof(REGISTRY_VALUE) );
333                 
334         /* paranoia */
335         
336         ZERO_STRUCTP( ctr->values[i] );
337         
338         ctr->num_values--;
339         
340         return ctr->num_values;
341 }
342
343 /***********************************************************************
344  Delete a single value from the registry container.
345  No need to free memory since it is talloc'd.
346  **********************************************************************/
347
348 REGISTRY_VALUE* regval_ctr_getvalue( REGVAL_CTR *ctr, const char *name )
349 {
350         int     i;
351         
352         /* search for the value */
353         
354         for ( i=0; i<ctr->num_values; i++ ) {
355                 if ( strequal( ctr->values[i]->valuename, name ) )
356                         return ctr->values[i];
357         }
358         
359         return NULL;
360 }
361
362 /***********************************************************************
363  free memory held by a REGVAL_CTR structure
364  **********************************************************************/
365
366 void regval_ctr_destroy( REGVAL_CTR *ctr )
367 {
368         if ( ctr ) {
369                 talloc_destroy( ctr->ctx );
370                 ZERO_STRUCTP( ctr );
371         }
372 }
373
374