X-Git-Url: http://git.samba.org/samba.git/?a=blobdiff_plain;f=source4%2Fparam%2Fshare_classic.c;h=bac1aac2d78f33ca82312a53cb8599af31309ad6;hb=21fc7673780aa1d7c0caab7b17ff9171238913ba;hp=794a21c5bf7d6dac54da2c79b3adcec30ccd8e82;hpb=fa257e78b5e1de1ba12e12968b1b2a6edbead7c6;p=kai%2Fsamba-autobuild%2F.git diff --git a/source4/param/share_classic.c b/source4/param/share_classic.c index 794a21c5bf7..bac1aac2d78 100644 --- a/source4/param/share_classic.c +++ b/source4/param/share_classic.c @@ -1,13 +1,13 @@ /* Unix SMB/CIFS implementation. - Classic file based services configuration + Classic file based shares configuration Copyright (C) Simo Sorce 2006 This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or + the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, @@ -16,18 +16,18 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + along with this program. If not, see . */ #include "includes.h" #include "param/share.h" +#include "param/param.h" -struct sclassic_snum { - int snum; -}; - -static NTSTATUS sclassic_init(TALLOC_CTX *mem_ctx, const struct share_ops *ops, struct share_context **ctx) +static NTSTATUS sclassic_init(TALLOC_CTX *mem_ctx, + const struct share_ops *ops, + struct event_context *event_ctx, + struct loadparm_context *lp_ctx, + struct share_context **ctx) { *ctx = talloc(mem_ctx, struct share_context); if (!*ctx) { @@ -36,14 +36,19 @@ static NTSTATUS sclassic_init(TALLOC_CTX *mem_ctx, const struct share_ops *ops, } (*ctx)->ops = ops; - (*ctx)->priv_data = NULL; + (*ctx)->priv_data = lp_ctx; return NT_STATUS_OK; } -static const char *sclassic_string_option(struct share_config *scfg, const char *opt_name, const char *defval) +static const char *sclassic_string_option(struct share_config *scfg, + const char *opt_name, + const char *defval) { - struct sclassic_snum *s = talloc_get_type(scfg->opaque, struct sclassic_snum); + struct loadparm_service *s = talloc_get_type(scfg->opaque, + struct loadparm_service); + struct loadparm_context *lp_ctx = talloc_get_type(scfg->ctx->priv_data, + struct loadparm_context); char *parm, *val; const char *ret; @@ -56,7 +61,7 @@ static const char *sclassic_string_option(struct share_config *scfg, const char *val = '\0'; val++; - ret = lp_parm_string(s->snum, parm, val); + ret = lp_parm_string(lp_ctx, s, parm, val); if (!ret) { ret = defval; } @@ -69,33 +74,43 @@ static const char *sclassic_string_option(struct share_config *scfg, const char } if (strcmp(opt_name, SHARE_PATH) == 0) { - return lp_pathname(s->snum); + return lp_pathname(s, lp_default_service(lp_ctx)); } if (strcmp(opt_name, SHARE_COMMENT) == 0) { - return lp_comment(s->snum); + return lp_comment(s, lp_default_service(lp_ctx)); } if (strcmp(opt_name, SHARE_VOLUME) == 0) { - return volume_label(s->snum); + return volume_label(s, lp_default_service(lp_ctx)); } if (strcmp(opt_name, SHARE_TYPE) == 0) { - if (lp_print_ok(s->snum)) { + if (lp_print_ok(s, lp_default_service(lp_ctx))) { return "PRINTER"; } - if (strcmp("NTFS", lp_fstype(s->snum)) == 0) { + if (strcmp("NTFS", lp_fstype(s, lp_default_service(lp_ctx))) == 0) { return "DISK"; } - return lp_fstype(s->snum); + return lp_fstype(s, lp_default_service(lp_ctx)); + } + + if (strcmp(opt_name, SHARE_PASSWORD) == 0) { + return defval; } + DEBUG(0,("request for unknown share string option '%s'\n", + opt_name)); + return defval; } -int sclassic_int_option(struct share_config *scfg, const char *opt_name, int defval) +static int sclassic_int_option(struct share_config *scfg, const char *opt_name, int defval) { - struct sclassic_snum *s = talloc_get_type(scfg->opaque, struct sclassic_snum); + struct loadparm_service *s = talloc_get_type(scfg->opaque, + struct loadparm_service); + struct loadparm_context *lp_ctx = talloc_get_type(scfg->ctx->priv_data, + struct loadparm_context); char *parm, *val; int ret; @@ -108,7 +123,7 @@ int sclassic_int_option(struct share_config *scfg, const char *opt_name, int def *val = '\0'; val++; - ret = lp_parm_int(s->snum, parm, val, defval); + ret = lp_parm_int(lp_ctx, s, parm, val, defval); if (!ret) { ret = defval; } @@ -117,88 +132,116 @@ int sclassic_int_option(struct share_config *scfg, const char *opt_name, int def } if (strcmp(opt_name, SHARE_CSC_POLICY) == 0) { - ret = lp_csc_policy(s->snum); - if (ret == -1) { - return defval; - } + return lp_csc_policy(s, lp_default_service(lp_ctx)); } if (strcmp(opt_name, SHARE_MAX_CONNECTIONS) == 0) { - ret = lp_max_connections(s->snum); - if (ret == -1) { - return defval; - } + return lp_max_connections(s, lp_default_service(lp_ctx)); + } + + if (strcmp(opt_name, SHARE_CREATE_MASK) == 0) { + return lp_create_mask(s, lp_default_service(lp_ctx)); + } + + if (strcmp(opt_name, SHARE_DIR_MASK) == 0) { + return lp_dir_mask(s, lp_default_service(lp_ctx)); + } + + if (strcmp(opt_name, SHARE_FORCE_DIR_MODE) == 0) { + return lp_force_dir_mode(s, lp_default_service(lp_ctx)); + } + + if (strcmp(opt_name, SHARE_FORCE_CREATE_MODE) == 0) { + return lp_force_create_mode(s, lp_default_service(lp_ctx)); } + + DEBUG(0,("request for unknown share int option '%s'\n", + opt_name)); + return defval; } -BOOL sclassic_bool_option(struct share_config *scfg, const char *opt_name, BOOL defval) +static bool sclassic_bool_option(struct share_config *scfg, const char *opt_name, + bool defval) { - struct sclassic_snum *s = talloc_get_type(scfg->opaque, struct sclassic_snum); + struct loadparm_service *s = talloc_get_type(scfg->opaque, + struct loadparm_service); + struct loadparm_context *lp_ctx = talloc_get_type(scfg->ctx->priv_data, + struct loadparm_context); char *parm, *val; - BOOL ret; + bool ret; if (strchr(opt_name, ':')) { parm = talloc_strdup(scfg, opt_name); if(!parm) { - return False; + return false; } val = strchr(parm, ':'); *val = '\0'; val++; - ret = lp_parm_bool(s->snum, parm, val, defval); + ret = lp_parm_bool(lp_ctx, s, parm, val, defval); talloc_free(parm); return ret; } if (strcmp(opt_name, SHARE_AVAILABLE) == 0) { - return lp_snum_ok(s->snum); + return s != NULL; } if (strcmp(opt_name, SHARE_BROWSEABLE) == 0) { - return lp_browseable(s->snum); + return lp_browseable(s, lp_default_service(lp_ctx)); } if (strcmp(opt_name, SHARE_READONLY) == 0) { - return lp_readonly(s->snum); + return lp_readonly(s, lp_default_service(lp_ctx)); } if (strcmp(opt_name, SHARE_MAP_SYSTEM) == 0) { - return lp_map_system(s->snum); + return lp_map_system(s, lp_default_service(lp_ctx)); } if (strcmp(opt_name, SHARE_MAP_HIDDEN) == 0) { - return lp_map_hidden(s->snum); + return lp_map_hidden(s, lp_default_service(lp_ctx)); } if (strcmp(opt_name, SHARE_MAP_ARCHIVE) == 0) { - return lp_map_archive(s->snum); + return lp_map_archive(s, lp_default_service(lp_ctx)); } if (strcmp(opt_name, SHARE_STRICT_LOCKING) == 0) { - return lp_strict_locking(s->snum); + return lp_strict_locking(s, lp_default_service(lp_ctx)); + } + + if (strcmp(opt_name, SHARE_OPLOCKS) == 0) { + return lp_oplocks(s, lp_default_service(lp_ctx)); } if (strcmp(opt_name, SHARE_STRICT_SYNC) == 0) { - return lp_strict_sync(s->snum); + return lp_strict_sync(s, lp_default_service(lp_ctx)); } if (strcmp(opt_name, SHARE_MSDFS_ROOT) == 0) { - return lp_msdfs_root(s->snum); + return lp_msdfs_root(s, lp_default_service(lp_ctx)); } if (strcmp(opt_name, SHARE_CI_FILESYSTEM) == 0) { - return lp_ci_filesystem(s->snum); + return lp_ci_filesystem(s, lp_default_service(lp_ctx)); } + DEBUG(0,("request for unknown share bool option '%s'\n", + opt_name)); + return defval; } -const char **sclassic_string_list_option(TALLOC_CTX *mem_ctx, struct share_config *scfg, const char *opt_name) +static const char **sclassic_string_list_option(TALLOC_CTX *mem_ctx, struct share_config *scfg, const char *opt_name) { - struct sclassic_snum *s = talloc_get_type(scfg->opaque, struct sclassic_snum); + struct loadparm_service *s = talloc_get_type(scfg->opaque, + struct loadparm_service); + struct loadparm_context *lp_ctx = talloc_get_type(scfg->ctx->priv_data, + struct loadparm_context); char *parm, *val; const char **ret; @@ -211,36 +254,39 @@ const char **sclassic_string_list_option(TALLOC_CTX *mem_ctx, struct share_confi *val = '\0'; val++; - ret = lp_parm_string_list(s->snum, parm, val, ",;"); + ret = lp_parm_string_list(mem_ctx, lp_ctx, s, parm, val, ",;"); talloc_free(parm); return ret; } if (strcmp(opt_name, SHARE_HOSTS_ALLOW) == 0) { - return lp_hostsallow(s->snum); + return lp_hostsallow(s, lp_default_service(lp_ctx)); } if (strcmp(opt_name, SHARE_HOSTS_DENY) == 0) { - return lp_hostsdeny(s->snum); + return lp_hostsdeny(s, lp_default_service(lp_ctx)); } if (strcmp(opt_name, SHARE_NTVFS_HANDLER) == 0) { - return lp_ntvfs_handler(s->snum); + return lp_ntvfs_handler(s, lp_default_service(lp_ctx)); } + DEBUG(0,("request for unknown share list option '%s'\n", + opt_name)); + return NULL; } -NTSTATUS sclassic_list_all(TALLOC_CTX *mem_ctx, - struct share_context *ctx, - int *count, - const char ***names) +static NTSTATUS sclassic_list_all(TALLOC_CTX *mem_ctx, + struct share_context *ctx, + int *count, + const char ***names) { int i; int num_services; const char **n; - num_services = lp_numservices(); + num_services = lp_numservices((struct loadparm_context *)ctx->priv_data); n = talloc_array(mem_ctx, const char *, num_services); if (!n) { @@ -249,7 +295,7 @@ NTSTATUS sclassic_list_all(TALLOC_CTX *mem_ctx, } for (i = 0; i < num_services; i++) { - n[i] = talloc_strdup(n, lp_servicename(i)); + n[i] = talloc_strdup(n, lp_servicename(lp_servicebynum((struct loadparm_context *)ctx->priv_data, i))); if (!n[i]) { DEBUG(0,("ERROR: Out of memory!\n")); talloc_free(n); @@ -263,24 +309,17 @@ NTSTATUS sclassic_list_all(TALLOC_CTX *mem_ctx, return NT_STATUS_OK; } -NTSTATUS sclassic_get_config(TALLOC_CTX *mem_ctx, - struct share_context *ctx, - const char *name, - struct share_config **scfg) +static NTSTATUS sclassic_get_config(TALLOC_CTX *mem_ctx, + struct share_context *ctx, + const char *name, + struct share_config **scfg) { - int i, snum; struct share_config *s; - struct sclassic_snum *scnum; + struct loadparm_service *service; - snum = -1; - for (i = 0; i < lp_numservices(); i++) { - if (strcasecmp_m(name, lp_servicename(i)) == 0) { - snum = i; - break; - } - } + service = lp_service((struct loadparm_context *)ctx->priv_data, name); - if (snum < 0) { + if (service == NULL) { return NT_STATUS_OBJECT_NAME_NOT_FOUND; } @@ -290,22 +329,14 @@ NTSTATUS sclassic_get_config(TALLOC_CTX *mem_ctx, return NT_STATUS_NO_MEMORY; } - s->name = talloc_strdup(s, lp_servicename(snum)); + s->name = talloc_strdup(s, lp_servicename(service)); if (!s->name) { DEBUG(0,("ERROR: Out of memory!\n")); talloc_free(s); return NT_STATUS_NO_MEMORY; } - scnum = talloc(s, struct sclassic_snum); - if (!scnum) { - DEBUG(0,("ERROR: Out of memory!\n")); - talloc_free(s); - return NT_STATUS_NO_MEMORY; - } - scnum->snum = snum; - - s->opaque = (void *)scnum; + s->opaque = (void *)service; s->ctx = ctx; *scfg = s; @@ -313,19 +344,19 @@ NTSTATUS sclassic_get_config(TALLOC_CTX *mem_ctx, return NT_STATUS_OK; } +static const struct share_ops ops = { + .name = "classic", + .init = sclassic_init, + .string_option = sclassic_string_option, + .int_option = sclassic_int_option, + .bool_option = sclassic_bool_option, + .string_list_option = sclassic_string_list_option, + .list_all = sclassic_list_all, + .get_config = sclassic_get_config +}; + NTSTATUS share_classic_init(void) { - static struct share_ops ops = { - .name = "classic", - .init = sclassic_init, - .string_option = sclassic_string_option, - .int_option = sclassic_int_option, - .bool_option = sclassic_bool_option, - .string_list_option = sclassic_string_list_option, - .list_all = sclassic_list_all, - .get_config = sclassic_get_config - }; - return share_register(&ops); }