source4/param/share_ldb.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    LDB based services configuration
   5
   6    Copyright (C) Simo Sorce     2006
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "includes.h"
  24 #include "ldb/include/ldb.h"
  25 #include "ldb/include/ldb_errors.h"
  26 #include "auth/auth.h"
  27 #include "db_wrap.h"
  28 #include "param/share.h"
  29
  30 static NTSTATUS sldb_init(TALLOC_CTX *mem_ctx, const struct share_ops *ops, struct share_context **ctx)
  31 {
  32         struct ldb_context *sdb;
  33
  34         *ctx = talloc(mem_ctx, struct share_context);
  35         if (!*ctx) {
  36                 DEBUG(0, ("ERROR: Out of memory!\n"));
  37                 return NT_STATUS_NO_MEMORY;
  38         }
  39
  40         sdb = ldb_wrap_connect( *ctx,
  41                                 private_path(*ctx, "share.ldb"),
  42                                 system_session(*ctx),
  43                                 NULL, 0, NULL);
  44
  45         if (!sdb) {
  46                 talloc_free(*ctx);
  47                 return NT_STATUS_UNSUCCESSFUL;
  48         }
  49
  50         (*ctx)->ops = ops;
  51         (*ctx)->priv_data = (void *)sdb;
  52
  53         return NT_STATUS_OK;
  54 }
  55
  56 static const char *sldb_string_option(struct share_config *scfg, const char *opt_name, const char *defval)
  57 {
  58         struct ldb_message *msg;
  59         struct ldb_message_element *el;
  60
  61         if (scfg == NULL) return defval;
  62
  63         msg = talloc_get_type(scfg->opaque, struct ldb_message);
  64
  65         if (strchr(opt_name, ':')) {
  66                 char *name, *p;
  67
  68                 name = talloc_strdup(scfg, opt_name);
  69                 if (!name) {
  70                         return NULL;
  71                 }
  72                 p = strchr(name, ':');
  73                 *p = '-';
  74
  75                 el = ldb_msg_find_element(msg, name);
  76         } else {
  77                 el = ldb_msg_find_element(msg, opt_name);
  78         }
  79
  80         if (el == NULL) {
  81                 return defval;
  82         }
  83
  84         return (const char *)(el->values[0].data);
  85 }
  86
  87 static int sldb_int_option(struct share_config *scfg, const char *opt_name, int defval)
  88 {
  89         const char *val;
  90         int ret;
  91
  92         val = sldb_string_option(scfg, opt_name, NULL);
  93         if (val == NULL) return defval;
  94
  95         errno = 0;
  96         ret = (int)strtol(val, NULL, 10);
  97         if (errno) return -1;
  98
  99         return ret;
 100 }
 101
 102 static BOOL sldb_bool_option(struct share_config *scfg, const char *opt_name, BOOL defval)
 103 {
 104         const char *val;
 105
 106         val = sldb_string_option(scfg, opt_name, NULL);
 107         if (val == NULL) return defval;
 108
 109         if (strcasecmp(val, "true") == 0) return True;
 110
 111         return False;
 112 }
 113
 114 static const char **sldb_string_list_option(TALLOC_CTX *mem_ctx, struct share_config *scfg, const char *opt_name)
 115 {
 116         struct ldb_message *msg;
 117         struct ldb_message_element *el;
 118         const char **list;
 119         int i;
 120
 121         if (scfg == NULL) return NULL;
 122
 123         msg = talloc_get_type(scfg->opaque, struct ldb_message);
 124
 125         if (strchr(opt_name, ':')) {
 126                 char *name, *p;
 127
 128                 name = talloc_strdup(scfg, opt_name);
 129                 if (!name) {
 130                         return NULL;
 131                 }
 132                 p = strchr(name, ':');
 133                 *p = '-';
 134
 135                 el = ldb_msg_find_element(msg, name);
 136         } else {
 137                 el = ldb_msg_find_element(msg, opt_name);
 138         }
 139
 140         if (el == NULL) {
 141                 return NULL;
 142         }
 143
 144         list = talloc_array(mem_ctx, const char *, el->num_values + 1);
 145         if (!list) return NULL;
 146
 147         for (i = 0; i < el->num_values; i++) {
 148                 list[i] = (const char *)(el->values[i].data);
 149         }
 150         list[i] = NULL;
 151
 152         return list;
 153 }
 154
 155 static NTSTATUS sldb_list_all(TALLOC_CTX *mem_ctx,
 156                                  struct share_context *ctx,
 157                                  int *count,
 158                                  const char ***names)
 159 {
 160         int ret, i, j;
 161         const char **n;
 162         struct ldb_context *ldb;
 163         struct ldb_result *res;
 164         TALLOC_CTX *tmp_ctx;
 165
 166         tmp_ctx = talloc_new(mem_ctx);
 167         if (!tmp_ctx) {
 168                 DEBUG(0,("ERROR: Out of memory!\n"));
 169                 return NT_STATUS_NO_MEMORY;
 170         }
 171
 172         ldb = talloc_get_type(ctx->priv_data, struct ldb_context);
 173
 174         ret = ldb_search(ldb, ldb_dn_explode(tmp_ctx, "CN=SHARES"), LDB_SCOPE_SUBTREE, "(name=*)", NULL, &res);
 175         if (ret != LDB_SUCCESS) {
 176                 talloc_free(tmp_ctx);
 177                 return NT_STATUS_UNSUCCESSFUL;
 178         }
 179         talloc_steal(tmp_ctx, res);
 180
 181         n = talloc_array(mem_ctx, const char *, res->count);
 182         if (!n) {
 183                 DEBUG(0,("ERROR: Out of memory!\n"));
 184                 talloc_free(tmp_ctx);
 185                 return NT_STATUS_NO_MEMORY;
 186         }
 187
 188         for (i = 0, j = 0; i < res->count; i++) {
 189                 n[j] = talloc_strdup(n, ldb_msg_find_string(res->msgs[i], "name", NULL));
 190                 if (!n[j]) {
 191                         DEBUG(0,("WARNING: Malformed share object in share database\n!"));
 192                         continue;
 193                 }
 194                 j++;
 195         }
 196
 197         *names = n;
 198         *count = j;
 199         talloc_free(tmp_ctx);
 200
 201         return NT_STATUS_OK;
 202 }
 203
 204 static NTSTATUS sldb_get_config(TALLOC_CTX *mem_ctx,
 205                          struct share_context *ctx,
 206                          const char *name,
 207                          struct share_config **scfg)
 208 {
 209         int ret;
 210         struct share_config *s;
 211         struct ldb_context *ldb;
 212         struct ldb_result *res;
 213         TALLOC_CTX *tmp_ctx;
 214         char *filter;
 215
 216         tmp_ctx = talloc_new(mem_ctx);
 217         if (!tmp_ctx) {
 218                 DEBUG(0,("ERROR: Out of memory!\n"));
 219                 return NT_STATUS_NO_MEMORY;
 220         }
 221
 222         ldb = talloc_get_type(ctx->priv_data, struct ldb_context);
 223
 224         filter = talloc_asprintf(tmp_ctx,"(name=%s)", name);
 225         if (!filter) {
 226                 DEBUG(0,("ERROR: Out of memory!\n"));
 227                 talloc_free(tmp_ctx);
 228                 return NT_STATUS_NO_MEMORY;
 229         }
 230         ret = ldb_search(ldb, ldb_dn_explode(tmp_ctx, "CN=SHARES"), LDB_SCOPE_SUBTREE, filter, NULL, &res);
 231         if (ret != LDB_SUCCESS || res->count != 1) {
 232                 talloc_free(tmp_ctx);
 233                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
 234         }
 235         talloc_steal(tmp_ctx, res);
 236
 237         s = talloc(tmp_ctx, struct share_config);
 238         if (!s) {
 239                 DEBUG(0,("ERROR: Out of memory!\n"));
 240                 talloc_free(tmp_ctx);
 241                 return NT_STATUS_NO_MEMORY;
 242         }
 243
 244         s->name = talloc_strdup(s, ldb_msg_find_string(res->msgs[0], "name", NULL));
 245         if (!s->name) {
 246                 DEBUG(0,("ERROR: Invalid share object!\n"));
 247                 talloc_free(tmp_ctx);
 248                 return NT_STATUS_UNSUCCESSFUL;
 249         }
 250
 251         s->opaque = talloc_steal(s, res->msgs[0]);
 252         if (!s->opaque) {
 253                 DEBUG(0,("ERROR: Invalid share object!\n"));
 254                 talloc_free(tmp_ctx);
 255                 return NT_STATUS_UNSUCCESSFUL;
 256         }
 257
 258         s->ctx = ctx;
 259
 260         *scfg = talloc_steal(mem_ctx, s);
 261
 262         talloc_free(tmp_ctx);
 263         return NT_STATUS_OK;
 264 }
 265
 266 NTSTATUS share_ldb_init(void *mem_ctx)
 267 {
 268         struct share_ops ops;
 269
 270         ops.name = "ldb";
 271         ops.init = sldb_init;
 272         ops.string_option = sldb_string_option;
 273         ops.int_option = sldb_int_option;
 274         ops.bool_option = sldb_bool_option;
 275         ops.string_list_option = sldb_string_list_option;
 276         ops.list_all = sldb_list_all;
 277         ops.get_config = sldb_get_config;
 278
 279         return share_register(&ops);
 280 }
 281