2 Unix SMB/CIFS implementation.
4 Copyright (C) Jelmer Vernooij 2004.
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.
23 #include "lib/ldb/include/ldb.h"
28 struct ldb_message **subkeys, **values;
29 int subkey_count, value_count;
32 static int ldb_close_hive (void *_hive)
34 struct registry_hive *hive = _hive;
35 ldb_close (hive->backend_data);
39 static void reg_ldb_unpack_value(TALLOC_CTX *mem_ctx, struct ldb_message *msg, char **name, uint32 *type, void **data, int *len)
41 const struct ldb_val *val;
42 *name = talloc_strdup(mem_ctx, ldb_msg_find_string(msg, "value", NULL));
43 *type = ldb_msg_find_uint(msg, "type", 0);
44 val = ldb_msg_find_ldb_val(msg, "data");
45 *data = talloc_memdup(mem_ctx, val->data, val->length);
49 static struct ldb_message *reg_ldb_pack_value(struct ldb_context *ctx, TALLOC_CTX *mem_ctx, const char *name, uint32 type, void *data, int len)
52 struct ldb_message *msg = talloc_zero_p(mem_ctx, struct ldb_message);
55 ldb_msg_add_string(ctx, msg, "value", talloc_strdup(mem_ctx, name));
58 ldb_msg_add_value(ctx, msg, "data", &val);
60 type_s = talloc_asprintf(mem_ctx, "%u", type);
61 ldb_msg_add_string(ctx, msg, "type", type_s);
67 static int reg_close_ldb_key (void *data)
69 struct registry_key *key = data;
70 struct ldb_key_data *kd = key->backend_data;
71 struct ldb_context *c = key->hive->backend_data;
74 ldb_search_free(c, kd->subkeys);
79 ldb_search_free(c, kd->values);
85 static char *reg_path_to_ldb(TALLOC_CTX *mem_ctx, struct registry_key *from, const char *path, const char *add)
87 char *ret = talloc_strdup(mem_ctx, "");
88 char *mypath = talloc_strdup(mem_ctx, path);
90 struct ldb_key_data *kd = from->backend_data;
93 ret = talloc_asprintf_append(ret, "%s", add);
97 begin = strrchr(mypath, '\\');
99 if(begin) keyname = begin + 1;
100 else keyname = mypath;
103 ret = talloc_asprintf_append(ret, "key=%s,", keyname);
112 ret = talloc_asprintf_append(ret, "%s", kd->dn);
118 static WERROR ldb_get_subkey_by_id(TALLOC_CTX *mem_ctx, struct registry_key *k, int idx, struct registry_key **subkey)
120 struct ldb_context *c = k->hive->backend_data;
121 struct ldb_message_element *el;
122 struct ldb_key_data *kd = k->backend_data, *newkd;
124 /* Do a search if necessary */
125 if (kd->subkeys == NULL) {
126 kd->subkey_count = ldb_search(c, kd->dn, LDB_SCOPE_ONELEVEL, "(key=*)", NULL, &kd->subkeys);
128 if(kd->subkey_count < 0) {
129 DEBUG(0, ("Error getting subkeys for '%s': %s\n", kd->dn, ldb_errstring(c)));
134 if (idx >= kd->subkey_count) return WERR_NO_MORE_ITEMS;
136 el = ldb_msg_find_element(kd->subkeys[idx], "key");
138 *subkey = talloc_p(mem_ctx, struct registry_key);
139 talloc_set_destructor(*subkey, reg_close_ldb_key);
140 (*subkey)->name = talloc_strdup(mem_ctx, el->values[0].data);
141 (*subkey)->backend_data = newkd = talloc_zero_p(*subkey, struct ldb_key_data);
142 newkd->dn = talloc_strdup(mem_ctx, kd->subkeys[idx]->dn);
147 static WERROR ldb_get_value_by_id(TALLOC_CTX *mem_ctx, struct registry_key *k, int idx, struct registry_value **value)
149 struct ldb_context *c = k->hive->backend_data;
150 struct ldb_key_data *kd = k->backend_data;
152 /* Do the search if necessary */
153 if (kd->values == NULL) {
154 kd->value_count = ldb_search(c, kd->dn, LDB_SCOPE_ONELEVEL, "(value=*)", NULL,&kd->values);
156 if(kd->value_count < 0) {
157 DEBUG(0, ("Error getting values for '%s': %s\n", kd->dn, ldb_errstring(c)));
162 if(idx >= kd->value_count) return WERR_NO_MORE_ITEMS;
164 *value = talloc_p(mem_ctx, struct registry_value);
166 reg_ldb_unpack_value(mem_ctx, kd->values[idx], &(*value)->name, &(*value)->data_type, &(*value)->data_blk, &(*value)->data_len);
171 static WERROR ldb_open_key(TALLOC_CTX *mem_ctx, struct registry_key *h, const char *name, struct registry_key **key)
173 struct ldb_context *c = h->hive->backend_data;
174 struct ldb_message **msg;
177 struct ldb_key_data *newkd;
179 ldap_path = reg_path_to_ldb(mem_ctx, h, name, NULL);
181 ret = ldb_search(c, ldap_path, LDB_SCOPE_BASE, "(key=*)", NULL,&msg);
184 return WERR_NO_MORE_ITEMS;
186 DEBUG(0, ("Error opening key '%s': %s\n", ldap_path, ldb_errstring(c)));
190 *key = talloc_p(mem_ctx, struct registry_key);
191 talloc_set_destructor(*key, reg_close_ldb_key);
192 (*key)->name = talloc_strdup(mem_ctx, strrchr(name, '\\')?strchr(name, '\\'):name);
193 (*key)->backend_data = newkd = talloc_zero_p(*key, struct ldb_key_data);
194 newkd->dn = talloc_strdup(mem_ctx, msg[0]->dn);
196 ldb_search_free(c, msg);
201 static WERROR ldb_open_hive(struct registry_hive *hive, struct registry_key **k)
203 struct ldb_context *c;
204 struct ldb_key_data *kd;
205 struct ldb_wrap *wrap;
207 if (!hive->location) return WERR_INVALID_PARAM;
208 wrap = ldb_wrap_connect(hive, hive->location, 0, NULL);
213 DEBUG(1, ("ldb_open_hive: %s\n", ldb_errstring(hive->backend_data)));
216 ldb_set_debug_stderr(c);
217 hive->backend_data = c;
219 *k = talloc_zero_p(hive, struct registry_key);
220 talloc_set_destructor (*k, reg_close_ldb_key);
221 talloc_set_destructor (hive, ldb_close_hive);
222 (*k)->name = talloc_strdup(*k, "");
223 (*k)->backend_data = kd = talloc_zero_p(*k, struct ldb_key_data);
224 kd->dn = talloc_strdup(*k, "hive=");
230 static WERROR ldb_add_key (TALLOC_CTX *mem_ctx, struct registry_key *parent, const char *name, uint32_t access_mask, struct security_descriptor *sd, struct registry_key **newkey)
232 struct ldb_context *ctx = parent->hive->backend_data;
233 struct ldb_message msg;
234 struct ldb_key_data *newkd;
239 msg.dn = reg_path_to_ldb(mem_ctx, parent, name, NULL);
241 ldb_msg_add_string(ctx, &msg, "key", talloc_strdup(mem_ctx, name));
243 ret = ldb_add(ctx, &msg);
245 DEBUG(1, ("ldb_msg_add: %s\n", ldb_errstring(parent->hive->backend_data)));
249 *newkey = talloc_zero_p(mem_ctx, struct registry_key);
250 (*newkey)->name = talloc_strdup(mem_ctx, name);
252 (*newkey)->backend_data = newkd = talloc_zero_p(*newkey, struct ldb_key_data);
258 static WERROR ldb_del_key (struct registry_key *key, const char *child)
261 struct ldb_key_data *kd = key->backend_data;
262 char *childdn = talloc_asprintf(NULL, "key=%s,%s", child, kd->dn);
264 ret = ldb_delete(key->hive->backend_data, childdn);
266 talloc_destroy(childdn);
269 DEBUG(1, ("ldb_del_key: %s\n", ldb_errstring(key->hive->backend_data)));
276 static WERROR ldb_del_value (struct registry_key *key, const char *child)
279 struct ldb_key_data *kd = key->backend_data;
280 char *childdn = talloc_asprintf(NULL, "value=%s,%s", child, kd->dn);
282 ret = ldb_delete(key->hive->backend_data, childdn);
284 talloc_destroy(childdn);
287 DEBUG(1, ("ldb_del_value: %s\n", ldb_errstring(key->hive->backend_data)));
294 static WERROR ldb_set_value (struct registry_key *parent, const char *name, uint32 type, void *data, int len)
296 struct ldb_context *ctx = parent->hive->backend_data;
297 struct ldb_message *msg;
298 struct ldb_key_data *kd = parent->backend_data;
300 TALLOC_CTX *mem_ctx = talloc_init("ldb_set_value");
302 msg = reg_ldb_pack_value(ctx, mem_ctx, name, type, data, len);
304 msg->dn = talloc_asprintf(mem_ctx, "value=%s,%s", name, kd->dn);
306 ret = ldb_add(ctx, msg);
308 ret = ldb_modify(ctx, msg);
310 DEBUG(1, ("ldb_msg_add: %s\n", ldb_errstring(parent->hive->backend_data)));
311 talloc_destroy(mem_ctx);
316 talloc_destroy(mem_ctx);
320 static struct hive_operations reg_backend_ldb = {
322 .add_key = ldb_add_key,
323 .del_key = ldb_del_key,
324 .open_hive = ldb_open_hive,
325 .open_key = ldb_open_key,
326 .get_value_by_index = ldb_get_value_by_id,
327 .get_subkey_by_index = ldb_get_subkey_by_id,
328 .set_value = ldb_set_value,
329 .del_value = ldb_del_value,
332 NTSTATUS registry_ldb_init(void)
334 return registry_register(®_backend_ldb);