0f77254d38137bd4dcf14d60926b00ac30328ef9
[gd/samba-autobuild/.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         sbcErr err;
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         err = smbconf_add_string_to_array(cache, &(cache->share_names),
76                                           cache->num_shares, section);
77         if (!SBC_ERROR_IS_OK(err)) {
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         sbcErr err;
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         err = smbconf_add_string_to_array(cache,
150                                 &(cache->param_names[cache->current_share]),
151                                 num_params, param_name);
152         if (!SBC_ERROR_IS_OK(err)) {
153                 return false;
154         }
155         err = 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 SBC_ERROR_IS_OK(err);
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 sbcErr 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 SBC_ERR_NOMEM;
178         }
179
180         return SBC_ERR_OK;
181 }
182
183 static sbcErr smbconf_txt_load_file(struct smbconf_ctx *ctx)
184 {
185         sbcErr err;
186         uint64_t new_csn;
187
188         if (!file_exist(ctx->path)) {
189                 return SBC_ERR_BADFILE;
190         }
191
192         new_csn = (uint64_t)file_modtime(ctx->path);
193         if (new_csn == pd(ctx)->csn) {
194                 return SBC_ERR_OK;
195         }
196
197         err = smbconf_txt_init_cache(ctx);
198         if (!SBC_ERROR_IS_OK(err)) {
199                 return err;
200         }
201
202         if (!pm_process(ctx->path, smbconf_txt_do_section,
203                         smbconf_txt_do_parameter, pd(ctx)))
204         {
205                 return SBC_ERR_CAN_NOT_COMPLETE;
206         }
207
208         pd(ctx)->csn = new_csn;
209
210         return SBC_ERR_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 sbcErr smbconf_txt_init(struct smbconf_ctx *ctx, const char *path)
224 {
225         if (path == NULL) {
226                 return SBC_ERR_BADFILE;
227         }
228         ctx->path = talloc_strdup(ctx, path);
229         if (ctx->path == NULL) {
230                 return SBC_ERR_NOMEM;
231         }
232
233         ctx->data = talloc_zero(ctx, struct txt_private_data);
234         if (ctx->data == NULL) {
235                 return SBC_ERR_NOMEM;
236         }
237
238         pd(ctx)->verbatim = true;
239
240         return SBC_ERR_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 sbcErr 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 sbcErr smbconf_txt_drop(struct smbconf_ctx *ctx)
289 {
290         return SBC_ERR_NOT_SUPPORTED;
291 }
292
293 /**
294  * get the list of share names defined in the configuration.
295  */
296 static sbcErr 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         sbcErr err = SBC_ERR_OK;
305         char **tmp_share_names = NULL;
306
307         if ((num_shares == NULL) || (share_names == NULL)) {
308                 return SBC_ERR_INVALID_PARAM;
309         }
310
311         err = smbconf_txt_load_file(ctx);
312         if (!SBC_ERROR_IS_OK(err)) {
313                 return err;
314         }
315
316         tmp_ctx = talloc_stackframe();
317
318         /* make sure "global" is always listed first,
319          * possibly after NULL section */
320
321         if (smbconf_share_exists(ctx, NULL)) {
322                 err = smbconf_add_string_to_array(tmp_ctx, &tmp_share_names,
323                                                   0, NULL);
324                 if (!SBC_ERROR_IS_OK(err)) {
325                         goto done;
326                 }
327                 added_count++;
328         }
329
330         if (smbconf_share_exists(ctx, GLOBAL_NAME)) {
331                 err = smbconf_add_string_to_array(tmp_ctx, &tmp_share_names,
332                                                    added_count, GLOBAL_NAME);
333                 if (!SBC_ERROR_IS_OK(err)) {
334                         goto done;
335                 }
336                 added_count++;
337         }
338
339         for (count = 0; count < pd(ctx)->cache->num_shares; count++) {
340                 if (strequal(pd(ctx)->cache->share_names[count], GLOBAL_NAME) ||
341                     (pd(ctx)->cache->share_names[count] == NULL))
342                 {
343                         continue;
344                 }
345
346                 err = smbconf_add_string_to_array(tmp_ctx, &tmp_share_names,
347                                         added_count,
348                                         pd(ctx)->cache->share_names[count]);
349                 if (!SBC_ERROR_IS_OK(err)) {
350                         goto done;
351                 }
352                 added_count++;
353         }
354
355         *num_shares = added_count;
356         if (added_count > 0) {
357                 *share_names = talloc_move(mem_ctx, &tmp_share_names);
358         } else {
359                 *share_names = NULL;
360         }
361
362 done:
363         talloc_free(tmp_ctx);
364         return err;
365 }
366
367 /**
368  * check if a share/service of a given name exists
369  */
370 static bool smbconf_txt_share_exists(struct smbconf_ctx *ctx,
371                                      const char *servicename)
372 {
373         sbcErr err;
374
375         err = smbconf_txt_load_file(ctx);
376         if (!SBC_ERROR_IS_OK(err)) {
377                 return false;
378         }
379
380         return smbconf_find_in_array(servicename,
381                                      pd(ctx)->cache->share_names,
382                                      pd(ctx)->cache->num_shares, NULL);
383 }
384
385 /**
386  * Add a service if it does not already exist
387  */
388 static sbcErr smbconf_txt_create_share(struct smbconf_ctx *ctx,
389                                        const char *servicename)
390 {
391         return SBC_ERR_NOT_SUPPORTED;
392 }
393
394 /**
395  * get a definition of a share (service) from configuration.
396  */
397 static sbcErr smbconf_txt_get_share(struct smbconf_ctx *ctx,
398                                     TALLOC_CTX *mem_ctx,
399                                     const char *servicename,
400                                     struct smbconf_service **service)
401 {
402         sbcErr err;
403         uint32_t sidx, count;
404         bool found;
405         TALLOC_CTX *tmp_ctx = NULL;
406         struct smbconf_service *tmp_service = NULL;
407
408         err = smbconf_txt_load_file(ctx);
409         if (!SBC_ERROR_IS_OK(err)) {
410                 return err;
411         }
412
413         found = smbconf_find_in_array(servicename,
414                                       pd(ctx)->cache->share_names,
415                                       pd(ctx)->cache->num_shares,
416                                       &sidx);
417         if (!found) {
418                 return SBC_ERR_NO_SUCH_SERVICE;
419         }
420
421         tmp_ctx = talloc_stackframe();
422
423         tmp_service = talloc_zero(tmp_ctx, struct smbconf_service);
424         if (tmp_service == NULL) {
425                 err = SBC_ERR_NOMEM;
426                 goto done;
427         }
428
429         if (servicename != NULL) {
430                 tmp_service->name = talloc_strdup(tmp_service, servicename);
431                 if (tmp_service->name == NULL) {
432                         err = SBC_ERR_NOMEM;
433                         goto done;
434                 }
435         }
436
437         for (count = 0; count < pd(ctx)->cache->num_params[sidx]; count++) {
438                 err = smbconf_add_string_to_array(tmp_service,
439                                 &(tmp_service->param_names),
440                                 count,
441                                 pd(ctx)->cache->param_names[sidx][count]);
442                 if (!SBC_ERROR_IS_OK(err)) {
443                         goto done;
444                 }
445                 err = smbconf_add_string_to_array(tmp_service,
446                                 &(tmp_service->param_values),
447                                 count,
448                                 pd(ctx)->cache->param_values[sidx][count]);
449                 if (!SBC_ERROR_IS_OK(err)) {
450                         goto done;
451                 }
452         }
453
454         tmp_service->num_params = count;
455         *service = talloc_move(mem_ctx, &tmp_service);
456
457 done:
458         talloc_free(tmp_ctx);
459         return err;
460 }
461
462 /**
463  * delete a service from configuration
464  */
465 static sbcErr smbconf_txt_delete_share(struct smbconf_ctx *ctx,
466                                        const char *servicename)
467 {
468         return SBC_ERR_NOT_SUPPORTED;
469 }
470
471 /**
472  * set a configuration parameter to the value provided.
473  */
474 static sbcErr smbconf_txt_set_parameter(struct smbconf_ctx *ctx,
475                                         const char *service,
476                                         const char *param,
477                                         const char *valstr)
478 {
479         return SBC_ERR_NOT_SUPPORTED;
480 }
481
482 /**
483  * get the value of a configuration parameter as a string
484  */
485 static WERROR smbconf_txt_get_parameter(struct smbconf_ctx *ctx,
486                                         TALLOC_CTX *mem_ctx,
487                                         const char *service,
488                                         const char *param,
489                                         char **valstr)
490 {
491         sbcErr err;
492         bool found;
493         uint32_t share_index, param_index;
494
495         err = smbconf_txt_load_file(ctx);
496         if (!SBC_ERROR_IS_OK(err)) {
497                 return WERR_GENERAL_FAILURE;
498         }
499
500         found = smbconf_find_in_array(service,
501                                       pd(ctx)->cache->share_names,
502                                       pd(ctx)->cache->num_shares,
503                                       &share_index);
504         if (!found) {
505                 return WERR_NO_SUCH_SERVICE;
506         }
507
508         found = smbconf_reverse_find_in_array(param,
509                                 pd(ctx)->cache->param_names[share_index],
510                                 pd(ctx)->cache->num_params[share_index],
511                                 &param_index);
512         if (!found) {
513                 return WERR_INVALID_PARAM;
514         }
515
516         *valstr = talloc_strdup(mem_ctx,
517                         pd(ctx)->cache->param_values[share_index][param_index]);
518
519         if (*valstr == NULL) {
520                 return WERR_NOMEM;
521         }
522
523         return WERR_OK;
524 }
525
526 /**
527  * delete a parameter from configuration
528  */
529 static WERROR smbconf_txt_delete_parameter(struct smbconf_ctx *ctx,
530                                            const char *service,
531                                            const char *param)
532 {
533         return WERR_NOT_SUPPORTED;
534 }
535
536 static WERROR smbconf_txt_get_includes(struct smbconf_ctx *ctx,
537                                        TALLOC_CTX *mem_ctx,
538                                        const char *service,
539                                        uint32_t *num_includes,
540                                        char ***includes)
541 {
542         WERROR werr;
543         sbcErr err;
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         err = smbconf_txt_load_file(ctx);
551         if (!SBC_ERROR_IS_OK(err)) {
552                 return WERR_GENERAL_FAILURE;
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                         err = smbconf_add_string_to_array(tmp_ctx,
570                                 &tmp_includes,
571                                 tmp_num_includes,
572                                 pd(ctx)->cache->param_values[sidx][count]);
573                         if (!SBC_ERROR_IS_OK(err)) {
574                                 werr = WERR_NOMEM;
575                                 goto done;
576                         }
577                         tmp_num_includes++;
578                 }
579         }
580
581         *num_includes = tmp_num_includes;
582         if (*num_includes > 0) {
583                 *includes = talloc_move(mem_ctx, &tmp_includes);
584                 if (*includes == NULL) {
585                         werr = WERR_NOMEM;
586                         goto done;
587                 }
588         } else {
589                 *includes = NULL;
590         }
591
592         werr = WERR_OK;
593
594 done:
595         talloc_free(tmp_ctx);
596         return werr;
597 }
598
599 static WERROR smbconf_txt_set_includes(struct smbconf_ctx *ctx,
600                                        const char *service,
601                                        uint32_t num_includes,
602                                        const char **includes)
603 {
604         return WERR_NOT_SUPPORTED;
605 }
606
607 static WERROR smbconf_txt_delete_includes(struct smbconf_ctx *ctx,
608                                           const char *service)
609 {
610         return WERR_NOT_SUPPORTED;
611 }
612
613 static WERROR smbconf_txt_transaction_start(struct smbconf_ctx *ctx)
614 {
615         return WERR_OK;
616 }
617
618 static WERROR smbconf_txt_transaction_commit(struct smbconf_ctx *ctx)
619 {
620         return WERR_OK;
621 }
622
623 static WERROR smbconf_txt_transaction_cancel(struct smbconf_ctx *ctx)
624 {
625         return WERR_OK;
626 }
627
628 static struct smbconf_ops smbconf_ops_txt = {
629         .init                   = smbconf_txt_init,
630         .shutdown               = smbconf_txt_shutdown,
631         .requires_messaging     = smbconf_txt_requires_messaging,
632         .is_writeable           = smbconf_txt_is_writeable,
633         .open_conf              = smbconf_txt_open,
634         .close_conf             = smbconf_txt_close,
635         .get_csn                = smbconf_txt_get_csn,
636         .drop                   = smbconf_txt_drop,
637         .get_share_names        = smbconf_txt_get_share_names,
638         .share_exists           = smbconf_txt_share_exists,
639         .create_share           = smbconf_txt_create_share,
640         .get_share              = smbconf_txt_get_share,
641         .delete_share           = smbconf_txt_delete_share,
642         .set_parameter          = smbconf_txt_set_parameter,
643         .get_parameter          = smbconf_txt_get_parameter,
644         .delete_parameter       = smbconf_txt_delete_parameter,
645         .get_includes           = smbconf_txt_get_includes,
646         .set_includes           = smbconf_txt_set_includes,
647         .delete_includes        = smbconf_txt_delete_includes,
648         .transaction_start      = smbconf_txt_transaction_start,
649         .transaction_commit     = smbconf_txt_transaction_commit,
650         .transaction_cancel     = smbconf_txt_transaction_cancel,
651 };
652
653
654 /**
655  * initialize the smbconf text backend
656  * the only function that is exported from this module
657  */
658 sbcErr smbconf_init_txt(TALLOC_CTX *mem_ctx,
659                         struct smbconf_ctx **conf_ctx,
660                         const char *path)
661 {
662         sbcErr err;
663
664         err = smbconf_init_internal(mem_ctx, conf_ctx, path, &smbconf_ops_txt);
665         if (!SBC_ERROR_IS_OK(err)) {
666                 return err;
667         }
668
669         return smbconf_txt_load_file(*conf_ctx);
670 }