source4/param/share.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    Modular services 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 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 "param/share.h"
  25 #include "build.h"
  26
  27 const char *share_string_option(struct share_config *scfg, const char *opt_name, const char *defval)
  28 {
  29         return scfg->ctx->ops->string_option(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] = malloc(sizeof(struct share_ops));
 120         if (!backends[i]) {
 121                 smb_panic("out of memory in share_register");
 122         }
 123
 124         backends[i] = smb_xmemdup(ops, sizeof(*ops));
 125         backends[i]->name = smb_xstrdup(ops->name);
 126
 127         backends[i + 1] = NULL;
 128
 129         DEBUG(3, ("SHARE backend [%s] registered.\n", ops->name));
 130
 131         return NT_STATUS_OK;
 132 }
 133
 134 NTSTATUS share_get_context_by_name(TALLOC_CTX *mem_ctx,
 135                                                                    const char *backend_name,
 136                                                                    struct share_context **ctx)
 137 {
 138         const struct share_ops *ops;
 139
 140         ops = share_backend_by_name(backend_name);
 141         if (!ops) {
 142                 DEBUG(0, ("share_init_connection: share backend [%s] not found!\n", lp_share_backend()));
 143                 return NT_STATUS_INTERNAL_ERROR;
 144         }
 145
 146         return ops->init(mem_ctx, ops, ctx);
 147 }
 148
 149 NTSTATUS share_get_context(TALLOC_CTX *mem_ctx, struct share_context **ctx)
 150 {
 151         return share_get_context_by_name(mem_ctx, lp_share_backend(), ctx);
 152 }
 153
 154 /*
 155   initialise the SHARE subsystem
 156 */
 157 NTSTATUS share_init(void)
 158 {
 159         init_module_fn static_init[] = STATIC_share_MODULES;
 160         init_module_fn *shared_init = load_samba_modules(NULL, "share");
 161
 162         run_init_functions(static_init);
 163         run_init_functions(shared_init);
 164
 165         talloc_free(shared_init);
 166
 167         return NT_STATUS_OK;
 168 }