libsmbconf: parse an empty share as empty share, not as NULL.
[samba.git] / lib / smbconf / smbconf_txt.c
1 /*
2  *  Unix SMB/CIFS implementation.
3  *  libsmbconf - Samba configuration library, text backend
4  *  Copyright (C) Michael Adam 2008
5  *
6  *  This program is free software; you can redistribute it and/or modify
7  *  it under the terms of the GNU General Public License as published by
8  *  the Free Software Foundation; either version 3 of the License, or
9  *  (at your option) any later version.
10  *
11  *  This program is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *  GNU General Public License for more details.
15  *
16  *  You should have received a copy of the GNU General Public License
17  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20 /*
21  * This is a sample implementation of a libsmbconf text backend
22  * using the params.c parser.
23  *
24  * It is read only.
25  * Don't expect brilliant performance, since it is not hashing the lists.
26  */
27
28 #include "includes.h"
29 #include "smbconf_private.h"
30 #include "lib/smbconf/smbconf_txt.h"
31
32 struct txt_cache {
33         uint32_t current_share;
34         uint32_t num_shares;
35         char **share_names;
36         uint32_t *num_params;
37         char ***param_names;
38         char ***param_values;
39 };
40
41 struct txt_private_data {
42         struct txt_cache *cache;
43         uint64_t csn;
44         bool verbatim;
45 };
46
47 /**********************************************************************
48  *
49  * helper functions
50  *
51  **********************************************************************/
52
53 /**
54  * a convenience helper to cast the private data structure
55  */
56 static struct txt_private_data *pd(struct smbconf_ctx *ctx)
57 {
58         return (struct txt_private_data *)(ctx->data);
59 }
60
61 static bool smbconf_txt_do_section(const char *section, void *private_data)
62 {
63         WERROR werr;
64         uint32_t idx;
65         struct txt_private_data *tpd = (struct txt_private_data *)private_data;
66         struct txt_cache *cache = tpd->cache;
67
68         if (smbconf_find_in_array(section, cache->share_names,
69                                   cache->num_shares, &idx))
70         {
71                 cache->current_share = idx;
72                 return true;
73         }
74
75         werr = smbconf_add_string_to_array(cache, &(cache->share_names),
76                                            cache->num_shares, section);
77         if (!W_ERROR_IS_OK(werr)) {
78                 return false;
79         }
80         cache->current_share = cache->num_shares;
81         cache->num_shares++;
82
83         cache->param_names = talloc_realloc(cache,
84                                                   cache->param_names,
85                                                   char **,
86                                                   cache->num_shares);
87         if (cache->param_names == NULL) {
88                 return false;
89         }
90         cache->param_names[cache->current_share] = NULL;
91
92         cache->param_values = talloc_realloc(cache,
93                                                    cache->param_values,
94                                                    char **,
95                                                    cache->num_shares);
96         if (cache->param_values == NULL) {
97                 return false;
98         }
99         cache->param_values[cache->current_share] = NULL;
100
101         cache->num_params = talloc_realloc(cache,
102                                                  cache->num_params,
103                                                  uint32_t,
104                                                  cache->num_shares);
105         if (cache->num_params == NULL) {
106                 return false;
107         }
108         cache->num_params[cache->current_share] = 0;
109
110         return true;
111 }
112
113 static bool smbconf_txt_do_parameter(const char *param_name,
114                                      const char *param_value,
115                                      void *private_data)
116 {
117         WERROR werr;
118         char **param_names, **param_values;
119         uint32_t num_params;
120         uint32_t idx;
121         struct txt_private_data *tpd = (struct txt_private_data *)private_data;
122         struct txt_cache *cache = tpd->cache;
123
124         if (cache->num_shares == 0) {
125                 /*
126                  * not in any share yet,
127                  * initialize the "empty" section (NULL):
128                  * parameters without a previous [section] are stored here.
129                  */
130                 if (!smbconf_txt_do_section(NULL, private_data)) {
131                         return false;
132                 }
133         }
134
135         param_names  = cache->param_names[cache->current_share];
136         param_values = cache->param_values[cache->current_share];
137         num_params   = cache->num_params[cache->current_share];
138
139         if (!(tpd->verbatim) &&
140             smbconf_find_in_array(param_name, param_names, num_params, &idx))
141         {
142                 talloc_free(param_values[idx]);
143                 param_values[idx] = talloc_strdup(cache, param_value);
144                 if (param_values[idx] == NULL) {
145                         return false;
146                 }
147                 return true;
148         }
149         werr = smbconf_add_string_to_array(cache,
150                                 &(cache->param_names[cache->current_share]),
151                                 num_params, param_name);
152         if (!W_ERROR_IS_OK(werr)) {
153                 return false;
154         }
155         werr = smbconf_add_string_to_array(cache,
156                                 &(cache->param_values[cache->current_share]),
157                                 num_params, param_value);
158         cache->num_params[cache->current_share]++;
159         return W_ERROR_IS_OK(werr);
160 }
161
162 static void smbconf_txt_flush_cache(struct smbconf_ctx *ctx)
163 {
164         talloc_free(pd(ctx)->cache);
165         pd(ctx)->cache = NULL;
166 }
167
168 static WERROR smbconf_txt_init_cache(struct smbconf_ctx *ctx)
169 {
170         if (pd(ctx)->cache != NULL) {
171                 smbconf_txt_flush_cache(ctx);
172         }
173
174         pd(ctx)->cache = talloc_zero(pd(ctx), struct txt_cache);
175
176         if (pd(ctx)->cache == NULL) {
177                 return WERR_NOMEM;
178         }
179
180         return WERR_OK;
181 }
182
183 static WERROR smbconf_txt_load_file(struct smbconf_ctx *ctx)
184 {
185         WERROR werr;
186         uint64_t new_csn;
187
188         if (!file_exist(ctx->path)) {
189                 return WERR_BADFILE;
190         }
191
192         new_csn = (uint64_t)file_modtime(ctx->path);
193         if (new_csn == pd(ctx)->csn) {
194                 return WERR_OK;
195         }
196
197         werr = smbconf_txt_init_cache(ctx);
198         if (!W_ERROR_IS_OK(werr)) {
199                 return werr;
200         }
201
202         if (!pm_process(ctx->path, smbconf_txt_do_section,
203                         smbconf_txt_do_parameter, pd(ctx)))
204         {
205                 return WERR_CAN_NOT_COMPLETE;
206         }
207
208         pd(ctx)->csn = new_csn;
209
210         return WERR_OK;
211 }
212
213
214 /**********************************************************************
215  *
216  * smbconf operations: text backend implementations
217  *
218  **********************************************************************/
219
220 /**
221  * initialize the text based smbconf backend
222  */
223 static WERROR smbconf_txt_init(struct smbconf_ctx *ctx, const char *path)
224 {
225         if (path == NULL) {
226                 return WERR_BADFILE;
227         }
228         ctx->path = talloc_strdup(ctx, path);
229         if (ctx->path == NULL) {
230                 return WERR_NOMEM;
231         }
232
233         ctx->data = talloc_zero(ctx, struct txt_private_data);
234         if (ctx->data == NULL) {
235                 return WERR_NOMEM;
236         }
237
238         pd(ctx)->verbatim = true;
239
240         return WERR_OK;
241 }
242
243 static int smbconf_txt_shutdown(struct smbconf_ctx *ctx)
244 {
245         return ctx->ops->close_conf(ctx);
246 }
247
248 static bool smbconf_txt_requires_messaging(struct smbconf_ctx *ctx)
249 {
250         return false;
251 }
252
253 static bool smbconf_txt_is_writeable(struct smbconf_ctx *ctx)
254 {
255         /* no write support in this backend yet... */
256         return false;
257 }
258
259 static WERROR smbconf_txt_open(struct smbconf_ctx *ctx)
260 {
261         return smbconf_txt_load_file(ctx);
262 }
263
264 static int smbconf_txt_close(struct smbconf_ctx *ctx)
265 {
266         smbconf_txt_flush_cache(ctx);
267         return 0;
268 }
269
270 /**
271  * Get the change sequence number of the given service/parameter.
272  * service and parameter strings may be NULL.
273  */
274 static void smbconf_txt_get_csn(struct smbconf_ctx *ctx,
275                                 struct smbconf_csn *csn,
276                                 const char *service, const char *param)
277 {
278         if (csn == NULL) {
279                 return;
280         }
281
282         csn->csn = (uint64_t)file_modtime(ctx->path);
283 }
284
285 /**
286  * Drop the whole configuration (restarting empty)
287  */
288 static WERROR smbconf_txt_drop(struct smbconf_ctx *ctx)
289 {
290         return WERR_NOT_SUPPORTED;
291 }
292
293 /**
294  * get the list of share names defined in the configuration.
295  */
296 static WERROR smbconf_txt_get_share_names(struct smbconf_ctx *ctx,
297                                           TALLOC_CTX *mem_ctx,
298                                           uint32_t *num_shares,
299                                           char ***share_names)
300 {
301         uint32_t count;
302         uint32_t added_count = 0;
303         TALLOC_CTX *tmp_ctx = NULL;
304         WERROR werr = WERR_OK;
305         char **tmp_share_names = NULL;
306
307         if ((num_shares == NULL) || (share_names == NULL)) {
308                 werr = WERR_INVALID_PARAM;
309                 goto done;
310         }
311
312         werr = smbconf_txt_load_file(ctx);
313         if (!W_ERROR_IS_OK(werr)) {
314                 return werr;
315         }
316
317         tmp_ctx = talloc_stackframe();
318
319         /* make sure "global" is always listed first,
320          * possibly after NULL section */
321
322         if (smbconf_share_exists(ctx, NULL)) {
323                 werr = smbconf_add_string_to_array(tmp_ctx, &tmp_share_names,
324                                                    0, NULL);
325                 if (!W_ERROR_IS_OK(werr)) {
326                         goto done;
327                 }
328                 added_count++;
329         }
330
331         if (smbconf_share_exists(ctx, GLOBAL_NAME)) {
332                 werr = smbconf_add_string_to_array(tmp_ctx, &tmp_share_names,
333                                                    added_count, GLOBAL_NAME);
334                 if (!W_ERROR_IS_OK(werr)) {
335                         goto done;
336                 }
337                 added_count++;
338         }
339
340         for (count = 0; count < pd(ctx)->cache->num_shares; count++) {
341                 if (strequal(pd(ctx)->cache->share_names[count], GLOBAL_NAME) ||
342                     (pd(ctx)->cache->share_names[count] == NULL))
343                 {
344                         continue;
345                 }
346
347                 werr = smbconf_add_string_to_array(tmp_ctx, &tmp_share_names,
348                                         added_count,
349                                         pd(ctx)->cache->share_names[count]);
350                 if (!W_ERROR_IS_OK(werr)) {
351                         goto done;
352                 }
353                 added_count++;
354         }
355
356         *num_shares = added_count;
357         if (added_count > 0) {
358                 *share_names = talloc_move(mem_ctx, &tmp_share_names);
359         } else {
360                 *share_names = NULL;
361         }
362
363 done:
364         talloc_free(tmp_ctx);
365         return werr;
366 }
367
368 /**
369  * check if a share/service of a given name exists
370  */
371 static bool smbconf_txt_share_exists(struct smbconf_ctx *ctx,
372                                      const char *servicename)
373 {
374         WERROR werr;
375
376         werr = smbconf_txt_load_file(ctx);
377         if (!W_ERROR_IS_OK(werr)) {
378                 return false;
379         }
380
381         return smbconf_find_in_array(servicename,
382                                      pd(ctx)->cache->share_names,
383                                      pd(ctx)->cache->num_shares, NULL);
384 }
385
386 /**
387  * Add a service if it does not already exist
388  */
389 static WERROR smbconf_txt_create_share(struct smbconf_ctx *ctx,
390                                        const char *servicename)
391 {
392         return WERR_NOT_SUPPORTED;
393 }
394
395 /**
396  * get a definition of a share (service) from configuration.
397  */
398 static WERROR smbconf_txt_get_share(struct smbconf_ctx *ctx,
399                                     TALLOC_CTX *mem_ctx,
400                                     const char *servicename,
401                                     struct smbconf_service **service)
402 {
403         WERROR werr;
404         uint32_t sidx, count;
405         bool found;
406         TALLOC_CTX *tmp_ctx = NULL;
407         struct smbconf_service *tmp_service = NULL;
408
409         werr = smbconf_txt_load_file(ctx);
410         if (!W_ERROR_IS_OK(werr)) {
411                 return werr;
412         }
413
414         found = smbconf_find_in_array(servicename,
415                                       pd(ctx)->cache->share_names,
416                                       pd(ctx)->cache->num_shares,
417                                       &sidx);
418         if (!found) {
419                 return WERR_NO_SUCH_SERVICE;
420         }
421
422         tmp_ctx = talloc_stackframe();
423
424         tmp_service = talloc_zero(tmp_ctx, struct smbconf_service);
425         if (tmp_service == NULL) {
426                 werr = WERR_NOMEM;
427                 goto done;
428         }
429
430         if (servicename != NULL) {
431                 tmp_service->name = talloc_strdup(tmp_service, servicename);
432                 if (tmp_service->name == NULL) {
433                         werr = WERR_NOMEM;
434                         goto done;
435                 }
436         }
437
438         for (count = 0; count < pd(ctx)->cache->num_params[sidx]; count++) {
439                 werr = smbconf_add_string_to_array(tmp_service,
440                                 &(tmp_service->param_names),
441                                 count,
442                                 pd(ctx)->cache->param_names[sidx][count]);
443                 if (!W_ERROR_IS_OK(werr)) {
444                         goto done;
445                 }
446                 werr = smbconf_add_string_to_array(tmp_service,
447                                 &(tmp_service->param_values),
448                                 count,
449                                 pd(ctx)->cache->param_values[sidx][count]);
450                 if (!W_ERROR_IS_OK(werr)) {
451                         goto done;
452                 }
453         }
454
455         tmp_service->num_params = count;
456         *service = talloc_move(mem_ctx, &tmp_service);
457
458 done:
459         talloc_free(tmp_ctx);
460         return werr;
461 }
462
463 /**
464  * delete a service from configuration
465  */
466 static WERROR smbconf_txt_delete_share(struct smbconf_ctx *ctx,
467                                        const char *servicename)
468 {
469         return WERR_NOT_SUPPORTED;
470 }
471
472 /**
473  * set a configuration parameter to the value provided.
474  */
475 static WERROR smbconf_txt_set_parameter(struct smbconf_ctx *ctx,
476                                         const char *service,
477                                         const char *param,
478                                         const char *valstr)
479 {
480         return WERR_NOT_SUPPORTED;
481 }
482
483 /**
484  * get the value of a configuration parameter as a string
485  */
486 static WERROR smbconf_txt_get_parameter(struct smbconf_ctx *ctx,
487                                         TALLOC_CTX *mem_ctx,
488                                         const char *service,
489                                         const char *param,
490                                         char **valstr)
491 {
492         WERROR werr;
493         bool found;
494         uint32_t share_index, param_index;
495
496         werr = smbconf_txt_load_file(ctx);
497         if (!W_ERROR_IS_OK(werr)) {
498                 return werr;
499         }
500
501         found = smbconf_find_in_array(service,
502                                       pd(ctx)->cache->share_names,
503                                       pd(ctx)->cache->num_shares,
504                                       &share_index);
505         if (!found) {
506                 return WERR_NO_SUCH_SERVICE;
507         }
508
509         found = smbconf_reverse_find_in_array(param,
510                                 pd(ctx)->cache->param_names[share_index],
511                                 pd(ctx)->cache->num_params[share_index],
512                                 &param_index);
513         if (!found) {
514                 return WERR_INVALID_PARAM;
515         }
516
517         *valstr = talloc_strdup(mem_ctx,
518                         pd(ctx)->cache->param_values[share_index][param_index]);
519
520         if (*valstr == NULL) {
521                 return WERR_NOMEM;
522         }
523
524         return WERR_OK;
525 }
526
527 /**
528  * delete a parameter from configuration
529  */
530 static WERROR smbconf_txt_delete_parameter(struct smbconf_ctx *ctx,
531                                            const char *service,
532                                            const char *param)
533 {
534         return WERR_NOT_SUPPORTED;
535 }
536
537 static WERROR smbconf_txt_get_includes(struct smbconf_ctx *ctx,
538                                        TALLOC_CTX *mem_ctx,
539                                        const char *service,
540                                        uint32_t *num_includes,
541                                        char ***includes)
542 {
543         WERROR werr;
544         bool found;
545         uint32_t sidx, count;
546         TALLOC_CTX *tmp_ctx = NULL;
547         uint32_t tmp_num_includes = 0;
548         char **tmp_includes = NULL;
549
550         werr = smbconf_txt_load_file(ctx);
551         if (!W_ERROR_IS_OK(werr)) {
552                 return werr;
553         }
554
555         found = smbconf_find_in_array(service,
556                                       pd(ctx)->cache->share_names,
557                                       pd(ctx)->cache->num_shares,
558                                       &sidx);
559         if (!found) {
560                 return WERR_NO_SUCH_SERVICE;
561         }
562
563         tmp_ctx = talloc_stackframe();
564
565         for (count = 0; count < pd(ctx)->cache->num_params[sidx]; count++) {
566                 if (strequal(pd(ctx)->cache->param_names[sidx][count],
567                              "include"))
568                 {
569                         werr = smbconf_add_string_to_array(tmp_ctx,
570                                 &tmp_includes,
571                                 tmp_num_includes,
572                                 pd(ctx)->cache->param_values[sidx][count]);
573                         if (!W_ERROR_IS_OK(werr)) {
574                                 goto done;
575                         }
576                         tmp_num_includes++;
577                 }
578         }
579
580         *num_includes = tmp_num_includes;
581         if (*num_includes > 0) {
582                 *includes = talloc_move(mem_ctx, &tmp_includes);
583                 if (*includes == NULL) {
584                         werr = WERR_NOMEM;
585                         goto done;
586                 }
587         } else {
588                 *includes = NULL;
589         }
590
591         werr = WERR_OK;
592
593 done:
594         talloc_free(tmp_ctx);
595         return werr;
596 }
597
598 static WERROR smbconf_txt_set_includes(struct smbconf_ctx *ctx,
599                                        const char *service,
600                                        uint32_t num_includes,
601                                        const char **includes)
602 {
603         return WERR_NOT_SUPPORTED;
604 }
605
606 static WERROR smbconf_txt_delete_includes(struct smbconf_ctx *ctx,
607                                           const char *service)
608 {
609         return WERR_NOT_SUPPORTED;
610 }
611
612 static WERROR smbconf_txt_transaction_start(struct smbconf_ctx *ctx)
613 {
614         return WERR_OK;
615 }
616
617 static WERROR smbconf_txt_transaction_commit(struct smbconf_ctx *ctx)
618 {
619         return WERR_OK;
620 }
621
622 static WERROR smbconf_txt_transaction_cancel(struct smbconf_ctx *ctx)
623 {
624         return WERR_OK;
625 }
626
627 static struct smbconf_ops smbconf_ops_txt = {
628         .init                   = smbconf_txt_init,
629         .shutdown               = smbconf_txt_shutdown,
630         .requires_messaging     = smbconf_txt_requires_messaging,
631         .is_writeable           = smbconf_txt_is_writeable,
632         .open_conf              = smbconf_txt_open,
633         .close_conf             = smbconf_txt_close,
634         .get_csn                = smbconf_txt_get_csn,
635         .drop                   = smbconf_txt_drop,
636         .get_share_names        = smbconf_txt_get_share_names,
637         .share_exists           = smbconf_txt_share_exists,
638         .create_share           = smbconf_txt_create_share,
639         .get_share              = smbconf_txt_get_share,
640         .delete_share           = smbconf_txt_delete_share,
641         .set_parameter          = smbconf_txt_set_parameter,
642         .get_parameter          = smbconf_txt_get_parameter,
643         .delete_parameter       = smbconf_txt_delete_parameter,
644         .get_includes           = smbconf_txt_get_includes,
645         .set_includes           = smbconf_txt_set_includes,
646         .delete_includes        = smbconf_txt_delete_includes,
647         .transaction_start      = smbconf_txt_transaction_start,
648         .transaction_commit     = smbconf_txt_transaction_commit,
649         .transaction_cancel     = smbconf_txt_transaction_cancel,
650 };
651
652
653 /**
654  * initialize the smbconf text backend
655  * the only function that is exported from this module
656  */
657 WERROR smbconf_init_txt(TALLOC_CTX *mem_ctx,
658                         struct smbconf_ctx **conf_ctx,
659                         const char *path)
660 {
661         WERROR werr;
662
663         werr = smbconf_init_internal(mem_ctx, conf_ctx, path, &smbconf_ops_txt);
664         if (!W_ERROR_IS_OK(werr)) {
665                 return werr;
666         }
667
668         return smbconf_txt_load_file(*conf_ctx);
669 }