Ignore:
Timestamp:
Nov 14, 2012, 12:59:34 PM (13 years ago)
Author:
Silvan Scherrer
Message:

Samba Server: update vendor to 3.6.0

Location:
vendor/current/source3/lib/smbconf
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • vendor/current/source3/lib/smbconf/smbconf_init.c

    r414 r740  
    2222#include "lib/smbconf/smbconf_txt.h"
    2323#include "lib/smbconf/smbconf_reg.h"
     24#include "lib/smbconf/smbconf_init.h"
    2425
    2526/**
    … …  
    3435 * -  "txt" or "file"
    3536 */
    36 WERROR smbconf_init(TALLOC_CTX *mem_ctx, struct smbconf_ctx **conf_ctx,
     37sbcErr smbconf_init(TALLOC_CTX *mem_ctx, struct smbconf_ctx **conf_ctx,
    3738                    const char *source)
    3839{
    39         WERROR werr;
     40        sbcErr err;
    4041        char *backend = NULL;
    4142        char *path = NULL;
    … …  
    4445
    4546        if (conf_ctx == NULL) {
    46                 werr = WERR_INVALID_PARAM;
     47                err = SBC_ERR_INVALID_PARAM;
    4748                goto done;
    4849        }
    4950
    5051        if ((source == NULL) || (*source == '\0')) {
    51                 werr = WERR_INVALID_PARAM;
     52                err = SBC_ERR_INVALID_PARAM;
    5253                goto done;
    5354        }
    … …  
    5556        backend = talloc_strdup(tmp_ctx, source);
    5657        if (backend == NULL) {
    57                 werr = WERR_NOMEM;
     58                err = SBC_ERR_NOMEM;
    5859                goto done;
    5960        }
    … …  
    6970
    7071        if (strequal(backend, "registry") || strequal(backend, "reg")) {
    71                 werr = smbconf_init_reg(mem_ctx, conf_ctx, path);
     72                err = smbconf_init_reg(mem_ctx, conf_ctx, path);
    7273        } else if (strequal(backend, "file") || strequal(backend, "txt")) {
    73                 werr = smbconf_init_txt(mem_ctx, conf_ctx, path);
     74                err = smbconf_init_txt(mem_ctx, conf_ctx, path);
    7475        } else if (sep == NULL) {
    7576                /*
    … …  
    7879                 * string as a path argument.
    7980                 */
    80                 werr = smbconf_init_txt(mem_ctx, conf_ctx, backend);
     81                err = smbconf_init_txt(mem_ctx, conf_ctx, backend);
    8182        } else {
    8283                /*
    … …  
    8788                 * 'include = /path/to/file.%T'
    8889                 */
    89                 werr = smbconf_init_txt(mem_ctx, conf_ctx, source);
     90                err = smbconf_init_txt(mem_ctx, conf_ctx, source);
    9091        }
    9192
    9293done:
    9394        talloc_free(tmp_ctx);
    94         return werr;
     95        return err;
    9596}

  • vendor/current/source3/lib/smbconf/smbconf_init.h

    r414 r740  
    2727 * takes source string in the form of "backend:path"
    2828 */
    29 WERROR smbconf_init(TALLOC_CTX *mem_ctx, struct smbconf_ctx **conf_ctx,
     29sbcErr smbconf_init(TALLOC_CTX *mem_ctx, struct smbconf_ctx **conf_ctx,
    3030                    const char *source);
    3131

  • vendor/current/source3/lib/smbconf/smbconf_reg.c

    r414 r740  
    2020#include "includes.h"
    2121#include "lib/smbconf/smbconf_private.h"
     22#include "registry.h"
     23#include "registry/reg_api.h"
     24#include "registry/reg_backend_db.h"
     25#include "registry/reg_util_token.h"
     26#include "registry/reg_api_util.h"
     27#include "registry/reg_init_smbconf.h"
     28#include "lib/smbconf/smbconf_init.h"
     29#include "lib/smbconf/smbconf_reg.h"
     30#include "../libcli/registry/util_reg.h"
    2231
    2332#define INCLUDES_VALNAME "includes"
    … …  
    7584 * Open a subkey of the base key (i.e a service)
    7685 */
    77 static WERROR smbconf_reg_open_service_key(TALLOC_CTX *mem_ctx,
     86static sbcErr smbconf_reg_open_service_key(TALLOC_CTX *mem_ctx,
    7887                                           struct smbconf_ctx *ctx,
    7988                                           const char *servicename,
    … …  
    8594        if (servicename == NULL) {
    8695                *key = rpd(ctx)->base_key;
    87                 return WERR_OK;
     96                return SBC_ERR_OK;
    8897        }
    8998        werr = reg_openkey(mem_ctx, rpd(ctx)->base_key, servicename,
    9099                           desired_access, key);
    91 
    92100        if (W_ERROR_EQUAL(werr, WERR_BADFILE)) {
    93                 werr = WERR_NO_SUCH_SERVICE;
    94         }
    95 
    96         return werr;
     101                return SBC_ERR_NO_SUCH_SERVICE;
     102        }
     103        if (!W_ERROR_IS_OK(werr)) {
     104                return SBC_ERR_NOMEM;
     105        }
     106
     107        return SBC_ERR_OK;
    97108}
    98109
    … …  
    119130 * create a subkey of the base key (i.e. a service...)
    120131 */
    121 static WERROR smbconf_reg_create_service_key(TALLOC_CTX *mem_ctx,
     132static sbcErr smbconf_reg_create_service_key(TALLOC_CTX *mem_ctx,
    122133                                             struct smbconf_ctx *ctx,
    123134                                             const char * subkeyname,
    124135                                             struct registry_key **newkey)
    125136{
    126         WERROR werr = WERR_OK;
     137        WERROR werr;
     138        sbcErr err = SBC_ERR_OK;
    127139        TALLOC_CTX *create_ctx;
    128140        enum winreg_CreateAction action = REG_ACTION_NONE;
    … …  
    137149        if (W_ERROR_IS_OK(werr) && (action != REG_CREATED_NEW_KEY)) {
    138150                DEBUG(10, ("Key '%s' already exists.\n", subkeyname));
    139                 werr = WERR_FILE_EXISTS;
     151                err = SBC_ERR_FILE_EXISTS;
    140152        }
    141153        if (!W_ERROR_IS_OK(werr)) {
    142154                DEBUG(5, ("Error creating key %s: %s\n",
    143155                         subkeyname, win_errstr(werr)));
     156                err = SBC_ERR_UNKNOWN_FAILURE;
    144157        }
    145158
    146159        talloc_free(create_ctx);
    147         return werr;
     160        return err;
    148161}
    149162
    … …  
    151164 * add a value to a key.
    152165 */
    153 static WERROR smbconf_reg_set_value(struct registry_key *key,
     166static sbcErr smbconf_reg_set_value(struct registry_key *key,
    154167                                    const char *valname,
    155168                                    const char *valstr)
    … …  
    157170        struct registry_value val;
    158171        WERROR werr = WERR_OK;
     172        sbcErr err;
    159173        char *subkeyname;
    160174        const char *canon_valname;
    … …  
    172186                                  "parameter '%s'\n", valstr, valname));
    173187                }
    174                 werr = WERR_INVALID_PARAM;
     188                err = SBC_ERR_INVALID_PARAM;
    175189                goto done;
    176190        }
    … …  
    179193                DEBUG(5, ("Parameter '%s' not allowed in registry.\n",
    180194                          canon_valname));
    181                 werr = WERR_INVALID_PARAM;
     195                err = SBC_ERR_INVALID_PARAM;
    182196                goto done;
    183197        }
    … …  
    187201                DEBUG(5, ("Invalid registry key '%s' given as "
    188202                          "smbconf section.\n", key->key->name));
    189                 werr = WERR_INVALID_PARAM;
     203                err = SBC_ERR_INVALID_PARAM;
    190204                goto done;
    191205        }
    … …  
    197211                          "service definition ('%s').\n", canon_valname,
    198212                          subkeyname));
    199                 werr = WERR_INVALID_PARAM;
     213                err = SBC_ERR_INVALID_PARAM;
    200214                goto done;
    201215        }
    … …  
    204218
    205219        val.type = REG_SZ;
    206         val.v.sz.str = CONST_DISCARD(char *, canon_valstr);
    207         val.v.sz.len = strlen(canon_valstr) + 1;
     220        if (!push_reg_sz(talloc_tos(), &val.data, canon_valstr)) {
     221                err = SBC_ERR_NOMEM;
     222                goto done;
     223        }
    208224
    209225        werr = reg_setvalue(key, canon_valname, &val);
    … …  
    212228                          "key '%s': %s\n",
    213229                          canon_valname, key->key->name, win_errstr(werr)));
    214         }
    215 
    216 done:
    217         return werr;
    218 }
    219 
    220 static WERROR smbconf_reg_set_multi_sz_value(struct registry_key *key,
     230                err = SBC_ERR_NOMEM;
     231                goto done;
     232        }
     233
     234        err = SBC_ERR_OK;
     235done:
     236        return err;
     237}
     238
     239static sbcErr smbconf_reg_set_multi_sz_value(struct registry_key *key,
    221240                                             const char *valname,
    222241                                             const uint32_t num_strings,
    … …  
    224243{
    225244        WERROR werr;
     245        sbcErr err = SBC_ERR_OK;
    226246        struct registry_value *value;
    227247        uint32_t count;
    228248        TALLOC_CTX *tmp_ctx = talloc_stackframe();
     249        const char **array;
    229250
    230251        if (strings == NULL) {
    231                 werr = WERR_INVALID_PARAM;
     252                err = SBC_ERR_INVALID_PARAM;
     253                goto done;
     254        }
     255
     256        array = talloc_zero_array(tmp_ctx, const char *, num_strings + 1);
     257        if (array == NULL) {
     258                err = SBC_ERR_NOMEM;
    232259                goto done;
    233260        }
    234261
    235262        value = TALLOC_ZERO_P(tmp_ctx, struct registry_value);
     263        if (value == NULL) {
     264                err = SBC_ERR_NOMEM;
     265                goto done;
     266        }
    236267
    237268        value->type = REG_MULTI_SZ;
    238         value->v.multi_sz.num_strings = num_strings;
    239         value->v.multi_sz.strings = TALLOC_ARRAY(tmp_ctx, char *, num_strings);
    240         if (value->v.multi_sz.strings == NULL) {
    241                 werr = WERR_NOMEM;
    242                 goto done;
    243         }
     269
    244270        for (count = 0; count < num_strings; count++) {
    245                 value->v.multi_sz.strings[count] =
    246                         talloc_strdup(value->v.multi_sz.strings,
    247                                       strings[count]);
    248                 if (value->v.multi_sz.strings[count] == NULL) {
    249                         werr = WERR_NOMEM;
    250                         goto done;
    251                 }
     271                array[count] = talloc_strdup(value, strings[count]);
     272                if (array[count] == NULL) {
     273                        err = SBC_ERR_NOMEM;
     274                        goto done;
     275                }
     276        }
     277
     278        if (!push_reg_multi_sz(value, &value->data, array)) {
     279                err = SBC_ERR_NOMEM;
     280                goto done;
    252281        }
    253282
    … …  
    256285                DEBUG(5, ("Error adding value '%s' to key '%s': %s\n",
    257286                          valname, key->key->name, win_errstr(werr)));
     287                err = SBC_ERR_ACCESS_DENIED;
    258288        }
    259289
    260290done:
    261291        talloc_free(tmp_ctx);
    262         return werr;
     292        return err;
    263293}
    264294
    … …  
    282312        switch (value->type) {
    283313        case REG_DWORD:
    284                 result = talloc_asprintf(mem_ctx, "%d", value->v.dword);
     314                if (value->data.length >= 4) {
     315                        uint32_t v = IVAL(value->data.data, 0);
     316                        result = talloc_asprintf(mem_ctx, "%d", v);
     317                }
    285318                break;
    286319        case REG_SZ:
    287         case REG_EXPAND_SZ:
    288                 result = talloc_asprintf(mem_ctx, "%s", value->v.sz.str);
     320        case REG_EXPAND_SZ: {
     321                const char *s;
     322                if (!pull_reg_sz(mem_ctx, &value->data, &s)) {
     323                        break;
     324                }
     325                result = talloc_strdup(mem_ctx, s);
    289326                break;
     327        }
    290328        case REG_MULTI_SZ: {
    291329                uint32 j;
    292                 for (j = 0; j < value->v.multi_sz.num_strings; j++) {
     330                const char **a = NULL;
     331                if (!pull_reg_multi_sz(mem_ctx, &value->data, &a)) {
     332                        break;
     333                }
     334                for (j = 0; a[j] != NULL; j++) {
    293335                        result = talloc_asprintf(mem_ctx, "%s\"%s\" ",
    294336                                                 result ? result : "" ,
    295                                                  value->v.multi_sz.strings[j]);
     337                                                 a[j]);
    296338                        if (result == NULL) {
    297339                                break;
    … …  
    302344        case REG_BINARY:
    303345                result = talloc_asprintf(mem_ctx, "binary (%d bytes)",
    304                                          (int)value->v.binary.length);
     346                                         (int)value->data.length);
    305347                break;
    306348        default:
    … …  
    311353}
    312354
    313 static WERROR smbconf_reg_get_includes_internal(TALLOC_CTX *mem_ctx,
     355static sbcErr smbconf_reg_get_includes_internal(TALLOC_CTX *mem_ctx,
    314356                                                struct registry_key *key,
    315357                                                uint32_t *num_includes,
    … …  
    317359{
    318360        WERROR werr;
     361        sbcErr err;
    319362        uint32_t count;
    320363        struct registry_value *value = NULL;
    321364        char **tmp_includes = NULL;
     365        const char **array = NULL;
    322366        TALLOC_CTX *tmp_ctx = talloc_stackframe();
    323367
    … …  
    326370                *num_includes = 0;
    327371                *includes = NULL;
    328                 werr = WERR_OK;
     372                err = SBC_ERR_OK;
    329373                goto done;
    330374        }
    … …  
    332376        werr = reg_queryvalue(tmp_ctx, key, INCLUDES_VALNAME, &value);
    333377        if (!W_ERROR_IS_OK(werr)) {
     378                err = SBC_ERR_ACCESS_DENIED;
    334379                goto done;
    335380        }
    … …  
    337382        if (value->type != REG_MULTI_SZ) {
    338383                /* wrong type -- ignore */
    339                 goto done;
    340         }
    341 
    342         for (count = 0; count < value->v.multi_sz.num_strings; count++)
    343         {
    344                 werr = smbconf_add_string_to_array(tmp_ctx,
     384                err = SBC_ERR_OK;
     385                goto done;
     386        }
     387
     388        if (!pull_reg_multi_sz(tmp_ctx, &value->data, &array)) {
     389                err = SBC_ERR_NOMEM;
     390                goto done;
     391        }
     392
     393        for (count = 0; array[count] != NULL; count++) {
     394                err = smbconf_add_string_to_array(tmp_ctx,
    345395                                        &tmp_includes,
    346396                                        count,
    347                                         value->v.multi_sz.strings[count]);
    348                 if (!W_ERROR_IS_OK(werr)) {
     397                                        array[count]);
     398                if (!SBC_ERROR_IS_OK(err)) {
    349399                        goto done;
    350400                }
    … …  
    354404                *includes = talloc_move(mem_ctx, &tmp_includes);
    355405                if (*includes == NULL) {
    356                         werr = WERR_NOMEM;
     406                        err = SBC_ERR_NOMEM;
    357407                        goto done;
    358408                }
    … …  
    363413        }
    364414
     415        err = SBC_ERR_OK;
    365416done:
    366417        talloc_free(tmp_ctx);
    367         return werr;
     418        return err;
    368419}
    369420
    … …  
    372423 * and a list of value strings (ordered)
    373424 */
    374 static WERROR smbconf_reg_get_values(TALLOC_CTX *mem_ctx,
     425static sbcErr smbconf_reg_get_values(TALLOC_CTX *mem_ctx,
    375426                                     struct registry_key *key,
    376427                                     uint32_t *num_values,
    … …  
    380431        TALLOC_CTX *tmp_ctx = NULL;
    381432        WERROR werr = WERR_OK;
     433        sbcErr err;
    382434        uint32_t count;
    383435        struct registry_value *valvalue = NULL;
    … …  
    392444            (value_strings == NULL))
    393445        {
    394                 werr = WERR_INVALID_PARAM;
     446                err = SBC_ERR_INVALID_PARAM;
    395447                goto done;
    396448        }
    … …  
    409461                }
    410462
    411                 werr = smbconf_add_string_to_array(tmp_ctx,
    412                                                    &tmp_valnames,
    413                                                    tmp_num_values, valname);
    414                 if (!W_ERROR_IS_OK(werr)) {
     463                err = smbconf_add_string_to_array(tmp_ctx,
     464                                                  &tmp_valnames,
     465                                                  tmp_num_values, valname);
     466                if (!SBC_ERROR_IS_OK(err)) {
    415467                        goto done;
    416468                }
    417469
    418470                valstring = smbconf_format_registry_value(tmp_ctx, valvalue);
    419                 werr = smbconf_add_string_to_array(tmp_ctx, &tmp_valstrings,
    420                                                    tmp_num_values, valstring);
    421                 if (!W_ERROR_IS_OK(werr)) {
     471                err = smbconf_add_string_to_array(tmp_ctx, &tmp_valstrings,
     472                                                  tmp_num_values, valstring);
     473                if (!SBC_ERROR_IS_OK(err)) {
    422474                        goto done;
    423475                }
    … …  
    425477        }
    426478        if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
     479                err = SBC_ERR_NOMEM;
    427480                goto done;
    428481        }
    429482
    430483        /* now add the includes at the end */
    431         werr = smbconf_reg_get_includes_internal(tmp_ctx, key, &num_includes,
     484        err = smbconf_reg_get_includes_internal(tmp_ctx, key, &num_includes,
    432485                                                 &includes);
    433         if (!W_ERROR_IS_OK(werr)) {
    434                 goto done;
    435         }
     486        if (!SBC_ERROR_IS_OK(err)) {
     487                goto done;
     488        }
     489
    436490        for (count = 0; count < num_includes; count++) {
    437                 werr = smbconf_add_string_to_array(tmp_ctx, &tmp_valnames,
    438                                                    tmp_num_values, "include");
    439                 if (!W_ERROR_IS_OK(werr)) {
    440                         goto done;
    441                 }
    442 
    443                 werr = smbconf_add_string_to_array(tmp_ctx, &tmp_valstrings,
    444                                                    tmp_num_values,
    445                                                    includes[count]);
    446                 if (!W_ERROR_IS_OK(werr)) {
     491                err = smbconf_add_string_to_array(tmp_ctx, &tmp_valnames,
     492                                                  tmp_num_values, "include");
     493                if (!SBC_ERROR_IS_OK(err)) {
     494                        goto done;
     495                }
     496
     497                err = smbconf_add_string_to_array(tmp_ctx, &tmp_valstrings,
     498                                                  tmp_num_values,
     499                                                  includes[count]);
     500                if (!SBC_ERROR_IS_OK(err)) {
    447501                        goto done;
    448502                }
    … …  
    462516done:
    463517        talloc_free(tmp_ctx);
    464         return werr;
     518        return err;
    465519}
    466520
    … …  
    491545 * delete all values from a key
    492546 */
    493 static WERROR smbconf_reg_delete_values(struct registry_key *key)
    494 {
    495         WERROR werr;
     547static sbcErr smbconf_reg_delete_values(struct registry_key *key)
     548{
     549        WERROR werr;
     550        sbcErr err;
    496551        char *valname;
    497552        struct registry_value *valvalue;
    … …  
    506561                werr = reg_deletevalue(key, valname);
    507562                if (!W_ERROR_IS_OK(werr)) {
     563                        err = SBC_ERR_ACCESS_DENIED;
    508564                        goto done;
    509565                }
    … …  
    514570                          key->key->name,
    515571                          win_errstr(werr)));
    516                 goto done;
    517         }
    518 
    519         werr = WERR_OK;
     572                err = SBC_ERR_ACCESS_DENIED;
     573                goto done;
     574        }
     575
     576        err = SBC_ERR_OK;
    520577
    521578done:
    522579        talloc_free(mem_ctx);
    523         return werr;
     580        return err;
    524581}
    525582
    … …  
    533590 * initialize the registry smbconf backend
    534591 */
    535 static WERROR smbconf_reg_init(struct smbconf_ctx *ctx, const char *path)
     592static sbcErr smbconf_reg_init(struct smbconf_ctx *ctx, const char *path)
    536593{
    537594        WERROR werr = WERR_OK;
    538         struct nt_user_token *token;
     595        sbcErr err;
     596        struct security_token *token;
    539597
    540598        if (path == NULL) {
    … …  
    543601        ctx->path = talloc_strdup(ctx, path);
    544602        if (ctx->path == NULL) {
    545                 werr = WERR_NOMEM;
     603                err = SBC_ERR_NOMEM;
    546604                goto done;
    547605        }
    … …  
    552610        if (!W_ERROR_IS_OK(werr)) {
    553611                DEBUG(1, ("Error creating admin token\n"));
     612                err = SBC_ERR_UNKNOWN_FAILURE;
    554613                goto done;
    555614        }
    … …  
    558617        werr = registry_init_smbconf(path);
    559618        if (!W_ERROR_IS_OK(werr)) {
    560                 goto done;
    561         }
    562 
    563         werr = ctx->ops->open_conf(ctx);
    564         if (!W_ERROR_IS_OK(werr)) {
     619                err = SBC_ERR_BADFILE;
     620                goto done;
     621        }
     622
     623        err = ctx->ops->open_conf(ctx);
     624        if (!SBC_ERROR_IS_OK(err)) {
    565625                DEBUG(1, ("Error opening the registry.\n"));
    566626                goto done;
    … …  
    571631                             token, &rpd(ctx)->base_key);
    572632        if (!W_ERROR_IS_OK(werr)) {
    573                 goto done;
    574         }
    575 
    576 done:
    577         return werr;
     633                err = SBC_ERR_UNKNOWN_FAILURE;
     634                goto done;
     635        }
     636
     637done:
     638        return err;
    578639}
    579640
    … …  
    604665}
    605666
    606 static WERROR smbconf_reg_open(struct smbconf_ctx *ctx)
     667static sbcErr smbconf_reg_open(struct smbconf_ctx *ctx)
    607668{
    608669        WERROR werr;
    609670
    610671        if (rpd(ctx)->open) {
    611                 return WERR_OK;
     672                return SBC_ERR_OK;
    612673        }
    613674
    614675        werr = regdb_open();
    615         if (W_ERROR_IS_OK(werr)) {
    616                 rpd(ctx)->open = true;
    617         }
    618         return werr;
     676        if (!W_ERROR_IS_OK(werr)) {
     677                return SBC_ERR_BADFILE;
     678        }
     679
     680        rpd(ctx)->open = true;
     681        return SBC_ERR_OK;
    619682}
    620683
    … …  
    646709        }
    647710
    648         if (!W_ERROR_IS_OK(ctx->ops->open_conf(ctx))) {
     711        if (!SBC_ERROR_IS_OK(ctx->ops->open_conf(ctx))) {
    649712                return;
    650713        }
    … …  
    656719 * Drop the whole configuration (restarting empty) - registry version
    657720 */
    658 static WERROR smbconf_reg_drop(struct smbconf_ctx *ctx)
     721static sbcErr smbconf_reg_drop(struct smbconf_ctx *ctx)
    659722{
    660723        char *path, *p;
    661724        WERROR werr = WERR_OK;
     725        sbcErr err = SBC_ERR_OK;
    662726        struct registry_key *parent_key = NULL;
    663727        struct registry_key *new_key = NULL;
    664728        TALLOC_CTX* mem_ctx = talloc_stackframe();
    665729        enum winreg_CreateAction action;
    666         struct nt_user_token *token;
     730        struct security_token *token;
    667731
    668732        werr = ntstatus_to_werror(registry_create_admin_token(ctx, &token));
    669733        if (!W_ERROR_IS_OK(werr)) {
    670734                DEBUG(1, ("Error creating admin token\n"));
     735                err = SBC_ERR_UNKNOWN_FAILURE;
    671736                goto done;
    672737        }
    … …  
    674739        path = talloc_strdup(mem_ctx, ctx->path);
    675740        if (path == NULL) {
    676                 werr = WERR_NOMEM;
     741                err = SBC_ERR_NOMEM;
    677742                goto done;
    678743        }
    679744        p = strrchr(path, '\\');
     745        if (p == NULL) {
     746                err = SBC_ERR_INVALID_PARAM;
     747                goto done;
     748        }
    680749        *p = '\0';
    681750        werr = reg_open_path(mem_ctx, path, REG_KEY_WRITE, token,
    682751                             &parent_key);
    683 
    684         if (!W_ERROR_IS_OK(werr)) {
    685                 goto done;
    686         }
    687 
    688         werr = reg_deletekey_recursive(mem_ctx, parent_key, p+1);
    689 
    690         if (!W_ERROR_IS_OK(werr)) {
     752        if (!W_ERROR_IS_OK(werr)) {
     753                err = SBC_ERR_IO_FAILURE;
     754                goto done;
     755        }
     756
     757        werr = reg_deletekey_recursive(parent_key, p+1);
     758        if (!W_ERROR_IS_OK(werr)) {
     759                err = SBC_ERR_IO_FAILURE;
    691760                goto done;
    692761        }
    … …  
    694763        werr = reg_createkey(mem_ctx, parent_key, p+1, REG_KEY_WRITE,
    695764                             &new_key, &action);
     765        if (!W_ERROR_IS_OK(werr)) {
     766                err = SBC_ERR_IO_FAILURE;
     767                goto done;
     768        }
    696769
    697770done:
    698771        talloc_free(mem_ctx);
    699         return werr;
     772        return err;
    700773}
    701774
    … …  
    704777 * registry version.
    705778 */
    706 static WERROR smbconf_reg_get_share_names(struct smbconf_ctx *ctx,
     779static sbcErr smbconf_reg_get_share_names(struct smbconf_ctx *ctx,
    707780                                          TALLOC_CTX *mem_ctx,
    708781                                          uint32_t *num_shares,
    … …  
    712785        uint32_t added_count = 0;
    713786        TALLOC_CTX *tmp_ctx = NULL;
    714         WERROR werr = WERR_OK;
     787        WERROR werr;
     788        sbcErr err = SBC_ERR_OK;
    715789        char *subkey_name = NULL;
    716790        char **tmp_share_names = NULL;
    717791
    718792        if ((num_shares == NULL) || (share_names == NULL)) {
    719                 werr = WERR_INVALID_PARAM;
    720                 goto done;
     793                return SBC_ERR_INVALID_PARAM;
    721794        }
    722795
    … …  
    726799
    727800        if (smbconf_reg_key_has_values(rpd(ctx)->base_key)) {
    728                 werr = smbconf_add_string_to_array(tmp_ctx, &tmp_share_names,
     801                err = smbconf_add_string_to_array(tmp_ctx, &tmp_share_names,
    729802                                                   0, NULL);
    730                 if (!W_ERROR_IS_OK(werr)) {
     803                if (!SBC_ERROR_IS_OK(err)) {
    731804                        goto done;
    732805                }
    … …  
    736809        /* make sure "global" is always listed first */
    737810        if (smbconf_share_exists(ctx, GLOBAL_NAME)) {
    738                 werr = smbconf_add_string_to_array(tmp_ctx, &tmp_share_names,
    739                                                    added_count, GLOBAL_NAME);
    740                 if (!W_ERROR_IS_OK(werr)) {
     811                err = smbconf_add_string_to_array(tmp_ctx, &tmp_share_names,
     812                                                  added_count, GLOBAL_NAME);
     813                if (!SBC_ERROR_IS_OK(err)) {
    741814                        goto done;
    742815                }
    … …  
    754827                }
    755828
    756                 werr = smbconf_add_string_to_array(tmp_ctx,
     829                err = smbconf_add_string_to_array(tmp_ctx,
    757830                                                   &tmp_share_names,
    758831                                                   added_count,
    759832                                                   subkey_name);
    760                 if (!W_ERROR_IS_OK(werr)) {
     833                if (!SBC_ERROR_IS_OK(err)) {
    761834                        goto done;
    762835                }
    … …  
    764837        }
    765838        if (!W_ERROR_EQUAL(WERR_NO_MORE_ITEMS, werr)) {
    766                 goto done;
    767         }
    768         werr = WERR_OK;
     839                err = SBC_ERR_NO_MORE_ITEMS;
     840                goto done;
     841        }
     842        err = SBC_ERR_OK;
    769843
    770844        *num_shares = added_count;
    … …  
    777851done:
    778852        talloc_free(tmp_ctx);
    779         return werr;
     853        return err;
    780854}
    781855
    … …  
    787861{
    788862        bool ret = false;
    789         WERROR werr = WERR_OK;
     863        sbcErr err;
    790864        TALLOC_CTX *mem_ctx = talloc_stackframe();
    791865        struct registry_key *key = NULL;
    792866
    793         werr = smbconf_reg_open_service_key(mem_ctx, ctx, servicename,
    794                                             REG_KEY_READ, &key);
    795         if (W_ERROR_IS_OK(werr)) {
     867        err = smbconf_reg_open_service_key(mem_ctx, ctx, servicename,
     868                                           REG_KEY_READ, &key);
     869        if (SBC_ERROR_IS_OK(err)) {
    796870                ret = true;
    797871        }
    … …  
    804878 * Add a service if it does not already exist - registry version
    805879 */
    806 static WERROR smbconf_reg_create_share(struct smbconf_ctx *ctx,
     880static sbcErr smbconf_reg_create_share(struct smbconf_ctx *ctx,
    807881                                       const char *servicename)
    808882{
    809         WERROR werr;
     883        sbcErr err;
    810884        struct registry_key *key = NULL;
    811885
    812886        if (servicename == NULL) {
    813                 return WERR_OK;
    814         }
    815 
    816         werr = smbconf_reg_create_service_key(talloc_tos(), ctx,
    817                                               servicename, &key);
     887                return SBC_ERR_OK;
     888        }
     889
     890        err = smbconf_reg_create_service_key(talloc_tos(), ctx,
     891                                             servicename, &key);
    818892
    819893        talloc_free(key);
    820         return werr;
     894        return err;
    821895}
    822896
    … …  
    824898 * get a definition of a share (service) from configuration.
    825899 */
    826 static WERROR smbconf_reg_get_share(struct smbconf_ctx *ctx,
     900static sbcErr smbconf_reg_get_share(struct smbconf_ctx *ctx,
    827901                                    TALLOC_CTX *mem_ctx,
    828902                                    const char *servicename,
    829903                                    struct smbconf_service **service)
    830904{
    831         WERROR werr = WERR_OK;
     905        sbcErr err;
    832906        struct registry_key *key = NULL;
    833907        struct smbconf_service *tmp_service = NULL;
    834908        TALLOC_CTX *tmp_ctx = talloc_stackframe();
    835909
    836         werr = smbconf_reg_open_service_key(tmp_ctx, ctx, servicename,
    837                                             REG_KEY_READ, &key);
    838         if (!W_ERROR_IS_OK(werr)) {
     910        err = smbconf_reg_open_service_key(tmp_ctx, ctx, servicename,
     911                                           REG_KEY_READ, &key);
     912        if (!SBC_ERROR_IS_OK(err)) {
    839913                goto done;
    840914        }
    … …  
    842916        tmp_service = TALLOC_ZERO_P(tmp_ctx, struct smbconf_service);
    843917        if (tmp_service == NULL) {
    844                 werr =  WERR_NOMEM;
     918                err = SBC_ERR_NOMEM;
    845919                goto done;
    846920        }
    … …  
    849923                tmp_service->name = talloc_strdup(tmp_service, servicename);
    850924                if (tmp_service->name == NULL) {
    851                         werr = WERR_NOMEM;
    852                         goto done;
    853                 }
    854         }
    855 
    856         werr = smbconf_reg_get_values(tmp_service, key,
    857                                       &(tmp_service->num_params),
    858                                       &(tmp_service->param_names),
    859                                       &(tmp_service->param_values));
    860 
    861         if (W_ERROR_IS_OK(werr)) {
     925                        err = SBC_ERR_NOMEM;
     926                        goto done;
     927                }
     928        }
     929
     930        err = smbconf_reg_get_values(tmp_service, key,
     931                                     &(tmp_service->num_params),
     932                                     &(tmp_service->param_names),
     933                                     &(tmp_service->param_values));
     934        if (SBC_ERROR_IS_OK(err)) {
    862935                *service = talloc_move(mem_ctx, &tmp_service);
    863936        }
    … …  
    865938done:
    866939        talloc_free(tmp_ctx);
    867         return werr;
     940        return err;
    868941}
    869942
    … …  
    871944 * delete a service from configuration
    872945 */
    873 static WERROR smbconf_reg_delete_share(struct smbconf_ctx *ctx,
     946static sbcErr smbconf_reg_delete_share(struct smbconf_ctx *ctx,
    874947                                       const char *servicename)
    875948{
    876         WERROR werr = WERR_OK;
     949        WERROR werr;
     950        sbcErr err = SBC_ERR_OK;
    877951        TALLOC_CTX *mem_ctx = talloc_stackframe();
    878952
    879953        if (servicename != NULL) {
    880                 werr = reg_deletekey_recursive(mem_ctx, rpd(ctx)->base_key,
    881                                                servicename);
     954                werr = reg_deletekey_recursive(rpd(ctx)->base_key, servicename);
     955                if (!W_ERROR_IS_OK(werr)) {
     956                        err = SBC_ERR_ACCESS_DENIED;
     957                }
    882958        } else {
    883                 werr = smbconf_reg_delete_values(rpd(ctx)->base_key);
     959                err = smbconf_reg_delete_values(rpd(ctx)->base_key);
    884960        }
    885961
    886962        talloc_free(mem_ctx);
    887         return werr;
     963        return err;
    888964}
    889965
    … …  
    891967 * set a configuration parameter to the value provided.
    892968 */
    893 static WERROR smbconf_reg_set_parameter(struct smbconf_ctx *ctx,
     969static sbcErr smbconf_reg_set_parameter(struct smbconf_ctx *ctx,
    894970                                        const char *service,
    895971                                        const char *param,
    896972                                        const char *valstr)
    897973{
    898         WERROR werr;
     974        sbcErr err;
    899975        struct registry_key *key = NULL;
    900976        TALLOC_CTX *mem_ctx = talloc_stackframe();
    901977
    902         werr = smbconf_reg_open_service_key(mem_ctx, ctx, service,
    903                                             REG_KEY_WRITE, &key);
    904         if (!W_ERROR_IS_OK(werr)) {
    905                 goto done;
    906         }
    907 
    908         werr = smbconf_reg_set_value(key, param, valstr);
     978        err = smbconf_reg_open_service_key(mem_ctx, ctx, service,
     979                                           REG_KEY_WRITE, &key);
     980        if (!SBC_ERROR_IS_OK(err)) {
     981                goto done;
     982        }
     983
     984        err = smbconf_reg_set_value(key, param, valstr);
    909985
    910986done:
    911987        talloc_free(mem_ctx);
    912         return werr;
     988        return err;
    913989}
    914990
    … …  
    916992 * get the value of a configuration parameter as a string
    917993 */
    918 static WERROR smbconf_reg_get_parameter(struct smbconf_ctx *ctx,
     994static sbcErr smbconf_reg_get_parameter(struct smbconf_ctx *ctx,
    919995                                        TALLOC_CTX *mem_ctx,
    920996                                        const char *service,
    … …  
    923999{
    9241000        WERROR werr = WERR_OK;
     1001        sbcErr err;
    9251002        struct registry_key *key = NULL;
    9261003        struct registry_value *value = NULL;
    9271004
    928         werr = smbconf_reg_open_service_key(mem_ctx, ctx, service,
    929                                             REG_KEY_READ, &key);
    930         if (!W_ERROR_IS_OK(werr)) {
     1005        err = smbconf_reg_open_service_key(mem_ctx, ctx, service,
     1006                                           REG_KEY_READ, &key);
     1007        if (!SBC_ERROR_IS_OK(err)) {
    9311008                goto done;
    9321009        }
    9331010
    9341011        if (!smbconf_reg_valname_valid(param)) {
    935                 werr = WERR_INVALID_PARAM;
     1012                err = SBC_ERR_INVALID_PARAM;
    9361013                goto done;
    9371014        }
    9381015
    9391016        if (!smbconf_value_exists(key, param)) {
    940                 werr = WERR_INVALID_PARAM;
     1017                err = SBC_ERR_INVALID_PARAM;
    9411018                goto done;
    9421019        }
    … …  
    9441021        werr = reg_queryvalue(mem_ctx, key, param, &value);
    9451022        if (!W_ERROR_IS_OK(werr)) {
     1023                err = SBC_ERR_NOMEM;
    9461024                goto done;
    9471025        }
    9481026
    9491027        *valstr = smbconf_format_registry_value(mem_ctx, value);
    950 
    9511028        if (*valstr == NULL) {
    952                 werr = WERR_NOMEM;
     1029                err = SBC_ERR_NOMEM;
    9531030        }
    9541031
    … …  
    9561033        talloc_free(key);
    9571034        talloc_free(value);
    958         return werr;
     1035        return err;
    9591036}
    9601037
    … …  
    9621039 * delete a parameter from configuration
    9631040 */
    964 static WERROR smbconf_reg_delete_parameter(struct smbconf_ctx *ctx,
     1041static sbcErr smbconf_reg_delete_parameter(struct smbconf_ctx *ctx,
    9651042                                           const char *service,
    9661043                                           const char *param)
    9671044{
    9681045        struct registry_key *key = NULL;
    969         WERROR werr = WERR_OK;
     1046        WERROR werr;
     1047        sbcErr err;
    9701048        TALLOC_CTX *mem_ctx = talloc_stackframe();
    9711049
    972         werr = smbconf_reg_open_service_key(mem_ctx, ctx, service,
    973                                             REG_KEY_ALL, &key);
    974         if (!W_ERROR_IS_OK(werr)) {
     1050        err = smbconf_reg_open_service_key(mem_ctx, ctx, service,
     1051                                           REG_KEY_ALL, &key);
     1052        if (!SBC_ERROR_IS_OK(err)) {
    9751053                goto done;
    9761054        }
    9771055
    9781056        if (!smbconf_reg_valname_valid(param)) {
    979                 werr = WERR_INVALID_PARAM;
     1057                err = SBC_ERR_INVALID_PARAM;
    9801058                goto done;
    9811059        }
    9821060
    9831061        if (!smbconf_value_exists(key, param)) {
    984                 werr = WERR_INVALID_PARAM;
     1062                err = SBC_ERR_OK;
    9851063                goto done;
    9861064        }
    9871065
    9881066        werr = reg_deletevalue(key, param);
     1067        if (!W_ERROR_IS_OK(werr)) {
     1068                err = SBC_ERR_ACCESS_DENIED;
     1069        }
    9891070
    9901071done:
    9911072        talloc_free(mem_ctx);
    992         return werr;
    993 }
    994 
    995 static WERROR smbconf_reg_get_includes(struct smbconf_ctx *ctx,
     1073        return err;
     1074}
     1075
     1076static sbcErr smbconf_reg_get_includes(struct smbconf_ctx *ctx,
    9961077                                       TALLOC_CTX *mem_ctx,
    9971078                                       const char *service,
    … …  
    9991080                                       char ***includes)
    10001081{
    1001         WERROR werr;
     1082        sbcErr err;
    10021083        struct registry_key *key = NULL;
    10031084        TALLOC_CTX *tmp_ctx = talloc_stackframe();
    10041085
    1005         werr = smbconf_reg_open_service_key(tmp_ctx, ctx, service,
    1006                                             REG_KEY_READ, &key);
    1007         if (!W_ERROR_IS_OK(werr)) {
    1008                 goto done;
    1009         }
    1010 
    1011         werr = smbconf_reg_get_includes_internal(mem_ctx, key, num_includes,
     1086        err = smbconf_reg_open_service_key(tmp_ctx, ctx, service,
     1087                                           REG_KEY_READ, &key);
     1088        if (!SBC_ERROR_IS_OK(err)) {
     1089                goto done;
     1090        }
     1091
     1092        err = smbconf_reg_get_includes_internal(mem_ctx, key, num_includes,
    10121093                                                 includes);
     1094        if (!SBC_ERROR_IS_OK(err)) {
     1095                goto done;
     1096        }
    10131097
    10141098done:
    10151099        talloc_free(tmp_ctx);
    1016         return werr;
    1017 }
    1018 
    1019 static WERROR smbconf_reg_set_includes(struct smbconf_ctx *ctx,
     1100        return err;
     1101}
     1102
     1103static sbcErr smbconf_reg_set_includes(struct smbconf_ctx *ctx,
    10201104                                       const char *service,
    10211105                                       uint32_t num_includes,
    … …  
    10231107{
    10241108        WERROR werr = WERR_OK;
     1109        sbcErr err;
    10251110        struct registry_key *key = NULL;
    10261111        TALLOC_CTX *tmp_ctx = talloc_stackframe();
    10271112
    1028         werr = smbconf_reg_open_service_key(tmp_ctx, ctx, service,
    1029                                             REG_KEY_ALL, &key);
    1030         if (!W_ERROR_IS_OK(werr)) {
     1113        err = smbconf_reg_open_service_key(tmp_ctx, ctx, service,
     1114                                           REG_KEY_ALL, &key);
     1115        if (!SBC_ERROR_IS_OK(err)) {
    10311116                goto done;
    10321117        }
    … …  
    10341119        if (num_includes == 0) {
    10351120                if (!smbconf_value_exists(key, INCLUDES_VALNAME)) {
     1121                        err = SBC_ERR_OK;
    10361122                        goto done;
    10371123                }
    10381124                werr = reg_deletevalue(key, INCLUDES_VALNAME);
     1125                if (!W_ERROR_IS_OK(werr)) {
     1126                        err = SBC_ERR_ACCESS_DENIED;
     1127                        goto done;
     1128                }
    10391129        } else {
    1040                 werr = smbconf_reg_set_multi_sz_value(key, INCLUDES_VALNAME,
     1130                err = smbconf_reg_set_multi_sz_value(key, INCLUDES_VALNAME,
    10411131                                                      num_includes, includes);
    10421132        }
    … …  
    10441134done:
    10451135        talloc_free(tmp_ctx);
    1046         return werr;
    1047 }
    1048 
    1049 static WERROR smbconf_reg_delete_includes(struct smbconf_ctx *ctx,
     1136        return err;
     1137}
     1138
     1139static sbcErr smbconf_reg_delete_includes(struct smbconf_ctx *ctx,
    10501140                                          const char *service)
    10511141{
    1052         WERROR werr = WERR_OK;
     1142        WERROR werr;
     1143        sbcErr err;
    10531144        struct registry_key *key = NULL;
    10541145        TALLOC_CTX *tmp_ctx = talloc_stackframe();
    10551146
    1056         werr = smbconf_reg_open_service_key(tmp_ctx, ctx, service,
    1057                                             REG_KEY_ALL, &key);
    1058         if (!W_ERROR_IS_OK(werr)) {
     1147        err = smbconf_reg_open_service_key(tmp_ctx, ctx, service,
     1148                                           REG_KEY_ALL, &key);
     1149        if (!SBC_ERROR_IS_OK(err)) {
    10591150                goto done;
    10601151        }
    10611152
    10621153        if (!smbconf_value_exists(key, INCLUDES_VALNAME)) {
     1154                err = SBC_ERR_OK;
    10631155                goto done;
    10641156        }
    10651157
    10661158        werr = reg_deletevalue(key, INCLUDES_VALNAME);
    1067 
    1068 
     1159        if (!W_ERROR_IS_OK(werr)) {
     1160                err = SBC_ERR_ACCESS_DENIED;
     1161                goto done;
     1162        }
     1163
     1164        err = SBC_ERR_OK;
    10691165done:
    10701166        talloc_free(tmp_ctx);
    1071         return werr;
    1072 }
    1073 
    1074 static WERROR smbconf_reg_transaction_start(struct smbconf_ctx *ctx)
    1075 {
    1076         return regdb_transaction_start();
    1077 }
    1078 
    1079 static WERROR smbconf_reg_transaction_commit(struct smbconf_ctx *ctx)
    1080 {
    1081         return regdb_transaction_commit();
    1082 }
    1083 
    1084 static WERROR smbconf_reg_transaction_cancel(struct smbconf_ctx *ctx)
    1085 {
    1086         return regdb_transaction_cancel();
     1167        return err;
     1168}
     1169
     1170static sbcErr smbconf_reg_transaction_start(struct smbconf_ctx *ctx)
     1171{
     1172        WERROR werr;
     1173
     1174        werr = regdb_transaction_start();
     1175        if (!W_ERROR_IS_OK(werr)) {
     1176                return SBC_ERR_IO_FAILURE;
     1177        }
     1178
     1179        return SBC_ERR_OK;
     1180}
     1181
     1182static sbcErr smbconf_reg_transaction_commit(struct smbconf_ctx *ctx)
     1183{
     1184        WERROR werr;
     1185
     1186        werr = regdb_transaction_commit();
     1187        if (!W_ERROR_IS_OK(werr)) {
     1188                return SBC_ERR_IO_FAILURE;
     1189        }
     1190
     1191        return SBC_ERR_OK;
     1192}
     1193
     1194static sbcErr smbconf_reg_transaction_cancel(struct smbconf_ctx *ctx)
     1195{
     1196        WERROR werr;
     1197
     1198        werr = regdb_transaction_cancel();
     1199        if (!W_ERROR_IS_OK(werr)) {
     1200                return SBC_ERR_IO_FAILURE;
     1201        }
     1202
     1203        return SBC_ERR_OK;
    10871204}
    10881205
    … …  
    11171234 * the only function that is exported from this module
    11181235 */
    1119 WERROR smbconf_init_reg(TALLOC_CTX *mem_ctx, struct smbconf_ctx **conf_ctx,
     1236sbcErr smbconf_init_reg(TALLOC_CTX *mem_ctx, struct smbconf_ctx **conf_ctx,
    11201237                        const char *path)
    11211238{

  • vendor/current/source3/lib/smbconf/smbconf_reg.h

    r414 r740  
    2727 */
    2828
    29 WERROR smbconf_init_reg(TALLOC_CTX *mem_ctx, struct smbconf_ctx **conf_ctx,
     29sbcErr smbconf_init_reg(TALLOC_CTX *mem_ctx, struct smbconf_ctx **conf_ctx,
    3030                        const char *path);
    3131

  • vendor/current/source3/lib/smbconf/testsuite.c

    r414 r740  
    1919
    2020#include "includes.h"
     21#include "popt_common.h"
     22#include "lib/smbconf/smbconf.h"
     23#include "lib/smbconf/smbconf_init.h"
     24#include "lib/smbconf/smbconf_reg.h"
     25#include "lib/smbconf/smbconf_txt.h"
    2126
    2227static void print_strings(const char *prefix,
    … …  
    3641static bool test_get_includes(struct smbconf_ctx *ctx)
    3742{
    38         WERROR werr;
     43        sbcErr err;
    3944        bool ret = false;
    4045        uint32_t num_includes = 0;
    … …  
    4348
    4449        printf("TEST: get_includes\n");
    45         werr = smbconf_get_global_includes(ctx, mem_ctx,
    46                                            &num_includes, &includes);
    47         if (!W_ERROR_IS_OK(werr)) {
    48                 printf("FAIL: get_includes - %s\n", win_errstr(werr));
     50        err = smbconf_get_global_includes(ctx, mem_ctx,
     51                                          &num_includes, &includes);
     52        if (!SBC_ERROR_IS_OK(err)) {
     53                printf("FAIL: get_includes - %s\n", sbcErrorString(err));
    4954                goto done;
    5055        }
    … …  
    6469static bool test_set_get_includes(struct smbconf_ctx *ctx)
    6570{
    66         WERROR werr;
     71        sbcErr err;
    6772        uint32_t count;
    6873        bool ret = false;
    … …  
    7883        printf("TEST: set_get_includes\n");
    7984
    80         werr = smbconf_set_global_includes(ctx, set_num_includes, set_includes);
    81         if (!W_ERROR_IS_OK(werr)) {
     85        err = smbconf_set_global_includes(ctx, set_num_includes, set_includes);
     86        if (!SBC_ERROR_IS_OK(err)) {
    8287                printf("FAIL: get_set_includes (setting includes) - %s\n",
    83                        win_errstr(werr));
    84                 goto done;
    85         }
    86 
    87         werr = smbconf_get_global_includes(ctx, mem_ctx, &get_num_includes,
    88                                            &get_includes);
    89         if (!W_ERROR_IS_OK(werr)) {
     88                       sbcErrorString(err));
     89                goto done;
     90        }
     91
     92        err = smbconf_get_global_includes(ctx, mem_ctx, &get_num_includes,
     93                                          &get_includes);
     94        if (!SBC_ERROR_IS_OK(err)) {
    9095                printf("FAIL: get_set_includes (getting includes) - %s\n",
    91                        win_errstr(werr));
     96                       sbcErrorString(err));
    9297                goto done;
    9398        }
    … …  
    121126static bool test_delete_includes(struct smbconf_ctx *ctx)
    122127{
    123         WERROR werr;
     128        sbcErr err;
    124129        bool ret = false;
    125130        const char *set_includes[] = {
    … …  
    133138        printf("TEST: delete_includes\n");
    134139
    135         werr = smbconf_set_global_includes(ctx, set_num_includes, set_includes);
    136         if (!W_ERROR_IS_OK(werr)) {
     140        err = smbconf_set_global_includes(ctx, set_num_includes, set_includes);
     141        if (!SBC_ERROR_IS_OK(err)) {
    137142                printf("FAIL: delete_includes (setting includes) - %s\n",
    138                        win_errstr(werr));
    139                 goto done;
    140         }
    141 
    142         werr = smbconf_delete_global_includes(ctx);
    143         if (!W_ERROR_IS_OK(werr)) {
     143                       sbcErrorString(err));
     144                goto done;
     145        }
     146
     147        err = smbconf_delete_global_includes(ctx);
     148        if (!SBC_ERROR_IS_OK(err)) {
    144149                printf("FAIL: delete_includes (deleting includes) - %s\n",
    145                        win_errstr(werr));
    146                 goto done;
    147         }
    148 
    149         werr = smbconf_get_global_includes(ctx, mem_ctx, &get_num_includes,
    150                                            &get_includes);
    151         if (!W_ERROR_IS_OK(werr)) {
     150                       sbcErrorString(err));
     151                goto done;
     152        }
     153
     154        err = smbconf_get_global_includes(ctx, mem_ctx, &get_num_includes,
     155                                          &get_includes);
     156        if (!SBC_ERROR_IS_OK(err)) {
    152157                printf("FAIL: delete_includes (getting includes) - %s\n",
    153                        win_errstr(werr));
     158                       sbcErrorString(err));
    154159                goto done;
    155160        }
    … …  
    160165        }
    161166
    162         werr = smbconf_delete_global_includes(ctx);
    163         if (!W_ERROR_IS_OK(werr)) {
     167        err = smbconf_delete_global_includes(ctx);
     168        if (!SBC_ERROR_IS_OK(err)) {
    164169                printf("FAIL: delete_includes (delete empty includes) - "
    165                        "%s\n", win_errstr(werr));
     170                       "%s\n", sbcErrorString(err));
    166171                goto done;
    167172        }
    … …  
    199204static bool torture_smbconf_txt(void)
    200205{
    201         WERROR werr;
     206        sbcErr err;
    202207        bool ret = true;
    203208        const char *filename = "/tmp/smb.conf.smbconf_testsuite";
    … …  
    213218
    214219        printf("TEST: init\n");
    215         werr = smbconf_init_txt(mem_ctx, &conf_ctx, filename);
    216         if (!W_ERROR_IS_OK(werr)) {
    217                 printf("FAIL: text backend failed: %s\n", win_errstr(werr));
     220        err = smbconf_init_txt(mem_ctx, &conf_ctx, filename);
     221        if (!SBC_ERROR_IS_OK(err)) {
     222                printf("FAIL: text backend failed: %s\n", sbcErrorString(err));
    218223                ret = false;
    219224                goto done;
    … …  
    241246static bool torture_smbconf_reg(void)
    242247{
    243         WERROR werr;
     248        sbcErr err;
    244249        bool ret = true;
    245250        struct smbconf_ctx *conf_ctx = NULL;
    … …  
    249254
    250255        printf("TEST: init\n");
    251         werr = smbconf_init_reg(mem_ctx, &conf_ctx, NULL);
    252         if (!W_ERROR_IS_OK(werr)) {
    253                 printf("FAIL: init failed: %s\n", win_errstr(werr));
     256        err = smbconf_init_reg(mem_ctx, &conf_ctx, NULL);
     257        if (!SBC_ERROR_IS_OK(err)) {
     258                printf("FAIL: init failed: %s\n", sbcErrorString(err));
    254259                ret = false;
    255260                goto done;
    … …  
    290295
    291296        load_case_tables();
    292         dbf = x_stderr;
     297        setup_logging(argv[0], DEBUG_STDERR);
    293298
    294299        /* parse options */
Note: See TracChangeset for help on using the changeset viewer.