5ecbfa04077f3536c4d49fa3f69b7ffdbf48fd7d
[jelmer/samba4-debian.git] / source / lib / registry / ldb.c
1 /* 
2    Unix SMB/CIFS implementation.
3    Registry interface
4    Copyright (C) Jelmer Vernooij  2004-2007.
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 3 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, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include "includes.h"
21 #include "registry.h"
22 #include "lib/ldb/include/ldb.h"
23 #include "lib/ldb/include/ldb_errors.h"
24 #include "db_wrap.h"
25 #include "librpc/gen_ndr/winreg.h"
26
27 static struct hive_operations reg_backend_ldb;
28
29 struct ldb_key_data 
30 {
31         struct hive_key key;
32         struct ldb_context *ldb;
33         struct ldb_dn *dn;
34         struct ldb_message **subkeys, **values;
35         int subkey_count, value_count;
36 };
37
38 static void reg_ldb_unpack_value(TALLOC_CTX *mem_ctx, struct ldb_message *msg, const char **name, 
39                                                                  uint32_t *type, DATA_BLOB *data)
40 {
41         const struct ldb_val *val;
42         if (name != NULL)
43                 *name = talloc_strdup(mem_ctx, ldb_msg_find_attr_as_string(msg, "value", NULL));
44
45         if (type != NULL)
46                 *type = ldb_msg_find_attr_as_uint(msg, "type", 0);
47         val = ldb_msg_find_ldb_val(msg, "data");
48
49         switch (*type)
50         {
51         case REG_SZ:
52         case REG_EXPAND_SZ:
53                 data->length = convert_string_talloc(mem_ctx, CH_UTF8, CH_UTF16, 
54                                                                                          val->data, val->length, (void **)&data->data);
55                 break;
56
57         case REG_DWORD: {
58                 uint32_t tmp = strtoul((char *)val->data, NULL, 0);
59                 *data = data_blob_talloc(mem_ctx, &tmp, 4);
60                 }
61                 break;
62
63         default:
64                 *data = data_blob_talloc(mem_ctx, val->data, val->length);
65                 break;
66         }
67 }
68
69 static struct ldb_message *reg_ldb_pack_value(struct ldb_context *ctx, 
70                                                 TALLOC_CTX *mem_ctx, const char *name, 
71                                                 uint32_t type, DATA_BLOB data)
72 {
73         struct ldb_val val;
74         struct ldb_message *msg = talloc_zero(mem_ctx, struct ldb_message);
75         char *type_s;
76
77         ldb_msg_add_string(msg, "value", talloc_strdup(mem_ctx, name));
78
79         switch (type) {
80         case REG_SZ:
81         case REG_EXPAND_SZ:
82                 val.length = convert_string_talloc(mem_ctx, CH_UTF16, CH_UTF8, 
83                                                                                    (void *)data.data, data.length, (void **)&val.data);
84                 ldb_msg_add_value(msg, "data", &val, NULL);
85                 break;
86
87         case REG_DWORD:
88                 ldb_msg_add_string(msg, "data", talloc_asprintf(mem_ctx, "0x%x", IVAL(data.data, 0)));
89                 break;
90         default:
91                 ldb_msg_add_value(msg, "data", &data, NULL);
92         }
93
94
95         type_s = talloc_asprintf(mem_ctx, "%u", type);
96         ldb_msg_add_string(msg, "type", type_s); 
97
98         return msg;
99 }
100
101
102 static int reg_close_ldb_key(struct ldb_key_data *key)
103 {
104         if (key->subkeys != NULL) {
105                 talloc_free(key->subkeys); 
106                 key->subkeys = NULL;
107         }
108
109         if (key->values != NULL) {
110                 talloc_free(key->values); 
111                 key->values = NULL;
112         }
113         return 0;
114 }
115
116 static struct ldb_dn *reg_path_to_ldb(TALLOC_CTX *mem_ctx, 
117                                                                           const struct hive_key *from, 
118                                                                           const char *path, const char *add)
119 {
120         TALLOC_CTX *local_ctx;
121         struct ldb_dn *ret;
122         char *mypath = talloc_strdup(mem_ctx, path);
123         char *begin;
124         struct ldb_key_data *kd = talloc_get_type(from, struct ldb_key_data);
125         struct ldb_context *ldb = kd->ldb;
126
127         local_ctx = talloc_new(mem_ctx);
128
129         if (add) {
130                 ret = ldb_dn_new(mem_ctx, ldb, add);
131         } else {
132                 ret = ldb_dn_new(mem_ctx, ldb, NULL);
133         }
134         if (!ldb_dn_validate(ret)) {
135                 talloc_free(ret);
136                 talloc_free(local_ctx);
137                 return NULL;
138         }
139
140         while (mypath) {
141                 char *keyname;
142
143                 begin = strrchr(mypath, '\\');
144
145                 if (begin) keyname = begin + 1;
146                 else keyname = mypath;
147
148                 if(strlen(keyname)) {
149                         ldb_dn_add_base_fmt(ret, "key=%s", keyname);
150                 }
151
152                 if(begin) {
153                         *begin = '\0';
154                 } else {
155                         break;
156                 }
157         }
158
159         ldb_dn_add_base(ret, kd->dn);
160
161         talloc_free(local_ctx);
162
163         return ret;
164 }
165
166 static WERROR cache_subkeys(struct ldb_key_data *kd)
167 {
168         struct ldb_context *c = kd->ldb;
169         struct ldb_result *res;
170         int ret;
171
172         ret = ldb_search(c, kd->dn, LDB_SCOPE_ONELEVEL, "(key=*)", NULL, &res);
173
174         if (ret != LDB_SUCCESS) {
175                 DEBUG(0, ("Error getting subkeys for '%s': %s\n", ldb_dn_get_linearized(kd->dn), ldb_errstring(c)));
176                 return WERR_FOOBAR;
177         }
178
179         kd->subkey_count = res->count;
180         kd->subkeys = talloc_steal(kd, res->msgs);
181         talloc_free(res);
182
183         return WERR_OK;
184 }
185
186 static WERROR cache_values(struct ldb_key_data *kd)
187 {
188         struct ldb_context *c = kd->ldb;
189         struct ldb_result *res;
190         int ret;
191
192         ret = ldb_search(c, kd->dn, LDB_SCOPE_ONELEVEL, "(value=*)", NULL, &res);
193
194         if (ret != LDB_SUCCESS) {
195                 DEBUG(0, ("Error getting values for '%s': %s\n", ldb_dn_get_linearized(kd->dn), ldb_errstring(c)));
196                 return WERR_FOOBAR;
197         }
198         kd->value_count = res->count;
199         kd->values = talloc_steal(kd, res->msgs);
200         talloc_free(res);
201         return WERR_OK;
202 }
203
204
205 static WERROR ldb_get_subkey_by_id(TALLOC_CTX *mem_ctx, 
206                                                    const struct hive_key *k, uint32_t idx, 
207                                                    const char **name,
208                                                    const char **classname,
209                                                    NTTIME *last_mod_time)
210 {
211         struct ldb_message_element *el;
212         struct ldb_key_data *kd = talloc_get_type(k, struct ldb_key_data);
213
214         /* Do a search if necessary */
215         if (kd->subkeys == NULL) {
216                 W_ERROR_NOT_OK_RETURN(cache_subkeys(kd));
217         } 
218
219         if (idx >= kd->subkey_count) 
220                 return WERR_NO_MORE_ITEMS;
221
222         el = ldb_msg_find_element(kd->subkeys[idx], "key");
223         SMB_ASSERT(el != NULL);
224         SMB_ASSERT(el->num_values != 0);
225         
226         if (name != NULL)
227                 *name = talloc_strdup(mem_ctx, (char *)el->values[0].data);
228
229         if (classname != NULL)
230                 *classname = NULL; /* TODO: Store properly */
231         
232         if (last_mod_time != NULL)
233                 *last_mod_time = 0; /* TODO: we need to add this to the
234                                                 ldb backend properly */
235
236         return WERR_OK;
237 }
238
239 static WERROR ldb_get_value_by_id(TALLOC_CTX *mem_ctx, const struct hive_key *k, int idx, 
240                                                                   const char **name, uint32_t *data_type, DATA_BLOB *data)
241 {
242         struct ldb_key_data *kd = talloc_get_type(k, struct ldb_key_data);
243
244         /* Do the search if necessary */
245         if (kd->values == NULL) {
246                 W_ERROR_NOT_OK_RETURN(cache_values(kd));
247         }
248
249         if(idx >= kd->value_count) return WERR_NO_MORE_ITEMS;
250
251         reg_ldb_unpack_value(mem_ctx, kd->values[idx], 
252                                                  name, data_type, data);
253
254         return WERR_OK;
255 }
256
257 static WERROR ldb_get_value(TALLOC_CTX *mem_ctx, struct hive_key *k, 
258                                         const char *name, uint32_t *data_type, DATA_BLOB *data)
259 {
260         struct ldb_key_data *kd = talloc_get_type(k, struct ldb_key_data);
261         struct ldb_context *c = kd->ldb;
262         struct ldb_result *res;
263         int ret;
264         char *query = talloc_asprintf(mem_ctx, "(value=%s)", name);
265
266         ret = ldb_search(c, kd->dn, LDB_SCOPE_ONELEVEL, query, NULL, &res);
267
268         talloc_free(query);
269
270         if (ret != LDB_SUCCESS) {
271                 DEBUG(0, ("Error getting values for '%s': %s\n", ldb_dn_get_linearized(kd->dn), ldb_errstring(c)));
272                 return WERR_FOOBAR;
273         }
274
275         if (res->count == 0)
276                 return WERR_NOT_FOUND;
277
278         reg_ldb_unpack_value(mem_ctx, res->msgs[0], NULL, data_type, data);
279
280         return WERR_OK;
281 }
282
283 static WERROR ldb_open_key(TALLOC_CTX *mem_ctx, const struct hive_key *h, 
284                                                    const char *name, struct hive_key **key)
285 {
286         struct ldb_result *res;
287         struct ldb_dn *ldap_path;
288         int ret;
289         struct ldb_key_data *newkd;
290         struct ldb_key_data *kd = talloc_get_type(h, struct ldb_key_data);
291         struct ldb_context *c = kd->ldb;
292
293         ldap_path = reg_path_to_ldb(mem_ctx, h, name, NULL);
294
295         ret = ldb_search(c, ldap_path, LDB_SCOPE_BASE, "(key=*)", NULL, &res);
296
297         if (ret != LDB_SUCCESS) {
298                 DEBUG(3, ("Error opening key '%s': %s\n", 
299                                   ldb_dn_get_linearized(ldap_path), ldb_errstring(c)));
300                 return WERR_FOOBAR;
301         } else if (res->count == 0) {
302                 DEBUG(3, ("Key '%s' not found\n", ldb_dn_get_linearized(ldap_path)));
303                 talloc_free(res);
304                 return WERR_NOT_FOUND;
305         }
306
307         newkd = talloc_zero(mem_ctx, struct ldb_key_data);
308         newkd->key.ops = &reg_backend_ldb;
309         newkd->ldb = talloc_reference(newkd, kd->ldb);
310         newkd->dn = ldb_dn_copy(mem_ctx, res->msgs[0]->dn); 
311
312         *key = (struct hive_key *)newkd;
313
314         talloc_free(res);
315
316         return WERR_OK;
317 }
318
319 WERROR reg_open_ldb_file(TALLOC_CTX *parent_ctx, const char *location, 
320                                                                 struct auth_session_info *session_info,
321                                                                 struct cli_credentials *credentials,
322                                                                 struct hive_key **k)
323 {
324         struct ldb_key_data *kd;
325         struct ldb_context *wrap;
326
327         if (location == NULL) 
328                 return WERR_INVALID_PARAM;
329
330         wrap = ldb_wrap_connect(parent_ctx, location, session_info, credentials, 0, NULL);
331
332         if (wrap == NULL) {
333                 DEBUG(1, (__FILE__": unable to connect\n"));
334                 return WERR_FOOBAR;
335         }
336
337         ldb_set_debug_stderr(wrap);
338
339         kd = talloc_zero(parent_ctx, struct ldb_key_data);
340         kd->key.ops = &reg_backend_ldb;
341         kd->ldb = talloc_reference(kd, wrap);
342         talloc_set_destructor (kd, reg_close_ldb_key);
343         kd->dn = ldb_dn_new(kd, wrap, "hive=NONE");
344
345         *k = (struct hive_key *)kd;
346
347         return WERR_OK;
348 }
349
350 static WERROR ldb_add_key (TALLOC_CTX *mem_ctx, const struct hive_key *parent, 
351                                                    const char *name, const char *classname,
352                                                    struct security_descriptor *sd, 
353                                                    struct hive_key **newkey)
354 {
355         const struct ldb_key_data *parentkd = (const struct ldb_key_data *)parent;
356         struct ldb_message *msg;
357         struct ldb_key_data *newkd;
358         int ret;
359
360         msg = ldb_msg_new(mem_ctx);
361
362         msg->dn = reg_path_to_ldb(msg, parent, name, NULL);
363
364         ldb_msg_add_string(msg, "key", talloc_strdup(mem_ctx, name));
365         if (classname != NULL)
366                 ldb_msg_add_string(msg, "classname", talloc_strdup(mem_ctx, classname));
367
368         ret = ldb_add(parentkd->ldb, msg);
369         if (ret < 0) {
370                 DEBUG(1, ("ldb_msg_add: %s\n", ldb_errstring(parentkd->ldb)));
371                 return WERR_FOOBAR;
372         } 
373
374         DEBUG(2, ("key added: %s\n", ldb_dn_get_linearized(msg->dn)));
375
376         newkd = talloc_zero(mem_ctx, struct ldb_key_data);
377         newkd->ldb = talloc_reference(newkd, parentkd->ldb);
378         newkd->key.ops = &reg_backend_ldb;
379         newkd->dn = talloc_steal(newkd, msg->dn);
380
381         *newkey = (struct hive_key *)newkd;
382
383         return WERR_OK;
384 }
385
386 static WERROR ldb_del_key (const struct hive_key *key, const char *child)
387 {
388         int ret;
389         struct ldb_key_data *parentkd = talloc_get_type(key, struct ldb_key_data);
390         struct ldb_dn *childdn;
391
392         childdn = ldb_dn_copy(parentkd->ldb, parentkd->dn);
393         ldb_dn_add_child_fmt(childdn, "key=%s", child);
394
395         ret = ldb_delete(parentkd->ldb, childdn);
396
397         talloc_free(childdn);
398
399         if (ret == LDB_ERR_NO_SUCH_OBJECT) {
400                 return WERR_NOT_FOUND;
401         } else if (ret < 0) {
402                 DEBUG(1, ("ldb_del_key: %s\n", ldb_errstring(parentkd->ldb)));
403                 return WERR_FOOBAR;
404         }
405
406         return WERR_OK;
407 }
408
409 static WERROR ldb_del_value (struct hive_key *key, const char *child)
410 {
411         int ret;
412         struct ldb_key_data *kd = talloc_get_type(key, struct ldb_key_data);
413         struct ldb_dn *childdn;
414
415         childdn = ldb_dn_copy(kd->ldb, kd->dn);
416         ldb_dn_add_child_fmt(childdn, "value=%s", child);
417
418         ret = ldb_delete(kd->ldb, childdn);
419
420         talloc_free(childdn);
421
422         if (ret == LDB_ERR_NO_SUCH_OBJECT) {
423                 return WERR_NOT_FOUND;
424         } else if (ret < 0) {
425                 DEBUG(1, ("ldb_del_value: %s\n", ldb_errstring(kd->ldb)));
426                 return WERR_FOOBAR;
427         }
428
429         return WERR_OK;
430 }
431
432 static WERROR ldb_set_value(struct hive_key *parent, 
433                                                         const char *name, uint32_t type, 
434                                                         const DATA_BLOB data)
435 {
436         struct ldb_message *msg;
437         struct ldb_key_data *kd = talloc_get_type(parent, struct ldb_key_data);
438         int ret;
439         TALLOC_CTX *mem_ctx = talloc_init("ldb_set_value");
440
441         msg = reg_ldb_pack_value(kd->ldb, mem_ctx, name, type, data);
442
443         msg->dn = ldb_dn_copy(msg, kd->dn);
444         ldb_dn_add_child_fmt(msg->dn, "value=%s", name);
445
446         ret = ldb_add(kd->ldb, msg);
447         if (ret < 0) {
448                 ret = ldb_modify(kd->ldb, msg);
449                 if (ret < 0) {
450                         DEBUG(1, ("ldb_msg_add: %s\n", ldb_errstring(kd->ldb)));
451                         talloc_free(mem_ctx);
452                         return WERR_FOOBAR;
453                 }
454         }
455         
456         talloc_free(mem_ctx);
457         return WERR_OK;
458 }
459
460 static WERROR ldb_get_key_info(TALLOC_CTX *mem_ctx, 
461                                                            const struct hive_key *key,
462                                                            const char **classname, 
463                                                            uint32_t *num_subkeys,
464                                                            uint32_t *num_values,
465                                                            NTTIME *last_change_time)
466 {
467         struct ldb_key_data *kd = talloc_get_type(key, struct ldb_key_data);
468
469         /* FIXME */
470         if (classname != NULL)
471                 *classname = NULL;
472
473         if (num_subkeys != NULL) {
474                 W_ERROR_NOT_OK_RETURN(cache_subkeys(kd));
475                 *num_subkeys = kd->subkey_count;
476         }
477
478         if (num_values != NULL) {
479                 W_ERROR_NOT_OK_RETURN(cache_values(kd));
480                 *num_values = kd->value_count;
481         }
482
483         if (last_change_time != NULL)
484                 *last_change_time = 0;
485
486         return WERR_OK;
487 }
488
489 static struct hive_operations reg_backend_ldb = {
490         .name = "ldb",
491         .add_key = ldb_add_key,
492         .del_key = ldb_del_key,
493         .get_key_by_name = ldb_open_key,
494         .enum_value = ldb_get_value_by_id,
495         .enum_key = ldb_get_subkey_by_id,
496         .set_value = ldb_set_value,
497         .get_value_by_name = ldb_get_value,
498         .delete_value = ldb_del_value,
499         .get_key_info = ldb_get_key_info,
500 };