Merge branch 'v4-0-test' of ssh://git.samba.org/data/git/samba into v4-0-test

[sfrench/samba-autobuild/.git] / source4 / param / share_classic.c

diff --git a/source4/param/share_classic.c b/source4/param/share_classic.c
index 46a853b41a0ec938e9f1ef981b9000dbc21a064e..bac1aac2d78f33ca82312a53cb8599af31309ad6 100644 (file)
--- a/source4/param/share_classic.c
+++ b/source4/param/share_classic.c
@@ -1,7 +1,7 @@
 /* 
    Unix SMB/CIFS implementation.
    
-   Classic file based services configuration
+   Classic file based shares configuration
    
    Copyright (C) Simo Sorce    2006
    
@@ -23,7 +23,11 @@
 #include "param/share.h"
 #include "param/param.h"
 
-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) {
@@ -32,15 +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 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;
 
@@ -53,7 +61,7 @@ static const char *sclassic_string_option(struct share_config *scfg, const char
                *val = '\0';
                val++;
 
-               ret = lp_parm_string(s, parm, val);
+               ret = lp_parm_string(lp_ctx, s, parm, val);
                if (!ret) {
                        ret = defval;
                }
@@ -66,25 +74,25 @@ static const char *sclassic_string_option(struct share_config *scfg, const char
        }
 
        if (strcmp(opt_name, SHARE_PATH) == 0) {
-               return lp_pathname(s);
+               return lp_pathname(s, lp_default_service(lp_ctx));
        }
 
        if (strcmp(opt_name, SHARE_COMMENT) == 0) {
-               return lp_comment(s);
+               return lp_comment(s, lp_default_service(lp_ctx));
        }
 
        if (strcmp(opt_name, SHARE_VOLUME) == 0) {
-               return volume_label(s);
+               return volume_label(s, lp_default_service(lp_ctx));
        }
 
        if (strcmp(opt_name, SHARE_TYPE) == 0) {
-               if (lp_print_ok(s)) {
+               if (lp_print_ok(s, lp_default_service(lp_ctx))) {
                        return "PRINTER";
                }
-               if (strcmp("NTFS", lp_fstype(s)) == 0) {
+               if (strcmp("NTFS", lp_fstype(s, lp_default_service(lp_ctx))) == 0) {
                        return "DISK";
                }
-               return lp_fstype(s);
+               return lp_fstype(s, lp_default_service(lp_ctx));
        }
 
        if (strcmp(opt_name, SHARE_PASSWORD) == 0) {
@@ -101,6 +109,8 @@ static int sclassic_int_option(struct share_config *scfg, const char *opt_name,
 {
        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;
 
@@ -113,7 +123,7 @@ static int sclassic_int_option(struct share_config *scfg, const char *opt_name,
                *val = '\0';
                val++;
 
-               ret = lp_parm_int(s, parm, val, defval);
+               ret = lp_parm_int(lp_ctx, s, parm, val, defval);
                if (!ret) {
                        ret = defval;
                }
@@ -122,27 +132,27 @@ static int sclassic_int_option(struct share_config *scfg, const char *opt_name,
        }
 
        if (strcmp(opt_name, SHARE_CSC_POLICY) == 0) {
-               return lp_csc_policy(s);
+               return lp_csc_policy(s, lp_default_service(lp_ctx));
        }
 
        if (strcmp(opt_name, SHARE_MAX_CONNECTIONS) == 0) {
-               return lp_max_connections(s);
+               return lp_max_connections(s, lp_default_service(lp_ctx));
        }
 
        if (strcmp(opt_name, SHARE_CREATE_MASK) == 0) {
-               return lp_create_mask(s);
+               return lp_create_mask(s, lp_default_service(lp_ctx));
        }
 
        if (strcmp(opt_name, SHARE_DIR_MASK) == 0) {
-               return lp_dir_mask(s);
+               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);
+               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);
+               return lp_force_create_mode(s, lp_default_service(lp_ctx));
        }
 
 
@@ -157,19 +167,21 @@ static bool sclassic_bool_option(struct share_config *scfg, const char *opt_name
 {
        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, parm, val, defval);
+               ret = lp_parm_bool(lp_ctx, s, parm, val, defval);
                talloc_free(parm);
                return ret;
        }
@@ -179,39 +191,43 @@ static bool sclassic_bool_option(struct share_config *scfg, const char *opt_name
        }
 
        if (strcmp(opt_name, SHARE_BROWSEABLE) == 0) {
-               return lp_browseable(s);
+               return lp_browseable(s, lp_default_service(lp_ctx));
        }
 
        if (strcmp(opt_name, SHARE_READONLY) == 0) {
-               return lp_readonly(s);
+               return lp_readonly(s, lp_default_service(lp_ctx));
        }
 
        if (strcmp(opt_name, SHARE_MAP_SYSTEM) == 0) {
-               return lp_map_system(s);
+               return lp_map_system(s, lp_default_service(lp_ctx));
        }
 
        if (strcmp(opt_name, SHARE_MAP_HIDDEN) == 0) {
-               return lp_map_hidden(s);
+               return lp_map_hidden(s, lp_default_service(lp_ctx));
        }
 
        if (strcmp(opt_name, SHARE_MAP_ARCHIVE) == 0) {
-               return lp_map_archive(s);
+               return lp_map_archive(s, lp_default_service(lp_ctx));
        }
 
        if (strcmp(opt_name, SHARE_STRICT_LOCKING) == 0) {
-               return lp_strict_locking(s);
+               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);
+               return lp_strict_sync(s, lp_default_service(lp_ctx));
        }
 
        if (strcmp(opt_name, SHARE_MSDFS_ROOT) == 0) {
-               return lp_msdfs_root(s);
+               return lp_msdfs_root(s, lp_default_service(lp_ctx));
        }
 
        if (strcmp(opt_name, SHARE_CI_FILESYSTEM) == 0) {
-               return lp_ci_filesystem(s);
+               return lp_ci_filesystem(s, lp_default_service(lp_ctx));
        }
 
        DEBUG(0,("request for unknown share bool option '%s'\n",
@@ -224,6 +240,8 @@ static const char **sclassic_string_list_option(TALLOC_CTX *mem_ctx, struct shar
 {
        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;
 
@@ -236,21 +254,21 @@ static const char **sclassic_string_list_option(TALLOC_CTX *mem_ctx, struct shar
                *val = '\0';
                val++;
 
-               ret = lp_parm_string_list(s, 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);
+               return lp_hostsallow(s, lp_default_service(lp_ctx));
        }
 
        if (strcmp(opt_name, SHARE_HOSTS_DENY) == 0) {
-               return lp_hostsdeny(s);
+               return lp_hostsdeny(s, lp_default_service(lp_ctx));
        }
 
        if (strcmp(opt_name, SHARE_NTVFS_HANDLER) == 0) {
-               return lp_ntvfs_handler(s);
+               return lp_ntvfs_handler(s, lp_default_service(lp_ctx));
        }
 
        DEBUG(0,("request for unknown share list option '%s'\n",
@@ -268,7 +286,7 @@ static NTSTATUS sclassic_list_all(TALLOC_CTX *mem_ctx,
        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) {
@@ -277,7 +295,7 @@ static NTSTATUS sclassic_list_all(TALLOC_CTX *mem_ctx,
        }
 
        for (i = 0; i < num_services; i++) {
-               n[i] = talloc_strdup(n, lp_servicename(lp_servicebynum(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);
@@ -299,7 +317,7 @@ static NTSTATUS sclassic_get_config(TALLOC_CTX *mem_ctx,
        struct share_config *s;
        struct loadparm_service *service;
 
-       service = lp_service(name);
+       service = lp_service((struct loadparm_context *)ctx->priv_data, name);
 
        if (service == NULL) {
                return NT_STATUS_OBJECT_NAME_NOT_FOUND;
@@ -326,19 +344,19 @@ static 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);
 }