2 Unix SMB/CIFS implementation.
3 Transparent registry backend handling
4 Copyright (C) Jelmer Vernooij 2003-2007.
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.
22 #include "lib/util/dlinklist.h"
23 #include "lib/registry/registry.h"
24 #include "system/filesys.h"
28 uint32_t predefined_key;
29 const char **elements;
32 struct registry_local {
33 struct registry_context registry;
36 struct reg_key_path path;
38 struct mountpoint *prev, *next;
41 struct auth_session_info *session_info;
42 struct cli_credentials *credentials;
46 struct registry_key global;
47 struct reg_key_path path;
48 struct hive_key *hive_key;
52 struct registry_key *reg_import_hive_key(struct registry_context *ctx,
53 struct hive_key *hive,
54 uint32_t predefined_key,
55 const char **elements)
57 struct local_key *local_key;
58 struct reg_key_path parent_path;
60 parent_path.predefined_key = predefined_key;
61 parent_path.elements = elements;
63 local_key = talloc(ctx, struct local_key);
64 local_key->hive_key = talloc_steal(local_key, hive);
65 local_key->global.context = talloc_reference(local_key, ctx);
66 local_key->path = parent_path;
68 return (struct registry_key *)local_key;
72 static WERROR local_open_key(TALLOC_CTX *mem_ctx,
73 struct registry_key *parent,
75 struct registry_key **result)
77 char *orig = talloc_strdup(mem_ctx, path),
79 *curend = strchr(orig, '\\');
80 struct local_key *local_parent = talloc_get_type(parent,
82 struct hive_key *curkey = local_parent->hive_key;
84 const char **elements = NULL;
87 if (local_parent->path.elements != NULL) {
88 elements = talloc_array(mem_ctx, const char *,
89 str_list_length(local_parent->path.elements) + 1);
90 for (el = 0; local_parent->path.elements[el] != NULL; el++) {
91 elements[el] = talloc_reference(elements,
92 local_parent->path.elements[el]);
100 while (curbegin != NULL && *curbegin) {
103 elements = talloc_realloc(mem_ctx, elements, const char *, el+2);
104 elements[el] = talloc_strdup(elements, curbegin);
107 error = hive_get_key_by_name(mem_ctx, curkey,
109 if (!W_ERROR_IS_OK(error)) {
110 DEBUG(2, ("Opening key %s failed: %s\n", curbegin,
117 curbegin = curend + 1;
118 curend = strchr(curbegin, '\\');
122 *result = reg_import_hive_key(local_parent->global.context, curkey,
123 local_parent->path.predefined_key,
124 talloc_steal(curkey, elements));
129 WERROR local_get_predefined_key(struct registry_context *ctx,
130 uint32_t key_id, struct registry_key **key)
132 struct registry_local *rctx = talloc_get_type(ctx,
133 struct registry_local);
134 struct mountpoint *mp;
136 for (mp = rctx->mountpoints; mp != NULL; mp = mp->next) {
137 if (mp->path.predefined_key == key_id &&
138 mp->path.elements == NULL)
143 return WERR_NOT_FOUND;
145 *key = reg_import_hive_key(ctx, mp->key,
146 mp->path.predefined_key,
152 static WERROR local_enum_key(TALLOC_CTX *mem_ctx,
153 const struct registry_key *key, uint32_t idx,
155 const char **keyclass,
156 NTTIME *last_changed_time)
158 const struct local_key *local = (const struct local_key *)key;
160 return hive_enum_key(mem_ctx, local->hive_key, idx, name, keyclass,
164 static WERROR local_create_key(TALLOC_CTX *mem_ctx,
165 struct registry_key *parent_key,
167 const char *key_class,
168 struct security_descriptor *security,
169 struct registry_key **key)
171 struct local_key *local_parent;
172 struct hive_key *hivekey;
173 const char **elements;
175 const char *last_part;
177 last_part = strrchr(name, '\\');
178 if (last_part == NULL) {
180 local_parent = (struct local_key *)parent_key;
182 W_ERROR_NOT_OK_RETURN(reg_open_key(mem_ctx, parent_key,
183 talloc_strndup(mem_ctx, name, last_part-name),
184 (struct registry_key **)&local_parent));
188 W_ERROR_NOT_OK_RETURN(hive_key_add_name(mem_ctx, local_parent->hive_key,
189 last_part, key_class, security,
192 if (local_parent->path.elements != NULL) {
193 elements = talloc_array(hivekey, const char *,
194 str_list_length(local_parent->path.elements)+2);
195 for (i = 0; local_parent->path.elements[i] != NULL; i++) {
196 elements[i] = talloc_reference(elements,
197 local_parent->path.elements[i]);
200 elements = talloc_array(hivekey, const char *, 2);
204 elements[i] = talloc_strdup(elements, name);
205 elements[i+1] = NULL;
207 *key = reg_import_hive_key(local_parent->global.context, hivekey,
208 local_parent->path.predefined_key,
214 static WERROR local_set_value(struct registry_key *key, const char *name,
215 uint32_t type, const DATA_BLOB data)
217 struct local_key *local = (struct local_key *)key;
219 return hive_set_value(local->hive_key, name, type, data);
222 static WERROR local_get_value(TALLOC_CTX *mem_ctx,
223 const struct registry_key *key,
224 const char *name, uint32_t *type, DATA_BLOB *data)
226 const struct local_key *local = (const struct local_key *)key;
228 return hive_get_value(mem_ctx, local->hive_key, name, type, data);
231 static WERROR local_enum_value(TALLOC_CTX *mem_ctx,
232 const struct registry_key *key, uint32_t idx,
237 const struct local_key *local = (const struct local_key *)key;
239 return hive_get_value_by_index(mem_ctx, local->hive_key, idx,
243 static WERROR local_delete_key(struct registry_key *key, const char *name)
245 const struct local_key *local = (const struct local_key *)key;
247 return hive_key_del(local->hive_key, name);
250 static WERROR local_delete_value(struct registry_key *key, const char *name)
252 const struct local_key *local = (const struct local_key *)key;
254 return hive_del_value(local->hive_key, name);
257 static WERROR local_flush_key(struct registry_key *key)
259 const struct local_key *local = (const struct local_key *)key;
261 return hive_key_flush(local->hive_key);
264 static WERROR local_get_key_info(TALLOC_CTX *mem_ctx,
265 const struct registry_key *key,
266 const char **classname,
267 uint32_t *num_subkeys,
268 uint32_t *num_values,
269 NTTIME *last_change_time)
271 const struct local_key *local = (const struct local_key *)key;
273 return hive_key_get_info(mem_ctx, local->hive_key,
274 classname, num_subkeys, num_values,
278 const static struct registry_operations local_ops = {
280 .open_key = local_open_key,
281 .get_predefined_key = local_get_predefined_key,
282 .enum_key = local_enum_key,
283 .create_key = local_create_key,
284 .set_value = local_set_value,
285 .get_value = local_get_value,
286 .enum_value = local_enum_value,
287 .delete_key = local_delete_key,
288 .delete_value = local_delete_value,
289 .flush_key = local_flush_key,
290 .get_key_info = local_get_key_info,
293 WERROR reg_open_local(TALLOC_CTX *mem_ctx, struct registry_context **ctx,
294 struct auth_session_info *session_info,
295 struct cli_credentials *credentials)
297 struct registry_local *ret = talloc_zero(mem_ctx,
298 struct registry_local);
300 W_ERROR_HAVE_NO_MEMORY(ret);
302 ret->registry.ops = &local_ops;
303 ret->session_info = session_info;
304 ret->credentials = credentials;
306 *ctx = (struct registry_context *)ret;
311 WERROR reg_mount_hive(struct registry_context *rctx,
312 struct hive_key *hive_key,
314 const char **elements)
316 struct registry_local *reg_local = talloc_get_type(rctx,
317 struct registry_local);
318 struct mountpoint *mp = talloc(rctx, struct mountpoint);
321 mp->path.predefined_key = key_id;
322 mp->prev = mp->next = NULL;
324 if (elements != NULL && str_list_length(elements) != 0) {
325 mp->path.elements = talloc_array(mp, const char *,
326 str_list_length(elements));
327 for (i = 0; elements[i] != NULL; i++) {
328 mp->path.elements[i] = talloc_reference(mp->path.elements,
331 mp->path.elements[i] = NULL;
333 mp->path.elements = NULL;
336 DLIST_ADD(reg_local->mountpoints, mp);