source4/param/share.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    Modular shares configuration system
   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 3 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, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "includes.h"
  23 #include "param/share.h"
  24 #include "param/param.h"
  25 #include "lib/util/samba_modules.h"
  26
  27 char *share_string_option(TALLOC_CTX *mem_ctx, struct share_config *scfg, const char *opt_name, const char *defval)
  28 {
  29         return scfg->ctx->ops->string_option(mem_ctx, scfg, opt_name, defval);
  30 }
  31
  32 int share_int_option(struct share_config *scfg, const char *opt_name, int defval)
  33 {
  34         return scfg->ctx->ops->int_option(scfg, opt_name, defval);
  35 }
  36
  37 bool share_bool_option(struct share_config *scfg, const char *opt_name, bool defval)
  38 {
  39         return scfg->ctx->ops->bool_option(scfg, opt_name, defval);
  40 }
  41
  42 const char **share_string_list_option(TALLOC_CTX *mem_ctx, struct share_config *scfg, const char *opt_name)
  43 {
  44         return scfg->ctx->ops->string_list_option(mem_ctx, scfg, opt_name);
  45 }
  46
  47 NTSTATUS share_list_all(TALLOC_CTX *mem_ctx, struct share_context *sctx, int *count, const char ***names)
  48 {
  49         return sctx->ops->list_all(mem_ctx, sctx, count, names);
  50 }
  51
  52 NTSTATUS share_get_config(TALLOC_CTX *mem_ctx, struct share_context *sctx, const char *name, struct share_config **scfg)
  53 {
  54         return sctx->ops->get_config(mem_ctx, sctx, name, scfg);
  55 }
  56
  57 NTSTATUS share_create(struct share_context *sctx, const char *name, struct share_info *info, int count)
  58 {
  59         if (sctx->ops->create) {
  60                 return sctx->ops->create(sctx, name, info, count);
  61         }
  62         return NT_STATUS_NOT_IMPLEMENTED;
  63 }
  64
  65 NTSTATUS share_set(struct share_context *sctx, const char *name, struct share_info *info, int count)
  66 {
  67         if (sctx->ops->set) {
  68                 return sctx->ops->set(sctx, name, info, count);
  69         }
  70         return NT_STATUS_NOT_IMPLEMENTED;
  71 }
  72
  73 NTSTATUS share_remove(struct share_context *sctx, const char *name)
  74 {
  75         if (sctx->ops->remove) {
  76                 return sctx->ops->remove(sctx, name);
  77         }
  78         return NT_STATUS_NOT_IMPLEMENTED;
  79 }
  80
  81 /* List of currently available share backends */
  82 static struct share_ops **backends = NULL;
  83
  84 static const struct share_ops *share_backend_by_name(const char *name)
  85 {
  86         int i;
  87
  88         for (i = 0; backends && backends[i]; i++) {
  89                 if (strcmp(backends[i]->name, name) == 0) {
  90                         return backends[i];
  91                 }
  92         }
  93
  94         return NULL;
  95 }
  96
  97 /*
  98   Register the share backend
  99 */
 100 NTSTATUS share_register(const struct share_ops *ops)
 101 {
 102         int i;
 103
 104         if (share_backend_by_name(ops->name) != NULL) {
 105                 DEBUG(0,("SHARE backend [%s] already registered\n", ops->name));
 106                 return NT_STATUS_OBJECT_NAME_COLLISION;
 107         }
 108
 109         i = 0;
 110         while (backends && backends[i]) {
 111                 i++;
 112         }
 113
 114         backends = realloc_p(backends, struct share_ops *, i + 2);
 115         if (!backends) {
 116                 smb_panic("out of memory in share_register");
 117         }
 118
 119         backends[i] = (struct share_ops *)smb_xmemdup(ops, sizeof(*ops));
 120         backends[i]->name = smb_xstrdup(ops->name);
 121
 122         backends[i + 1] = NULL;
 123
 124         DEBUG(3, ("SHARE backend [%s] registered.\n", ops->name));
 125
 126         return NT_STATUS_OK;
 127 }
 128
 129 NTSTATUS share_get_context_by_name(TALLOC_CTX *mem_ctx, const char *backend_name,
 130                                    struct tevent_context *event_ctx,
 131                                    struct loadparm_context *lp_ctx,
 132                                    struct share_context **ctx)
 133 {
 134         const struct share_ops *ops;
 135
 136         ops = share_backend_by_name(backend_name);
 137         if (!ops) {
 138                 DEBUG(0, ("share_init_connection: share backend [%s] not found!\n", backend_name));
 139                 return NT_STATUS_INTERNAL_ERROR;
 140         }
 141
 142         return ops->init(mem_ctx, ops, event_ctx, lp_ctx, ctx);
 143 }
 144
 145 /*
 146   initialise the SHARE subsystem
 147 */
 148 NTSTATUS share_init(void)
 149 {
 150 #define _MODULE_PROTO(init) extern NTSTATUS init(TALLOC_CTX *);
 151         STATIC_share_MODULES_PROTO;
 152         init_module_fn static_init[] = { STATIC_share_MODULES };
 153
 154         run_init_functions(NULL, static_init);
 155
 156         return NT_STATUS_OK;
 157 }