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 }