r25446: Merge some changes I made on the way home from SFO:
[jelmer/samba4-debian.git] / source / param / share_ldb.c
1 /* 
2    Unix SMB/CIFS implementation.
3    
4    LDB 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 "ldb/include/ldb.h"
24 #include "ldb/include/ldb_errors.h"
25 #include "auth/auth.h"
26 #include "db_wrap.h"
27 #include "param/share.h"
28 #include "param/param.h"
29
30 static NTSTATUS sldb_init(TALLOC_CTX *mem_ctx, const struct share_ops *ops, struct share_context **ctx)
31 {
32         struct ldb_context *sdb;
33
34         *ctx = talloc(mem_ctx, struct share_context);
35         if (!*ctx) {
36                 DEBUG(0, ("ERROR: Out of memory!\n"));
37                 return NT_STATUS_NO_MEMORY;
38         }
39         
40         sdb = ldb_wrap_connect(*ctx, global_loadparm, 
41                                private_path(*ctx, global_loadparm, "share.ldb"),
42                                system_session(*ctx),
43                                NULL, 0, NULL);
44
45         if (!sdb) {
46                 talloc_free(*ctx);
47                 return NT_STATUS_UNSUCCESSFUL;
48         }
49
50         (*ctx)->ops = ops;
51         (*ctx)->priv_data = (void *)sdb;
52
53         return NT_STATUS_OK;
54 }
55
56 static const char *sldb_string_option(struct share_config *scfg, const char *opt_name, const char *defval)
57 {
58         struct ldb_message *msg;
59         struct ldb_message_element *el;
60
61         if (scfg == NULL) return defval;
62
63         msg = talloc_get_type(scfg->opaque, struct ldb_message);
64
65         if (strchr(opt_name, ':')) {
66                 char *name, *p;
67
68                 name = talloc_strdup(scfg, opt_name);
69                 if (!name) {
70                         return NULL;
71                 }
72                 p = strchr(name, ':');
73                 *p = '-';
74
75                 el = ldb_msg_find_element(msg, name);
76         } else {
77                 el = ldb_msg_find_element(msg, opt_name);
78         }
79
80         if (el == NULL) {
81                 return defval;
82         }
83
84         return (const char *)(el->values[0].data);
85 }
86
87 static int sldb_int_option(struct share_config *scfg, const char *opt_name, int defval)
88 {
89         const char *val;
90         int ret;
91
92         val = sldb_string_option(scfg, opt_name, NULL);
93         if (val == NULL) return defval;
94
95         errno = 0;
96         ret = (int)strtol(val, NULL, 10);
97         if (errno) return -1;
98
99         return ret;
100 }
101
102 static BOOL sldb_bool_option(struct share_config *scfg, const char *opt_name, BOOL defval)
103 {
104         const char *val;
105
106         val = sldb_string_option(scfg, opt_name, NULL);
107         if (val == NULL) return defval;
108
109         if (strcasecmp(val, "true") == 0) return True;
110
111         return False;
112 }
113
114 static const char **sldb_string_list_option(TALLOC_CTX *mem_ctx, struct share_config *scfg, const char *opt_name)
115 {
116         struct ldb_message *msg;
117         struct ldb_message_element *el;
118         const char **list;
119         int i;
120
121         if (scfg == NULL) return NULL;
122
123         msg = talloc_get_type(scfg->opaque, struct ldb_message);
124
125         if (strchr(opt_name, ':')) {
126                 char *name, *p;
127
128                 name = talloc_strdup(scfg, opt_name);
129                 if (!name) {
130                         return NULL;
131                 }
132                 p = strchr(name, ':');
133                 *p = '-';
134
135                 el = ldb_msg_find_element(msg, name);
136         } else {
137                 el = ldb_msg_find_element(msg, opt_name);
138         }
139
140         if (el == NULL) {
141                 return NULL;
142         }
143
144         list = talloc_array(mem_ctx, const char *, el->num_values + 1);
145         if (!list) return NULL;
146
147         for (i = 0; i < el->num_values; i++) {
148                 list[i] = (const char *)(el->values[i].data);
149         }
150         list[i] = NULL;
151
152         return list;
153 }
154
155 static NTSTATUS sldb_list_all(TALLOC_CTX *mem_ctx,
156                                  struct share_context *ctx,
157                                  int *count,
158                                  const char ***names)
159 {
160         int ret, i, j;
161         const char **n;
162         struct ldb_context *ldb;
163         struct ldb_result *res;
164         TALLOC_CTX *tmp_ctx;
165
166         tmp_ctx = talloc_new(mem_ctx);
167         if (!tmp_ctx) {
168                 DEBUG(0,("ERROR: Out of memory!\n"));
169                 return NT_STATUS_NO_MEMORY;
170         }
171
172         ldb = talloc_get_type(ctx->priv_data, struct ldb_context);
173
174         ret = ldb_search(ldb, ldb_dn_new(tmp_ctx, ldb, "CN=SHARES"), LDB_SCOPE_SUBTREE, "(name=*)", NULL, &res);
175         talloc_steal(tmp_ctx, res);
176         if (ret != LDB_SUCCESS) {
177                 talloc_free(tmp_ctx);
178                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
179         }
180
181         n = talloc_array(mem_ctx, const char *, res->count);
182         if (!n) {
183                 DEBUG(0,("ERROR: Out of memory!\n"));
184                 talloc_free(tmp_ctx);
185                 return NT_STATUS_NO_MEMORY;
186         }
187
188         for (i = 0, j = 0; i < res->count; i++) {
189                 n[j] = talloc_strdup(n, ldb_msg_find_attr_as_string(res->msgs[i], "name", NULL));
190                 if (!n[j]) {
191                         DEBUG(0,("WARNING: Malformed share object in share database\n!"));
192                         continue;
193                 }
194                 j++;
195         }
196
197         *names = n;
198         *count = j;
199         talloc_free(tmp_ctx);
200
201         return NT_STATUS_OK;
202 }
203
204 static NTSTATUS sldb_get_config(TALLOC_CTX *mem_ctx,
205                          struct share_context *ctx,
206                          const char *name,
207                          struct share_config **scfg)
208 {
209         int ret;
210         struct share_config *s;
211         struct ldb_context *ldb;
212         struct ldb_result *res;
213         TALLOC_CTX *tmp_ctx;
214
215         tmp_ctx = talloc_new(mem_ctx);
216         if (!tmp_ctx) {
217                 DEBUG(0,("ERROR: Out of memory!\n"));
218                 return NT_STATUS_NO_MEMORY;
219         }
220
221         ldb = talloc_get_type(ctx->priv_data, struct ldb_context);
222
223         ret = ldb_search_exp_fmt(ldb, tmp_ctx, &res,
224                                  ldb_dn_new(tmp_ctx, ldb, "CN=SHARES"), LDB_SCOPE_SUBTREE, NULL,
225                                  "(name=%s)", name);
226         if (ret != LDB_SUCCESS || res->count > 1) {
227                 talloc_free(tmp_ctx);
228                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
229         } else if (res->count != 1) {
230                 talloc_free(tmp_ctx);
231                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
232         }
233
234         s = talloc(tmp_ctx, struct share_config);
235         if (!s) {
236                 DEBUG(0,("ERROR: Out of memory!\n"));
237                 talloc_free(tmp_ctx);
238                 return NT_STATUS_NO_MEMORY;
239         }
240
241         s->name = talloc_strdup(s, ldb_msg_find_attr_as_string(res->msgs[0], "name", NULL));
242         if (!s->name) {
243                 DEBUG(0,("ERROR: Invalid share object!\n"));
244                 talloc_free(tmp_ctx);
245                 return NT_STATUS_UNSUCCESSFUL;
246         }
247
248         s->opaque = talloc_steal(s, res->msgs[0]);
249         if (!s->opaque) {
250                 DEBUG(0,("ERROR: Invalid share object!\n"));
251                 talloc_free(tmp_ctx);
252                 return NT_STATUS_UNSUCCESSFUL;
253         }
254
255         s->ctx = ctx;
256
257         *scfg = talloc_steal(mem_ctx, s);
258
259         talloc_free(tmp_ctx);
260         return NT_STATUS_OK;
261 }
262
263 #define SHARE_ADD_STRING(name, value) do { \
264         err = ldb_msg_add_string(msg, name, value); \
265         if (err != LDB_SUCCESS) { \
266                 DEBUG(2,("ERROR: unable to add string share option %s to ldb msg\n", name)); \
267                 ret = NT_STATUS_UNSUCCESSFUL; \
268                 goto done; \
269         } } while(0)
270
271 #define SHARE_ADD_INT(name, value) do { \
272         err = ldb_msg_add_fmt(msg, name, "%d", value); \
273         if (err != LDB_SUCCESS) { \
274                 DEBUG(2,("ERROR: unable to add integer share option %s to ldb msg\n", name)); \
275                 ret = NT_STATUS_UNSUCCESSFUL; \
276                 goto done; \
277         } } while(0)
278
279 #define SHARE_ADD_BLOB(name, value) do { \
280         err = ldb_msg_add_value(msg, name, value, NULL); \
281         if (err != LDB_SUCCESS) { \
282                 DEBUG(2,("ERROR: unable to add blob share option %s to ldb msg\n", name)); \
283                 ret = NT_STATUS_UNSUCCESSFUL; \
284                 goto done; \
285         } } while(0)
286
287 NTSTATUS sldb_create(struct share_context *ctx, const char *name, struct share_info *info, int count)
288 {
289         struct ldb_context *ldb;
290         struct ldb_message *msg;
291         TALLOC_CTX *tmp_ctx;
292         NTSTATUS ret;
293         int err, i, j;
294
295         for (i = 0, j = 0; i < count && j != 0x03; i++) {
296                 if (strcasecmp(info[i].name, SHARE_TYPE) == 0) j |= 0x02;
297                 if (strcasecmp(info[i].name, SHARE_PATH) == 0) j |= 0x01;
298                 if (strcasecmp(info[i].name, SHARE_NAME) == 0) {
299                         if (strcasecmp(name, (char *)info[i].value) != 0) {
300                                 return NT_STATUS_INVALID_PARAMETER;
301                         }
302                 }
303         }
304         if (!name || j != 0x03) {
305                 return NT_STATUS_INVALID_PARAMETER;
306         }
307         
308         tmp_ctx = talloc_new(NULL);
309         if (!tmp_ctx) {
310                 DEBUG(0,("ERROR: Out of memory!\n"));
311                 return NT_STATUS_NO_MEMORY;
312         }
313
314         ldb = talloc_get_type(ctx->priv_data, struct ldb_context);
315
316         msg = ldb_msg_new(tmp_ctx);
317         if (!msg) {
318                 DEBUG(0,("ERROR: Out of memory!\n"));
319                 ret = NT_STATUS_NO_MEMORY;
320                 goto done;
321         }
322
323         /* TODO: escape info->name */
324         msg->dn = ldb_dn_new_fmt(tmp_ctx, ldb, "CN=%s,CN=SHARES", name);
325         if (!msg->dn) {
326                 DEBUG(0,("ERROR: Out of memory!\n"));
327                 ret = NT_STATUS_NO_MEMORY;
328                 goto done;
329         }
330
331         SHARE_ADD_STRING("objectClass", "top");
332         SHARE_ADD_STRING("objectClass", "share");
333         SHARE_ADD_STRING("cn", name);
334         SHARE_ADD_STRING(SHARE_NAME, name);
335
336         for (i = 0; i < count; i++) {
337                 if (strcasecmp(info[i].name, SHARE_NAME) == 0) continue;
338
339                 switch (info[i].type) {
340                 case SHARE_INFO_STRING:
341                         SHARE_ADD_STRING(info[i].name, (char *)info[i].value);
342                         break;
343                 case SHARE_INFO_INT:
344                         SHARE_ADD_INT(info[i].name, *((int *)info[i].value));
345                         break;
346                 case SHARE_INFO_BLOB:
347                         SHARE_ADD_BLOB(info[i].name, (DATA_BLOB *)info[i].value);
348                         break;
349                 default:
350                         DEBUG(2,("ERROR: Invalid share info type for %s\n", info[i].name));
351                         ret = NT_STATUS_INVALID_PARAMETER;
352                         goto done;
353                 }
354         }
355
356         /* TODO: Security Descriptor */
357
358         SHARE_ADD_STRING(SHARE_AVAILABLE, "True");
359         SHARE_ADD_STRING(SHARE_BROWSEABLE, "True");
360         SHARE_ADD_STRING(SHARE_READONLY, "False");
361         SHARE_ADD_STRING(SHARE_NTVFS_HANDLER, "unixuid");
362         SHARE_ADD_STRING(SHARE_NTVFS_HANDLER, "posix");
363
364         err = ldb_add(ldb, msg);
365         if (err != LDB_SUCCESS) {
366                 DEBUG(2,("ERROR: unable to add share %s to share.ldb\n"
367                          "       err=%d [%s]\n", name, err, ldb_errstring(ldb)));
368                 if (err == LDB_ERR_NO_SUCH_OBJECT) {
369                         ret = NT_STATUS_OBJECT_NAME_NOT_FOUND;
370                 } else if (err == LDB_ERR_ENTRY_ALREADY_EXISTS) {
371                         ret = NT_STATUS_OBJECT_NAME_COLLISION;
372                 } else {
373                         ret = NT_STATUS_UNSUCCESSFUL;
374                 }
375                 goto done;
376         }
377
378         ret = NT_STATUS_OK;
379 done:
380         talloc_free(tmp_ctx);
381         return ret;
382 }
383
384 #define SHARE_MOD_STRING(name, value) do { \
385         err = ldb_msg_add_empty(msg, name, LDB_FLAG_MOD_REPLACE, NULL); \
386         if (err != LDB_SUCCESS) { \
387                 DEBUG(2,("ERROR: unable to add string share option %s to ldb msg\n", name)); \
388                 ret = NT_STATUS_UNSUCCESSFUL; \
389                 goto done; \
390         } \
391         err = ldb_msg_add_string(msg, name, value); \
392         if (err != LDB_SUCCESS) { \
393                 DEBUG(2,("ERROR: unable to add string share option %s to ldb msg\n", name)); \
394                 ret = NT_STATUS_UNSUCCESSFUL; \
395                 goto done; \
396         } } while(0)
397
398 #define SHARE_MOD_INT(name, value) do { \
399         err = ldb_msg_add_empty(msg, name, LDB_FLAG_MOD_REPLACE, NULL); \
400         if (err != LDB_SUCCESS) { \
401                 DEBUG(2,("ERROR: unable to add string share option %s to ldb msg\n", name)); \
402                 ret = NT_STATUS_UNSUCCESSFUL; \
403                 goto done; \
404         } \
405         err = ldb_msg_add_fmt(msg, name, "%d", value); \
406         if (err != LDB_SUCCESS) { \
407                 DEBUG(2,("ERROR: unable to add integer share option %s to ldb msg\n", name)); \
408                 ret = NT_STATUS_UNSUCCESSFUL; \
409                 goto done; \
410         } } while(0)
411
412 #define SHARE_MOD_BLOB(name, value) do { \
413         err = ldb_msg_add_empty(msg, name, LDB_FLAG_MOD_REPLACE, NULL); \
414         if (err != LDB_SUCCESS) { \
415                 DEBUG(2,("ERROR: unable to add string share option %s to ldb msg\n", name)); \
416                 ret = NT_STATUS_UNSUCCESSFUL; \
417                 goto done; \
418         } \
419         err = ldb_msg_add_value(msg, name, value, NULL); \
420         if (err != LDB_SUCCESS) { \
421                 DEBUG(2,("ERROR: unable to add blob share option %s to ldb msg\n", name)); \
422                 ret = NT_STATUS_UNSUCCESSFUL; \
423                 goto done; \
424         } } while(0)
425
426 NTSTATUS sldb_set(struct share_context *ctx, const char *name, struct share_info *info, int count)
427 {
428         struct ldb_context *ldb;
429         struct ldb_message *msg;
430         TALLOC_CTX *tmp_ctx;
431         NTSTATUS ret;
432         bool do_rename = False;
433         char *newname;
434         int err, i;
435
436         if (!name) {
437                 return NT_STATUS_INVALID_PARAMETER;
438         }
439         
440         tmp_ctx = talloc_new(NULL);
441         if (!tmp_ctx) {
442                 DEBUG(0,("ERROR: Out of memory!\n"));
443                 return NT_STATUS_NO_MEMORY;
444         }
445
446         ldb = talloc_get_type(ctx->priv_data, struct ldb_context);
447
448         msg = ldb_msg_new(tmp_ctx);
449         if (!msg) {
450                 DEBUG(0,("ERROR: Out of memory!\n"));
451                 ret = NT_STATUS_NO_MEMORY;
452                 goto done;
453         }
454
455         /* TODO: escape name */
456         msg->dn = ldb_dn_new_fmt(tmp_ctx, ldb, "CN=%s,CN=SHARES", name);
457         if (!msg->dn) {
458                 DEBUG(0,("ERROR: Out of memory!\n"));
459                 ret = NT_STATUS_NO_MEMORY;
460                 goto done;
461         }
462
463         for (i = 0; i < count; i++) {
464                 if (strcasecmp(info[i].name, SHARE_NAME) == 0) {
465                         if (strcasecmp(name, (char *)info[i].value) != 0) {
466                                 do_rename = True;
467                                 newname = (char *)info[i].value;
468                                 SHARE_MOD_STRING("cn", (char *)info[i].value);
469                         }
470                 }
471
472                 switch (info[i].type) {
473                 case SHARE_INFO_STRING:
474                         SHARE_MOD_STRING(info[i].name, (char *)info[i].value);
475                         break;
476                 case SHARE_INFO_INT:
477                         SHARE_MOD_INT(info[i].name, *((int *)info[i].value));
478                         break;
479                 case SHARE_INFO_BLOB:
480                         SHARE_MOD_BLOB(info[i].name, (DATA_BLOB *)info[i].value);
481                         break;
482                 default:
483                         DEBUG(2,("ERROR: Invalid share info type for %s\n", info[i].name));
484                         ret = NT_STATUS_INVALID_PARAMETER;
485                         goto done;
486                 }
487         }
488
489         if (do_rename) {
490                 struct ldb_dn *olddn, *newdn;
491
492                 olddn = msg->dn;
493
494                 /* TODO: escape newname */
495                 newdn = ldb_dn_new_fmt(tmp_ctx, ldb, "CN=%s,CN=SHARES", newname);
496                 if (!newdn) {
497                         DEBUG(0,("ERROR: Out of memory!\n"));
498                         ret = NT_STATUS_NO_MEMORY;
499                         goto done;
500                 }
501
502                 err = ldb_rename(ldb, olddn, newdn);
503                 if (err != LDB_SUCCESS) {
504                         DEBUG(2,("ERROR: unable to rename share %s (to %s)\n"
505                                  "       err=%d [%s]\n", name, newname, err, ldb_errstring(ldb)));
506                         if (err == LDB_ERR_NO_SUCH_OBJECT) {
507                                 ret = NT_STATUS_OBJECT_NAME_COLLISION;
508                         } else {
509                                 ret = NT_STATUS_UNSUCCESSFUL;
510                         }
511                         goto done;
512                 }
513
514                 msg->dn = newdn;
515         }
516
517         err = ldb_modify(ldb, msg);
518         if (err != LDB_SUCCESS) {
519                 DEBUG(2,("ERROR: unable to add share %s to share.ldb\n"
520                          "       err=%d [%s]\n", name, err, ldb_errstring(ldb)));
521                 if (err == LDB_ERR_NO_SUCH_OBJECT) {
522                         ret = NT_STATUS_OBJECT_NAME_COLLISION;
523                 } else {
524                         ret = NT_STATUS_UNSUCCESSFUL;
525                 }
526                 goto done;
527         }
528
529         ret = NT_STATUS_OK;
530 done:
531         talloc_free(tmp_ctx);
532         return ret;
533 }
534
535 NTSTATUS sldb_remove(struct share_context *ctx, const char *name)
536 {
537         struct ldb_context *ldb;
538         struct ldb_dn *dn;
539         TALLOC_CTX *tmp_ctx;
540         NTSTATUS ret;
541         int err;
542
543         tmp_ctx = talloc_new(NULL);
544         if (!tmp_ctx) {
545                 DEBUG(0,("ERROR: Out of memory!\n"));
546                 return NT_STATUS_NO_MEMORY;
547         }
548
549         ldb = talloc_get_type(ctx->priv_data, struct ldb_context);
550
551         dn = ldb_dn_new_fmt(tmp_ctx, ldb, "CN=%s,CN=SHARES", name);
552         if (!dn) {
553                 DEBUG(0,("ERROR: Out of memory!\n"));
554                 ret = NT_STATUS_NO_MEMORY;
555                 goto done;
556         }
557
558         err = ldb_delete(ldb, dn);
559         if (err != LDB_SUCCESS) {
560                 DEBUG(2,("ERROR: unable to remove share %s from share.ldb\n"
561                          "       err=%d [%s]\n", name, err, ldb_errstring(ldb)));
562                 ret = NT_STATUS_UNSUCCESSFUL;
563                 goto done;
564         }
565
566         ret = NT_STATUS_OK;
567 done:
568         talloc_free(tmp_ctx);
569         return ret;
570 }
571
572 static const struct share_ops ops = {
573         .name = "ldb",
574         .init = sldb_init,
575         .string_option = sldb_string_option,
576         .int_option = sldb_int_option,
577         .bool_option = sldb_bool_option,
578         .string_list_option = sldb_string_list_option,
579         .list_all = sldb_list_all,
580         .get_config = sldb_get_config,
581         .create = sldb_create,
582         .set = sldb_set,
583         .remove = sldb_remove
584 };
585
586 NTSTATUS share_ldb_init(void)
587 {
588         return share_register(&ops);
589 }