be15108f4d958d9863fa34f421c3018e740cde11
[gd/samba-autobuild/.git] / source4 / 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         val->ref--;
51         if(val->ref) return;
52
53         if(val->handle->functions->free_val_backend_data)
54                 val->handle->functions->free_val_backend_data(val);
55                 
56         talloc_destroy( val->mem_ctx );
57
58         return;
59 }
60
61 /**********************************************************************
62  *********************************************************************/
63
64 uint8* reg_val_data_blk( REG_VAL *val )
65 {
66         return val->data_blk;
67 }
68
69 /**********************************************************************
70  *********************************************************************/
71
72 int reg_val_size( REG_VAL *val )
73 {
74         return val->data_len;
75 }
76
77 /**********************************************************************
78  *********************************************************************/
79
80 char *reg_val_name( REG_VAL *val )
81 {
82         return val->name;
83 }
84
85 /**********************************************************************
86  *********************************************************************/
87
88 uint32_t reg_val_type( REG_VAL *val )
89 {
90         return val->data_type;
91 }
92
93 /**********************************************************************
94  *********************************************************************/
95
96 REG_HANDLE *reg_key_handle (REG_KEY *key) 
97 {
98         return key->handle;
99 }
100
101 char *reg_key_name( REG_KEY *key )
102 {
103         return key->name;
104 }
105
106 REG_KEY *reg_key_dup(REG_KEY *key)
107 {
108         key->ref++;
109         return key;
110 }
111
112 void reg_key_free(REG_KEY *key)
113 {
114         if(!key)
115                 return;
116         
117         key->ref--;
118         if(key->ref) return;
119         
120         if(key->handle->functions->free_key_backend_data)
121                 key->handle->functions->free_key_backend_data(key);
122
123         if(key->cache_values) {
124                 int i;
125                 for(i = 0; i < key->cache_values_count; i++) {
126                         reg_val_free(key->cache_values[i]);
127                 }
128         }
129
130         if(key->cache_subkeys) {
131                 int i;
132                 for(i = 0; i < key->cache_subkeys_count; i++) {
133                         reg_key_free(key->cache_subkeys[i]);
134                 }
135         }
136
137         talloc_destroy(key->mem_ctx);
138 }
139
140 char *reg_val_get_path(REG_VAL *v)
141 {
142         /* FIXME */
143         return NULL;
144 }
145
146 const char *reg_key_get_path(REG_KEY *k)
147 {
148         SMB_REG_ASSERT(k);
149         return strchr(k->path, '\\')?strchr(k->path, '\\')+1:"";
150 }
151
152 const char *reg_key_get_path_abs(REG_KEY *k)
153 {
154         SMB_REG_ASSERT(k);
155         return k->path;
156 }
157
158 /* For use by the backends _ONLY_ */
159 REG_KEY *reg_key_new_abs(const char *path, REG_HANDLE *h, void *data)
160 {
161         REG_KEY *r;
162         TALLOC_CTX *mem_ctx = talloc_init(path);
163         r = talloc(mem_ctx, sizeof(REG_KEY));
164         ZERO_STRUCTP(r);
165         r->handle = h;
166         r->mem_ctx = mem_ctx;
167         r->path = talloc_strdup(mem_ctx, path);
168         r->name = talloc_strdup(mem_ctx, strrchr(path, '\\')?strrchr(path,'\\')+1:path);
169         r->backend_data = data;
170         r->ref = 1;
171         return r;
172 }
173
174 REG_KEY *reg_key_new_rel(const char *name, REG_KEY *k, void *data)
175 {
176         REG_KEY *r;
177         const char *parent_path = k?reg_key_get_path(k):"";
178         TALLOC_CTX *mem_ctx = talloc_init(name);
179         r = talloc(mem_ctx, sizeof(REG_KEY));
180         ZERO_STRUCTP(r);
181         r->handle = k->handle;
182         r->hive = k->hive;
183         r->name = talloc_strdup(mem_ctx, name);
184         
185         r->path = talloc_asprintf(mem_ctx, "%s%s%s", parent_path, *parent_path && parent_path[strlen(parent_path)-1] != '\\'?"\\":"", name);
186         r->backend_data = data;
187         r->mem_ctx = mem_ctx;
188         r->ref = 1;
189         return r;
190 }
191
192 REG_VAL *reg_val_new(REG_KEY *parent, void *data)
193 {
194         REG_VAL *r;
195         TALLOC_CTX *mem_ctx = talloc_init("value");
196         r = talloc(mem_ctx, sizeof(REG_VAL));
197         ZERO_STRUCTP(r);
198         r->mem_ctx = mem_ctx;
199         r->handle = parent->handle;
200         r->backend_data = data;
201         r->ref = 1;
202         return r;
203 }