source4/lib/registry/reg_backend_ldb/reg_backend_ldb.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Registry interface
   4    Copyright (C) Jelmer Vernooij  2004.
   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 2 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, write to the Free Software
  18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19 */
  20
  21 #include "includes.h"
  22 #include "registry.h"
  23 #include "lib/ldb/include/ldb.h"
  24
  25 static char *reg_path_to_ldb(TALLOC_CTX *mem_ctx, const char *path, const char *add)
  26 {
  27         char *ret = talloc_strdup(mem_ctx, "");
  28         char *mypath = strdup(path);
  29         char *end = mypath, *begin;
  30
  31         if(add)
  32                 ret = talloc_asprintf_append(ret, "%s", add);
  33
  34         while(end) {
  35                 char *keyname;
  36                 begin = strrchr(end, '\\');
  37
  38                 if(begin) keyname = begin + 1;
  39                 else keyname = mypath;
  40
  41                 if(strlen(keyname))
  42                         ret = talloc_asprintf_append(ret, "key=%s,", keyname);
  43
  44                 if(begin) {
  45                         *begin = '\0';
  46                         end = begin-1;
  47                 } else {
  48                         end = NULL;
  49                 }
  50         }
  51
  52         SAFE_FREE(mypath);
  53
  54         ret[strlen(ret)-1] = '\0';
  55
  56         if(strlen(ret) == 0) return NULL;
  57
  58         return ret;
  59 }
  60
  61
  62 static WERROR ldb_get_subkey_by_id(TALLOC_CTX *mem_ctx, struct registry_key *k, int idx, struct registry_key **subkey)
  63 {
  64         struct ldb_context *c = k->hive->backend_data;
  65         int ret;
  66         struct ldb_message **msg;
  67         struct ldb_message_element *el;
  68
  69         ret = ldb_search(c, (char *)k->backend_data, LDB_SCOPE_ONELEVEL, "(key=*)", NULL,&msg);
  70
  71         if(ret < 0) {
  72                 DEBUG(0, ("Error getting subkeys for '%s': %s\n", (char *)k->backend_data, ldb_errstring(c)));
  73                 return WERR_FOOBAR;
  74         }
  75
  76         if(idx >= ret) return WERR_NO_MORE_ITEMS;
  77
  78         el = ldb_msg_find_element(msg[idx], "key");
  79
  80         *subkey = talloc_p(mem_ctx, struct registry_key);
  81         (*subkey)->name = talloc_strdup(mem_ctx, el->values[0].data);
  82         (*subkey)->backend_data = talloc_strdup(mem_ctx, msg[idx]->dn);
  83
  84         ldb_search_free(c, msg);
  85         return WERR_OK;
  86 }
  87
  88 static WERROR ldb_get_value_by_id(TALLOC_CTX *mem_ctx, struct registry_key *k, int idx, struct registry_value **value)
  89 {
  90         struct ldb_context *c = k->hive->backend_data;
  91         int ret;
  92         struct ldb_message **msg;
  93         struct ldb_message_element *el;
  94
  95         ret = ldb_search(c, (char *)k->backend_data, LDB_SCOPE_ONELEVEL, "(value=*)", NULL,&msg);
  96
  97         if(ret < 0) {
  98                 DEBUG(0, ("Error getting values for '%s': %s\n", (char *)k->backend_data, ldb_errstring(c)));
  99                 return WERR_FOOBAR;
 100         }
 101
 102         if(idx >= ret) return WERR_NO_MORE_ITEMS;
 103
 104         el = ldb_msg_find_element(msg[idx], "value");
 105
 106         *value = talloc_p(mem_ctx, struct registry_value);
 107         (*value)->name = talloc_strdup(mem_ctx, el->values[0].data);
 108         (*value)->backend_data = talloc_strdup(mem_ctx, msg[idx]->dn);
 109
 110         ldb_search_free(c, msg);
 111         return WERR_OK;
 112 }
 113
 114 static WERROR ldb_open_key(TALLOC_CTX *mem_ctx, struct registry_hive *h, const char *name, struct registry_key **key)
 115 {
 116         struct ldb_context *c = h->backend_data;
 117         struct ldb_message **msg;
 118         char *ldap_path;
 119         int ret;
 120         ldap_path = reg_path_to_ldb(mem_ctx, name, NULL);
 121
 122         ret = ldb_search(c, ldap_path, LDB_SCOPE_BASE, "(key=*)", NULL,&msg);
 123
 124         if(ret == 0) {
 125                 return WERR_NO_MORE_ITEMS;
 126         } else if(ret < 0) {
 127                 DEBUG(0, ("Error opening key '%s': %s\n", ldap_path, ldb_errstring(c)));
 128                 return WERR_FOOBAR;
 129         }
 130
 131         *key = talloc_p(mem_ctx, struct registry_key);
 132         (*key)->name = talloc_strdup(mem_ctx, strrchr(name, '\\'));
 133         (*key)->backend_data = talloc_strdup(mem_ctx, msg[0]->dn);
 134
 135         ldb_search_free(c, msg);
 136
 137         return WERR_OK;
 138 }
 139
 140 static WERROR ldb_open_hive(TALLOC_CTX *mem_ctx, struct registry_hive *hive, struct registry_key **k)
 141 {
 142         struct ldb_context *c;
 143
 144         if (!hive->location) return WERR_INVALID_PARAM;
 145         c = ldb_connect(hive->location, 0, NULL);
 146
 147         if(!c) {
 148                 DEBUG(1, ("ldb_open_hive: %s\n", ldb_errstring(hive->backend_data)));
 149                 return WERR_FOOBAR;
 150         }
 151         ldb_set_debug_stderr(c);
 152         hive->backend_data = c;
 153
 154         hive->root = talloc_zero_p(mem_ctx, struct registry_key);
 155         hive->root->name = talloc_strdup(mem_ctx, "");
 156
 157         return WERR_OK;
 158 }
 159
 160 static WERROR ldb_add_key (TALLOC_CTX *mem_ctx, struct registry_key *parent, const char *name, uint32_t access_mask, SEC_DESC *sd, struct registry_key **newkey)
 161 {
 162         struct ldb_context *ctx = parent->hive->backend_data;
 163         struct ldb_message msg;
 164         int ret;
 165
 166         ZERO_STRUCT(msg);
 167
 168         msg.dn = reg_path_to_ldb(mem_ctx, parent->path, talloc_asprintf(mem_ctx, "key=%s,", name));
 169
 170         ldb_msg_add_string(ctx, &msg, "key", talloc_strdup(mem_ctx, name));
 171
 172         ret = ldb_add(ctx, &msg);
 173         if (ret < 0) {
 174                 DEBUG(1, ("ldb_msg_add: %s\n", ldb_errstring(parent->hive->backend_data)));
 175                 return WERR_FOOBAR;
 176         }
 177
 178         *newkey = talloc_zero_p(mem_ctx, struct registry_key);
 179         (*newkey)->backend_data = msg.dn;
 180         (*newkey)->name = talloc_strdup(mem_ctx, name);
 181
 182         return WERR_OK;
 183 }
 184
 185 static WERROR ldb_del_key (struct registry_key *key)
 186 {
 187         int ret;
 188
 189         ret = ldb_delete(key->hive->backend_data, key->backend_data);
 190
 191         if (ret < 0) {
 192                 DEBUG(1, ("ldb_del_key: %s\n", ldb_errstring(key->hive->backend_data)));
 193                 return WERR_FOOBAR;
 194         }
 195
 196         return WERR_OK;
 197 }
 198
 199 static WERROR ldb_close_hive (struct registry_hive *hive)
 200 {
 201         ldb_close (hive->backend_data);
 202         return WERR_OK;
 203 }
 204
 205 static struct registry_operations reg_backend_ldb = {
 206         .name = "ldb",
 207         .add_key = ldb_add_key,
 208         .del_key = ldb_del_key,
 209         .open_hive = ldb_open_hive,
 210         .close_hive = ldb_close_hive,
 211         .open_key = ldb_open_key,
 212         .get_value_by_index = ldb_get_value_by_id,
 213         .get_subkey_by_index = ldb_get_subkey_by_id,
 214 };
 215
 216 NTSTATUS registry_ldb_init(void)
 217 {
 218         return registry_register(&reg_backend_ldb);
 219 }