r169: Fix gregedit
[kai/samba.git] / source / lib / registry / common / reg_objects.c
1 /* 
2  *  Unix SMB/CIFS implementation.
3  *  RPC Pipe client / server routines
4  *  Copyright (C) Gerald Carter                     2002.
5  *  Copyright (C) Jelmer Vernooij                                       2003-2004.
6  *
7  *  This program is free software; you can redistribute it and/or modify
8  *  it under the terms of the GNU General Public License as published by
9  *  the Free Software Foundation; either version 2 of the License, or
10  *  (at your option) any later version.
11  *  
12  *  This program is distributed in the hope that it will be useful,
13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  *  GNU General Public License for more details.
16  *  
17  *  You should have received a copy of the GNU General Public License
18  *  along with this program; if not, write to the Free Software
19  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20  */
21
22 /* Implementation of registry frontend view functions. */
23
24 #include "includes.h"
25 #include "lib/registry/common/registry.h"
26
27 #undef DBGC_CLASS
28 #define DBGC_CLASS DBGC_RPC_SRV
29
30 /***********************************************************************
31  allocate memory for and duplicate a REG_VAL.
32  This is malloc'd memory so the caller should free it when done
33  **********************************************************************/
34
35 REG_VAL* reg_val_dup( REG_VAL *val )
36 {
37         val->ref++;
38         return val;     
39 }
40
41 /**********************************************************************
42  free the memory allocated to a REG_VAL 
43  *********************************************************************/
44  
45 void reg_val_free( REG_VAL *val )
46 {
47         if ( !val )
48                 return;
49
50         if(val->handle->functions->free_val_backend_data)
51                 val->handle->functions->free_val_backend_data(val);
52                 
53         talloc_destroy( val->mem_ctx );
54
55         return;
56 }
57
58 /**********************************************************************
59  *********************************************************************/
60
61 uint8* reg_val_data_blk( REG_VAL *val )
62 {
63         return val->data_blk;
64 }
65
66 /**********************************************************************
67  *********************************************************************/
68
69 int reg_val_size( REG_VAL *val )
70 {
71         return val->data_len;
72 }
73
74 /**********************************************************************
75  *********************************************************************/
76
77 char *reg_val_name( REG_VAL *val )
78 {
79         return val->name;
80 }
81
82 /**********************************************************************
83  *********************************************************************/
84
85 uint32 reg_val_type( REG_VAL *val )
86 {
87         return val->data_type;
88 }
89
90 /**********************************************************************
91  *********************************************************************/
92
93 char *reg_key_name( REG_KEY *key )
94 {
95         return key->name;
96 }
97
98 REG_KEY *reg_key_dup(REG_KEY *key)
99 {
100         key->ref++;
101         return key;
102 }
103
104 void reg_key_free(REG_KEY *key)
105 {
106         if(!key)
107                 return;
108         
109         key->ref--;
110         if(key->ref) return;
111         
112         if(key->handle->functions->free_key_backend_data)
113                 key->handle->functions->free_key_backend_data(key);
114
115         if(key->cache_values) {
116                 int i;
117                 for(i = 0; i < key->cache_values_count; i++) {
118                         reg_val_free(key->cache_values[i]);
119                 }
120         }
121
122         if(key->cache_subkeys) {
123                 int i;
124                 for(i = 0; i < key->cache_subkeys_count; i++) {
125                         reg_key_free(key->cache_subkeys[i]);
126                 }
127         }
128
129         talloc_destroy(key->mem_ctx);
130 }
131
132 char *reg_val_get_path(REG_VAL *v)
133 {
134         /* FIXME */
135         return NULL;
136 }
137
138 const char *reg_key_get_path(REG_KEY *k)
139 {
140         SMB_REG_ASSERT(k);
141         return k->path;
142 }
143
144 /* For use by the backends _ONLY_ */
145 REG_KEY *reg_key_new_abs(const char *path, REG_HANDLE *h, void *data)
146 {
147         REG_KEY *r;
148         TALLOC_CTX *mem_ctx = talloc_init(path);
149         r = talloc(mem_ctx, sizeof(REG_KEY));
150         ZERO_STRUCTP(r);
151         r->handle = h;
152         r->mem_ctx = mem_ctx;
153         r->path = talloc_strdup(mem_ctx, path);
154         r->name = talloc_strdup(mem_ctx, strrchr(path, '\\')?strrchr(path,'\\')+1:path);
155         r->backend_data = data;
156         r->ref = 1;
157         return r;
158 }
159
160 REG_KEY *reg_key_new_rel(const char *name, REG_KEY *k, void *data)
161 {
162         REG_KEY *r;
163         TALLOC_CTX *mem_ctx = talloc_init(name);
164         r = talloc(mem_ctx, sizeof(REG_KEY));
165         ZERO_STRUCTP(r);
166         r->handle = k->handle;
167         r->name = talloc_strdup(mem_ctx, name);
168         r->backend_data = data;
169         r->mem_ctx = mem_ctx;
170         r->ref = 1;
171         return r;
172 }
173
174 REG_VAL *reg_val_new(REG_KEY *parent, void *data)
175 {
176         REG_VAL *r;
177         TALLOC_CTX *mem_ctx = talloc_init("value");
178         r = talloc(mem_ctx, sizeof(REG_VAL));
179         ZERO_STRUCTP(r);
180         r->mem_ctx = mem_ctx;
181         r->handle = parent->handle;
182         r->backend_data = data;
183         r->ref = 1;
184         return r;
185 }