smbconf: only include smbconf headers where needed.
[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         if (count > 0) {
457                 *service = talloc_move(mem_ctx, &tmp_service);
458         } else {
459                 *service = NULL;
460         }
461
462 done:
463         talloc_free(tmp_ctx);
464         return werr;
465 }
466
467 /**
468  * delete a service from configuration
469  */
470 static WERROR smbconf_txt_delete_share(struct smbconf_ctx *ctx,
471                                        const char *servicename)
472 {
473         return WERR_NOT_SUPPORTED;
474 }
475
476 /**
477  * set a configuration parameter to the value provided.
478  */
479 static WERROR smbconf_txt_set_parameter(struct smbconf_ctx *ctx,
480                                         const char *service,
481                                         const char *param,
482                                         const char *valstr)
483 {
484         return WERR_NOT_SUPPORTED;
485 }
486
487 /**
488  * get the value of a configuration parameter as a string
489  */
490 static WERROR smbconf_txt_get_parameter(struct smbconf_ctx *ctx,
491                                         TALLOC_CTX *mem_ctx,
492                                         const char *service,
493                                         const char *param,
494                                         char **valstr)
495 {
496         WERROR werr;
497         bool found;
498         uint32_t share_index, param_index;
499
500         werr = smbconf_txt_load_file(ctx);
501         if (!W_ERROR_IS_OK(werr)) {
502                 return werr;
503         }
504
505         found = smbconf_find_in_array(service,
506                                       pd(ctx)->cache->share_names,
507                                       pd(ctx)->cache->num_shares,
508                                       &share_index);
509         if (!found) {
510                 return WERR_NO_SUCH_SERVICE;
511         }
512
513         found = smbconf_reverse_find_in_array(param,
514                                 pd(ctx)->cache->param_names[share_index],
515                                 pd(ctx)->cache->num_params[share_index],
516                                 &param_index);
517         if (!found) {
518                 return WERR_INVALID_PARAM;
519         }
520
521         *valstr = talloc_strdup(mem_ctx,
522                         pd(ctx)->cache->param_values[share_index][param_index]);
523
524         if (*valstr == NULL) {
525                 return WERR_NOMEM;
526         }
527
528         return WERR_OK;
529 }
530
531 /**
532  * delete a parameter from configuration
533  */
534 static WERROR smbconf_txt_delete_parameter(struct smbconf_ctx *ctx,
535                                            const char *service,
536                                            const char *param)
537 {
538         return WERR_NOT_SUPPORTED;
539 }
540
541 static WERROR smbconf_txt_get_includes(struct smbconf_ctx *ctx,
542                                        TALLOC_CTX *mem_ctx,
543                                        const char *service,
544                                        uint32_t *num_includes,
545                                        char ***includes)
546 {
547         WERROR werr;
548         bool found;
549         uint32_t sidx, count;
550         TALLOC_CTX *tmp_ctx = NULL;
551         uint32_t tmp_num_includes = 0;
552         char **tmp_includes = NULL;
553
554         werr = smbconf_txt_load_file(ctx);
555         if (!W_ERROR_IS_OK(werr)) {
556                 return werr;
557         }
558
559         found = smbconf_find_in_array(service,
560                                       pd(ctx)->cache->share_names,
561                                       pd(ctx)->cache->num_shares,
562                                       &sidx);
563         if (!found) {
564                 return WERR_NO_SUCH_SERVICE;
565         }
566
567         tmp_ctx = talloc_stackframe();
568
569         for (count = 0; count < pd(ctx)->cache->num_params[sidx]; count++) {
570                 if (strequal(pd(ctx)->cache->param_names[sidx][count],
571                              "include"))
572                 {
573                         werr = smbconf_add_string_to_array(tmp_ctx,
574                                 &tmp_includes,
575                                 tmp_num_includes,
576                                 pd(ctx)->cache->param_values[sidx][count]);
577                         if (!W_ERROR_IS_OK(werr)) {
578                                 goto done;
579                         }
580                         tmp_num_includes++;
581                 }
582         }
583
584         *num_includes = tmp_num_includes;
585         if (*num_includes > 0) {
586                 *includes = talloc_move(mem_ctx, &tmp_includes);
587                 if (*includes == NULL) {
588                         werr = WERR_NOMEM;
589                         goto done;
590                 }
591         } else {
592                 *includes = NULL;
593         }
594
595         werr = WERR_OK;
596
597 done:
598         talloc_free(tmp_ctx);
599         return werr;
600 }
601
602 static WERROR smbconf_txt_set_includes(struct smbconf_ctx *ctx,
603                                        const char *service,
604                                        uint32_t num_includes,
605                                        const char **includes)
606 {
607         return WERR_NOT_SUPPORTED;
608 }
609
610 static WERROR smbconf_txt_delete_includes(struct smbconf_ctx *ctx,
611                                           const char *service)
612 {
613         return WERR_NOT_SUPPORTED;
614 }
615
616 static WERROR smbconf_txt_transaction_start(struct smbconf_ctx *ctx)
617 {
618         return WERR_OK;
619 }
620
621 static WERROR smbconf_txt_transaction_commit(struct smbconf_ctx *ctx)
622 {
623         return WERR_OK;
624 }
625
626 static WERROR smbconf_txt_transaction_cancel(struct smbconf_ctx *ctx)
627 {
628         return WERR_OK;
629 }
630
631 static struct smbconf_ops smbconf_ops_txt = {
632         .init                   = smbconf_txt_init,
633         .shutdown               = smbconf_txt_shutdown,
634         .requires_messaging     = smbconf_txt_requires_messaging,
635         .is_writeable           = smbconf_txt_is_writeable,
636         .open_conf              = smbconf_txt_open,
637         .close_conf             = smbconf_txt_close,
638         .get_csn                = smbconf_txt_get_csn,
639         .drop                   = smbconf_txt_drop,
640         .get_share_names        = smbconf_txt_get_share_names,
641         .share_exists           = smbconf_txt_share_exists,
642         .create_share           = smbconf_txt_create_share,
643         .get_share              = smbconf_txt_get_share,
644         .delete_share           = smbconf_txt_delete_share,
645         .set_parameter          = smbconf_txt_set_parameter,
646         .get_parameter          = smbconf_txt_get_parameter,
647         .delete_parameter       = smbconf_txt_delete_parameter,
648         .get_includes           = smbconf_txt_get_includes,
649         .set_includes           = smbconf_txt_set_includes,
650         .delete_includes        = smbconf_txt_delete_includes,
651         .transaction_start      = smbconf_txt_transaction_start,
652         .transaction_commit     = smbconf_txt_transaction_commit,
653         .transaction_cancel     = smbconf_txt_transaction_cancel,
654 };
655
656
657 /**
658  * initialize the smbconf text backend
659  * the only function that is exported from this module
660  */
661 WERROR smbconf_init_txt(TALLOC_CTX *mem_ctx,
662                         struct smbconf_ctx **conf_ctx,
663                         const char *path)
664 {
665         WERROR werr;
666
667         werr = smbconf_init_internal(mem_ctx, conf_ctx, path, &smbconf_ops_txt);
668         if (!W_ERROR_IS_OK(werr)) {
669                 return werr;
670         }
671
672         return smbconf_txt_load_file(*conf_ctx);
673 }