ab1b4bf904a2405e44816223fde34644011750b3
[gd/samba-autobuild/.git] / source4 / param / share_classic.c
1 /* 
2    Unix SMB/CIFS implementation.
3    
4    Classic file 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 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
26 static NTSTATUS sclassic_init(TALLOC_CTX *mem_ctx, 
27                               const struct share_ops *ops, 
28                               struct share_context **ctx)
29 {
30         *ctx = talloc(mem_ctx, struct share_context);
31         if (!*ctx) {
32                 DEBUG(0, ("ERROR: Out of memory!\n"));
33                 return NT_STATUS_NO_MEMORY;
34         }
35
36         (*ctx)->ops = ops;
37         (*ctx)->priv_data = global_loadparm;
38
39         return NT_STATUS_OK;
40 }
41
42 static const char *sclassic_string_option(struct share_config *scfg, 
43                                           const char *opt_name, 
44                                           const char *defval)
45 {
46         struct loadparm_service *s = talloc_get_type(scfg->opaque, 
47                                                      struct loadparm_service);
48         char *parm, *val;
49         const char *ret;
50
51         if (strchr(opt_name, ':')) {
52                 parm = talloc_strdup(scfg, opt_name);
53                 if (!parm) {
54                         return NULL;
55                 }
56                 val = strchr(parm, ':');
57                 *val = '\0';
58                 val++;
59
60                 ret = lp_parm_string(global_loadparm, s, parm, val);
61                 if (!ret) {
62                         ret = defval;
63                 }
64                 talloc_free(parm);
65                 return ret;
66         }
67
68         if (strcmp(opt_name, SHARE_NAME) == 0) {
69                 return scfg->name;
70         }
71
72         if (strcmp(opt_name, SHARE_PATH) == 0) {
73                 return lp_pathname(s);
74         }
75
76         if (strcmp(opt_name, SHARE_COMMENT) == 0) {
77                 return lp_comment(s);
78         }
79
80         if (strcmp(opt_name, SHARE_VOLUME) == 0) {
81                 return volume_label(s);
82         }
83
84         if (strcmp(opt_name, SHARE_TYPE) == 0) {
85                 if (lp_print_ok(s)) {
86                         return "PRINTER";
87                 }
88                 if (strcmp("NTFS", lp_fstype(s)) == 0) {
89                         return "DISK";
90                 }
91                 return lp_fstype(s);
92         }
93
94         if (strcmp(opt_name, SHARE_PASSWORD) == 0) {
95                 return defval;
96         }
97
98         DEBUG(0,("request for unknown share string option '%s'\n",
99                  opt_name));
100
101         return defval;
102 }
103
104 static int sclassic_int_option(struct share_config *scfg, const char *opt_name, int defval)
105 {
106         struct loadparm_service *s = talloc_get_type(scfg->opaque, 
107                                                      struct loadparm_service);
108         char *parm, *val;
109         int ret;
110
111         if (strchr(opt_name, ':')) {
112                 parm = talloc_strdup(scfg, opt_name);
113                 if (!parm) {
114                         return -1;
115                 }
116                 val = strchr(parm, ':');
117                 *val = '\0';
118                 val++;
119
120                 ret = lp_parm_int(global_loadparm, s, parm, val, defval);
121                 if (!ret) {
122                         ret = defval;
123                 }
124                 talloc_free(parm);
125                 return ret;
126         }
127
128         if (strcmp(opt_name, SHARE_CSC_POLICY) == 0) {
129                 return lp_csc_policy(s);
130         }
131
132         if (strcmp(opt_name, SHARE_MAX_CONNECTIONS) == 0) {
133                 return lp_max_connections(s);
134         }
135
136         if (strcmp(opt_name, SHARE_CREATE_MASK) == 0) {
137                 return lp_create_mask(s);
138         }
139
140         if (strcmp(opt_name, SHARE_DIR_MASK) == 0) {
141                 return lp_dir_mask(s);
142         }
143
144         if (strcmp(opt_name, SHARE_FORCE_DIR_MODE) == 0) {
145                 return lp_force_dir_mode(s);
146         }
147
148         if (strcmp(opt_name, SHARE_FORCE_CREATE_MODE) == 0) {
149                 return lp_force_create_mode(s);
150         }
151
152
153         DEBUG(0,("request for unknown share int option '%s'\n",
154                  opt_name));
155
156         return defval;
157 }
158
159 static bool sclassic_bool_option(struct share_config *scfg, const char *opt_name, 
160                           bool defval)
161 {
162         struct loadparm_service *s = talloc_get_type(scfg->opaque, 
163                                                      struct loadparm_service);
164         char *parm, *val;
165         bool ret;
166
167         if (strchr(opt_name, ':')) {
168                 parm = talloc_strdup(scfg, opt_name);
169                 if(!parm) {
170                         return false;
171                 }
172                 val = strchr(parm, ':');
173                 *val = '\0';
174                 val++;
175
176                 ret = lp_parm_bool(global_loadparm, s, parm, val, defval);
177                 talloc_free(parm);
178                 return ret;
179         }
180
181         if (strcmp(opt_name, SHARE_AVAILABLE) == 0) {
182                 return s != NULL;
183         }
184
185         if (strcmp(opt_name, SHARE_BROWSEABLE) == 0) {
186                 return lp_browseable(s);
187         }
188
189         if (strcmp(opt_name, SHARE_READONLY) == 0) {
190                 return lp_readonly(s);
191         }
192
193         if (strcmp(opt_name, SHARE_MAP_SYSTEM) == 0) {
194                 return lp_map_system(s);
195         }
196
197         if (strcmp(opt_name, SHARE_MAP_HIDDEN) == 0) {
198                 return lp_map_hidden(s);
199         }
200
201         if (strcmp(opt_name, SHARE_MAP_ARCHIVE) == 0) {
202                 return lp_map_archive(s);
203         }
204
205         if (strcmp(opt_name, SHARE_STRICT_LOCKING) == 0) {
206                 return lp_strict_locking(s);
207         }
208
209         if (strcmp(opt_name, SHARE_STRICT_SYNC) == 0) {
210                 return lp_strict_sync(s);
211         }
212
213         if (strcmp(opt_name, SHARE_MSDFS_ROOT) == 0) {
214                 return lp_msdfs_root(s);
215         }
216
217         if (strcmp(opt_name, SHARE_CI_FILESYSTEM) == 0) {
218                 return lp_ci_filesystem(s);
219         }
220
221         DEBUG(0,("request for unknown share bool option '%s'\n",
222                  opt_name));
223
224         return defval;
225 }
226
227 static const char **sclassic_string_list_option(TALLOC_CTX *mem_ctx, struct share_config *scfg, const char *opt_name)
228 {
229         struct loadparm_service *s = talloc_get_type(scfg->opaque, 
230                                                      struct loadparm_service);
231         char *parm, *val;
232         const char **ret;
233
234         if (strchr(opt_name, ':')) {
235                 parm = talloc_strdup(scfg, opt_name);
236                 if (!parm) {
237                         return NULL;
238                 }
239                 val = strchr(parm, ':');
240                 *val = '\0';
241                 val++;
242
243                 ret = lp_parm_string_list(mem_ctx, global_loadparm, s, parm, val, ",;");
244                 talloc_free(parm);
245                 return ret;
246         }
247
248         if (strcmp(opt_name, SHARE_HOSTS_ALLOW) == 0) {
249                 return lp_hostsallow(s);
250         }
251
252         if (strcmp(opt_name, SHARE_HOSTS_DENY) == 0) {
253                 return lp_hostsdeny(s);
254         }
255
256         if (strcmp(opt_name, SHARE_NTVFS_HANDLER) == 0) {
257                 return lp_ntvfs_handler(s);
258         }
259
260         DEBUG(0,("request for unknown share list option '%s'\n",
261                  opt_name));
262
263         return NULL;
264 }
265
266 static NTSTATUS sclassic_list_all(TALLOC_CTX *mem_ctx,
267                                   struct share_context *ctx,
268                                   int *count,
269                                   const char ***names)
270 {
271         int i;
272         int num_services;
273         const char **n;
274        
275         num_services = lp_numservices((struct loadparm_context *)ctx->priv_data);
276
277         n = talloc_array(mem_ctx, const char *, num_services);
278         if (!n) {
279                 DEBUG(0,("ERROR: Out of memory!\n"));
280                 return NT_STATUS_NO_MEMORY;
281         }
282
283         for (i = 0; i < num_services; i++) {
284                 n[i] = talloc_strdup(n, lp_servicename(lp_servicebynum((struct loadparm_context *)ctx->priv_data, i)));
285                 if (!n[i]) {
286                         DEBUG(0,("ERROR: Out of memory!\n"));
287                         talloc_free(n);
288                         return NT_STATUS_NO_MEMORY;
289                 }
290         }
291
292         *names = n;
293         *count = num_services;
294
295         return NT_STATUS_OK;
296 }
297
298 static NTSTATUS sclassic_get_config(TALLOC_CTX *mem_ctx,
299                                     struct share_context *ctx,
300                                     const char *name,
301                                     struct share_config **scfg)
302 {
303         struct share_config *s;
304         struct loadparm_service *service;
305
306         service = lp_service((struct loadparm_context *)ctx->priv_data, name);
307
308         if (service == NULL) {
309                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
310         }
311
312         s = talloc(mem_ctx, struct share_config);
313         if (!s) {
314                 DEBUG(0,("ERROR: Out of memory!\n"));
315                 return NT_STATUS_NO_MEMORY;
316         }
317
318         s->name = talloc_strdup(s, lp_servicename(service));
319         if (!s->name) {
320                 DEBUG(0,("ERROR: Out of memory!\n"));
321                 talloc_free(s);
322                 return NT_STATUS_NO_MEMORY;
323         }
324
325         s->opaque = (void *)service;
326         s->ctx = ctx;
327         
328         *scfg = s;
329
330         return NT_STATUS_OK;
331 }
332
333 static const struct share_ops ops = {
334         .name = "classic",
335         .init = sclassic_init,
336         .string_option = sclassic_string_option,
337         .int_option = sclassic_int_option,
338         .bool_option = sclassic_bool_option,
339         .string_list_option = sclassic_string_list_option,
340         .list_all = sclassic_list_all,
341         .get_config = sclassic_get_config
342 };
343
344 NTSTATUS share_classic_init(void)
345 {
346         return share_register(&ops);
347 }
348