Ignore:
Timestamp:
Nov 27, 2012, 4:43:17 PM (13 years ago)
Author:
Silvan Scherrer
Message:

Samba Server: updated trunk to 3.6.0

Location:
trunk/server
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/server

  • trunk/server/source3/utils/net_conf.c

    r480 r745  
    2929
    3030#include "includes.h"
     31#include "system/filesys.h"
    3132#include "utils/net.h"
     33#include "lib/smbconf/smbconf.h"
     34#include "lib/smbconf/smbconf_init.h"
     35#include "lib/smbconf/smbconf_reg.h"
    3236
    3337/**********************************************************************
    … …  
    171175 * This functions process a service previously loaded with libsmbconf.
    172176 */
    173 static WERROR import_process_service(struct net_context *c,
     177static sbcErr import_process_service(struct net_context *c,
    174178                                     struct smbconf_ctx *conf_ctx,
    175179                                     struct smbconf_service *service)
    176180{
    177181        uint32_t idx;
    178         WERROR werr = WERR_OK;
     182        sbcErr err = SBC_ERR_OK;
    179183        uint32_t num_includes = 0;
    180184        char **includes = NULL;
    … …  
    197201
    198202        if (smbconf_share_exists(conf_ctx, service->name)) {
    199                 werr = smbconf_delete_share(conf_ctx, service->name);
    200                 if (!W_ERROR_IS_OK(werr)) {
     203                err = smbconf_delete_share(conf_ctx, service->name);
     204                if (!SBC_ERROR_IS_OK(err)) {
    201205                        goto done;
    202206                }
    203207        }
    204         werr = smbconf_create_share(conf_ctx, service->name);
    205         if (!W_ERROR_IS_OK(werr)) {
     208        err = smbconf_create_share(conf_ctx, service->name);
     209        if (!SBC_ERROR_IS_OK(err)) {
    206210                goto done;
    207211        }
    … …  
    214218                                                        num_includes+1);
    215219                        if (includes == NULL) {
    216                                 werr = WERR_NOMEM;
     220                                err = SBC_ERR_NOMEM;
    217221                                goto done;
    218222                        }
    … …  
    220224                                                service->param_values[idx]);
    221225                        if (includes[num_includes] == NULL) {
    222                                 werr = WERR_NOMEM;
     226                                err = SBC_ERR_NOMEM;
    223227                                goto done;
    224228                        }
    225229                        num_includes++;
    226230                } else {
    227                         werr = smbconf_set_parameter(conf_ctx,
     231                        err = smbconf_set_parameter(conf_ctx,
    228232                                                     service->name,
    229233                                                     service->param_names[idx],
    230234                                                     service->param_values[idx]);
    231                         if (!W_ERROR_IS_OK(werr)) {
     235                        if (!SBC_ERROR_IS_OK(err)) {
    232236                                d_fprintf(stderr,
    233237                                          _("Error in section [%s], parameter \"%s\": %s\n"),
    234238                                          service->name, service->param_names[idx],
    235                                           win_errstr(werr));
     239                                          sbcErrorString(err));
    236240                                goto done;
    237241                        }
    … …  
    239243        }
    240244
    241         werr = smbconf_set_includes(conf_ctx, service->name, num_includes,
    242                                     (const char **)includes);
    243 
     245        err = smbconf_set_includes(conf_ctx, service->name, num_includes,
     246                                   (const char **)includes);
     247        if (!SBC_ERROR_IS_OK(err)) {
     248                goto done;
     249        }
     250
     251        err = SBC_ERR_OK;
    244252done:
    245253        TALLOC_FREE(mem_ctx);
    246         return werr;
     254        return err;
    247255}
    248256
    … …  
    257265                         int argc, const char **argv)
    258266{
    259         WERROR werr = WERR_OK;
     267        sbcErr err;
    260268        int ret = -1;
    261269        TALLOC_CTX *mem_ctx;
    … …  
    271279        }
    272280
    273         werr = smbconf_get_config(conf_ctx, mem_ctx, &num_shares, &shares);
    274         if (!W_ERROR_IS_OK(werr)) {
     281        err = smbconf_get_config(conf_ctx, mem_ctx, &num_shares, &shares);
     282        if (!SBC_ERROR_IS_OK(err)) {
    275283                d_fprintf(stderr, _("Error getting config: %s\n"),
    276                           win_errstr(werr));
     284                          sbcErrorString(err));
    277285                goto done;
    278286        }
    … …  
    312320        TALLOC_CTX *mem_ctx;
    313321        struct smbconf_ctx *txt_ctx;
    314         WERROR werr;
     322        sbcErr err;
    315323
    316324        if (c->display_usage)
    … …  
    344352        }
    345353
    346         werr = smbconf_init(mem_ctx, &txt_ctx, conf_source);
    347         if (!W_ERROR_IS_OK(werr)) {
     354        err = smbconf_init(mem_ctx, &txt_ctx, conf_source);
     355        if (!SBC_ERROR_IS_OK(err)) {
    348356                d_printf(_("error loading file '%s': %s\n"), filename,
    349                          win_errstr(werr));
     357                         sbcErrorString(err));
    350358                goto done;
    351359        }
    … …  
    359367                struct smbconf_service *service = NULL;
    360368
    361                 werr = smbconf_get_share(txt_ctx, mem_ctx,
    362                                          servicename,
    363                                          &service);
    364                 if (!W_ERROR_IS_OK(werr)) {
     369                err = smbconf_get_share(txt_ctx, mem_ctx,
     370                                        servicename,
     371                                        &service);
     372                if (!SBC_ERROR_IS_OK(err)) {
    365373                        goto cancel;
    366374                }
    367375
    368                 werr = smbconf_transaction_start(conf_ctx);
    369                 if (!W_ERROR_IS_OK(werr)) {
     376                err = smbconf_transaction_start(conf_ctx);
     377                if (!SBC_ERROR_IS_OK(err)) {
    370378                        d_printf(_("error starting transaction: %s\n"),
    371                                  win_errstr(werr));
     379                                 sbcErrorString(err));
    372380                        goto done;
    373381                }
    374382
    375                 werr = import_process_service(c, conf_ctx, service);
    376                 if (!W_ERROR_IS_OK(werr)) {
     383                err = import_process_service(c, conf_ctx, service);
     384                if (!SBC_ERROR_IS_OK(err)) {
    377385                        goto cancel;
    378386                }
    … …  
    381389                uint32_t num_shares, sidx;
    382390
    383                 werr = smbconf_get_config(txt_ctx, mem_ctx,
     391                err = smbconf_get_config(txt_ctx, mem_ctx,
    384392                                          &num_shares,
    385393                                          &services);
    386                 if (!W_ERROR_IS_OK(werr)) {
     394                if (!SBC_ERROR_IS_OK(err)) {
    387395                        goto cancel;
    388396                }
    389397                if (!c->opt_testmode) {
    390                         werr = smbconf_drop(conf_ctx);
    391                         if (!W_ERROR_IS_OK(werr)) {
     398                        if (!SBC_ERROR_IS_OK(smbconf_drop(conf_ctx))) {
    392399                                goto cancel;
    393400                        }
    … …  
    396403                /*
    397404                 * Wrap the importing of shares into a transaction,
    398                  * but only 100 at a time, in order to serve memory.
     405                 * but only 100 at a time, in order to save memory.
    399406                 * The allocated memory accumulates across the actions
    400407                 * within the transaction, and for me, some 1500
    … …  
    402409                 * was exceeded.
    403410                 */
    404                 werr = smbconf_transaction_start(conf_ctx);
    405                 if (!W_ERROR_IS_OK(werr)) {
     411                err = smbconf_transaction_start(conf_ctx);
     412                if (!SBC_ERROR_IS_OK(err)) {
    406413                        d_printf(_("error starting transaction: %s\n"),
    407                                  win_errstr(werr));
     414                                 sbcErrorString(err));
    408415                        goto done;
    409416                }
    410417
    411418                for (sidx = 0; sidx < num_shares; sidx++) {
    412                         werr = import_process_service(c, conf_ctx,
    413                                                       services[sidx]);
    414                         if (!W_ERROR_IS_OK(werr)) {
     419                        err = import_process_service(c, conf_ctx,
     420                                                     services[sidx]);
     421                        if (!SBC_ERROR_IS_OK(err)) {
    415422                                goto cancel;
    416423                        }
    … …  
    420427                        }
    421428
    422                         werr = smbconf_transaction_commit(conf_ctx);
    423                         if (!W_ERROR_IS_OK(werr)) {
     429                        err = smbconf_transaction_commit(conf_ctx);
     430                        if (!SBC_ERROR_IS_OK(err)) {
    424431                                d_printf(_("error committing transaction: "
    425432                                           "%s\n"),
    426                                          win_errstr(werr));
     433                                         sbcErrorString(err));
    427434                                goto done;
    428435                        }
    429                         werr = smbconf_transaction_start(conf_ctx);
    430                         if (!W_ERROR_IS_OK(werr)) {
     436                        err = smbconf_transaction_start(conf_ctx);
     437                        if (!SBC_ERROR_IS_OK(err)) {
    431438                                d_printf(_("error starting transaction: %s\n"),
    432                                          win_errstr(werr));
     439                                         sbcErrorString(err));
    433440                                goto done;
    434441                        }
    … …  
    436443        }
    437444
    438         werr = smbconf_transaction_commit(conf_ctx);
    439         if (!W_ERROR_IS_OK(werr)) {
     445        err = smbconf_transaction_commit(conf_ctx);
     446        if (!SBC_ERROR_IS_OK(err)) {
    440447                d_printf(_("error committing transaction: %s\n"),
    441                          win_errstr(werr));
     448                         sbcErrorString(err));
    442449        } else {
    443450                ret = 0;
    … …  
    447454
    448455cancel:
    449         werr = smbconf_transaction_cancel(conf_ctx);
    450         if (!W_ERROR_IS_OK(werr)) {
     456        err = smbconf_transaction_cancel(conf_ctx);
     457        if (!SBC_ERROR_IS_OK(err)) {
    451458                d_printf(_("error cancelling transaction: %s\n"),
    452                          win_errstr(werr));
     459                         sbcErrorString(err));
    453460        }
    454461
    … …  
    462469                               const char **argv)
    463470{
    464         WERROR werr = WERR_OK;
     471        sbcErr err;
    465472        int ret = -1;
    466473        uint32_t count, num_shares = 0;
    … …  
    475482        }
    476483
    477         werr = smbconf_get_share_names(conf_ctx, mem_ctx, &num_shares,
    478                                        &share_names);
    479         if (!W_ERROR_IS_OK(werr)) {
     484        err = smbconf_get_share_names(conf_ctx, mem_ctx, &num_shares,
     485                                      &share_names);
     486        if (!SBC_ERROR_IS_OK(err)) {
    480487                goto done;
    481488        }
    … …  
    497504{
    498505        int ret = -1;
    499         WERROR werr;
     506        sbcErr err;
    500507
    501508        if (argc != 0 || c->display_usage) {
    … …  
    504511        }
    505512
    506         werr = smbconf_drop(conf_ctx);
    507         if (!W_ERROR_IS_OK(werr)) {
     513        err = smbconf_drop(conf_ctx);
     514        if (!SBC_ERROR_IS_OK(err)) {
    508515                d_fprintf(stderr, _("Error deleting configuration: %s\n"),
    509                           win_errstr(werr));
     516                          sbcErrorString(err));
    510517                goto done;
    511518        }
    … …  
    522529{
    523530        int ret = -1;
    524         WERROR werr = WERR_OK;
     531        sbcErr err;
    525532        const char *sharename = NULL;
    526533        TALLOC_CTX *mem_ctx;
    … …  
    541548        }
    542549
    543         werr = smbconf_get_share(conf_ctx, mem_ctx, sharename, &service);
    544         if (!W_ERROR_IS_OK(werr)) {
     550        err = smbconf_get_share(conf_ctx, mem_ctx, sharename, &service);
     551        if (!SBC_ERROR_IS_OK(err)) {
    545552                d_printf(_("error getting share parameters: %s\n"),
    546                          win_errstr(werr));
     553                         sbcErrorString(err));
    547554                goto done;
    548555        }
    … …  
    573580{
    574581        int ret = -1;
    575         WERROR werr = WERR_OK;
     582        sbcErr err;
    576583        char *sharename = NULL;
    577584        const char *path = NULL;
    … …  
    579586        const char *guest_ok = "no";
    580587        const char *writeable = "no";
    581         SMB_STRUCT_STAT sbuf;
    582588        TALLOC_CTX *mem_ctx = talloc_stackframe();
    583589
    … …  
    679685        }
    680686
    681         if (sys_stat(path, &sbuf, false) != 0) {
    682                 d_fprintf(stderr,
    683                           _("ERROR: cannot stat path '%s' to ensure "
    684                             "this is a directory.\n"
    685                             "Error was '%s'.\n"),
    686                           path, strerror(errno));
    687                 goto done;
    688         }
    689 
    690         if (!S_ISDIR(sbuf.st_ex_mode)) {
    691                 d_fprintf(stderr,
    692                           _("ERROR: path '%s' is not a directory.\n"),
    693                           path);
    694                 goto done;
    695         }
    696 
    697687        /*
    698688         * start a transaction
    699689         */
    700690
    701         werr = smbconf_transaction_start(conf_ctx);
    702         if (!W_ERROR_IS_OK(werr)) {
     691        err = smbconf_transaction_start(conf_ctx);
     692        if (!SBC_ERROR_IS_OK(err)) {
    703693                d_printf("error starting transaction: %s\n",
    704                          win_errstr(werr));
     694                         sbcErrorString(err));
    705695                goto done;
    706696        }
    … …  
    710700         */
    711701
    712         werr = smbconf_create_share(conf_ctx, sharename);
    713         if (!W_ERROR_IS_OK(werr)) {
     702        err = smbconf_create_share(conf_ctx, sharename);
     703        if (!SBC_ERROR_IS_OK(err)) {
    714704                d_fprintf(stderr, _("Error creating share %s: %s\n"),
    715                           sharename, win_errstr(werr));
     705                          sharename, sbcErrorString(err));
    716706                goto cancel;
    717707        }
    … …  
    721711         */
    722712
    723         werr = smbconf_set_parameter(conf_ctx, sharename, "path", path);
    724         if (!W_ERROR_IS_OK(werr)) {
     713        err = smbconf_set_parameter(conf_ctx, sharename, "path", path);
     714        if (!SBC_ERROR_IS_OK(err)) {
    725715                d_fprintf(stderr, _("Error setting parameter %s: %s\n"),
    726                           "path", win_errstr(werr));
     716                          "path", sbcErrorString(err));
    727717                goto cancel;
    728718        }
    729719
    730720        if (comment != NULL) {
    731                 werr = smbconf_set_parameter(conf_ctx, sharename, "comment",
    732                                              comment);
    733                 if (!W_ERROR_IS_OK(werr)) {
     721                err = smbconf_set_parameter(conf_ctx, sharename, "comment",
     722                                            comment);
     723                if (!SBC_ERROR_IS_OK(err)) {
    734724                        d_fprintf(stderr, _("Error setting parameter %s: %s\n"),
    735                                   "comment", win_errstr(werr));
     725                                  "comment", sbcErrorString(err));
    736726                        goto cancel;
    737727                }
    738728        }
    739729
    740         werr = smbconf_set_parameter(conf_ctx, sharename, "guest ok", guest_ok);
    741         if (!W_ERROR_IS_OK(werr)) {
     730        err = smbconf_set_parameter(conf_ctx, sharename, "guest ok", guest_ok);
     731        if (!SBC_ERROR_IS_OK(err)) {
    742732                d_fprintf(stderr, _("Error setting parameter %s: %s\n"),
    743                           "'guest ok'", win_errstr(werr));
     733                          "'guest ok'", sbcErrorString(err));
    744734                goto cancel;
    745735        }
    746736
    747         werr = smbconf_set_parameter(conf_ctx, sharename, "writeable",
    748                                      writeable);
    749         if (!W_ERROR_IS_OK(werr)) {
     737        err = smbconf_set_parameter(conf_ctx, sharename, "writeable",
     738                                    writeable);
     739        if (!SBC_ERROR_IS_OK(err)) {
    750740                d_fprintf(stderr, _("Error setting parameter %s: %s\n"),
    751                           "writeable", win_errstr(werr));
     741                          "writeable", sbcErrorString(err));
    752742                goto cancel;
    753743        }
    … …  
    757747         */
    758748
    759         werr = smbconf_transaction_commit(conf_ctx);
    760         if (!W_ERROR_IS_OK(werr)) {
     749        err = smbconf_transaction_commit(conf_ctx);
     750        if (!SBC_ERROR_IS_OK(err)) {
    761751                d_printf("error committing transaction: %s\n",
    762                          win_errstr(werr));
     752                         sbcErrorString(err));
    763753        } else {
    764754                ret = 0;
    … …  
    768758
    769759cancel:
    770         werr = smbconf_transaction_cancel(conf_ctx);
    771         if (!W_ERROR_IS_OK(werr)) {
     760        err = smbconf_transaction_cancel(conf_ctx);
     761        if (!SBC_ERROR_IS_OK(err)) {
    772762                d_printf("error cancelling transaction: %s\n",
    773                          win_errstr(werr));
     763                         sbcErrorString(err));
    774764        }
    775765
    … …  
    785775        int ret = -1;
    786776        const char *sharename = NULL;
    787         WERROR werr = WERR_OK;
     777        sbcErr err;
    788778        TALLOC_CTX *mem_ctx = talloc_stackframe();
    789779
    … …  
    798788        }
    799789
    800         werr = smbconf_delete_share(conf_ctx, sharename);
    801         if (!W_ERROR_IS_OK(werr)) {
     790        err = smbconf_delete_share(conf_ctx, sharename);
     791        if (!SBC_ERROR_IS_OK(err)) {
    802792                d_fprintf(stderr, _("Error deleting share %s: %s\n"),
    803                           sharename, win_errstr(werr));
     793                          sharename, sbcErrorString(err));
    804794                goto done;
    805795        }
    … …  
    815805{
    816806        int ret = -1;
    817         WERROR werr = WERR_OK;
     807        sbcErr err;
    818808        char *service = NULL;
    819809        char *param = NULL;
    … …  
    843833        value_str = argv[2];
    844834
    845         werr = smbconf_transaction_start(conf_ctx);
    846         if (!W_ERROR_IS_OK(werr)) {
     835        err = smbconf_transaction_start(conf_ctx);
     836        if (!SBC_ERROR_IS_OK(err)) {
    847837                d_printf(_("error starting transaction: %s\n"),
    848                          win_errstr(werr));
     838                         sbcErrorString(err));
    849839                goto done;
    850840        }
    851841
    852842        if (!smbconf_share_exists(conf_ctx, service)) {
    853                 werr = smbconf_create_share(conf_ctx, service);
    854                 if (!W_ERROR_IS_OK(werr)) {
     843                err = smbconf_create_share(conf_ctx, service);
     844                if (!SBC_ERROR_IS_OK(err)) {
    855845                        d_fprintf(stderr, _("Error creating share '%s': %s\n"),
    856                                   service, win_errstr(werr));
     846                                  service, sbcErrorString(err));
    857847                        goto cancel;
    858848                }
    859849        }
    860850
    861         werr = smbconf_set_parameter(conf_ctx, service, param, value_str);
    862 
    863         if (!W_ERROR_IS_OK(werr)) {
     851        err = smbconf_set_parameter(conf_ctx, service, param, value_str);
     852        if (!SBC_ERROR_IS_OK(err)) {
    864853                d_fprintf(stderr, _("Error setting value '%s': %s\n"),
    865                           param, win_errstr(werr));
     854                          param, sbcErrorString(err));
    866855                goto cancel;
    867856        }
    868857
    869         werr = smbconf_transaction_commit(conf_ctx);
    870         if (!W_ERROR_IS_OK(werr)) {
     858        err = smbconf_transaction_commit(conf_ctx);
     859        if (!SBC_ERROR_IS_OK(err)) {
    871860                d_printf(_("error committing transaction: %s\n"),
    872                          win_errstr(werr));
     861                         sbcErrorString(err));
    873862        } else {
    874863                ret = 0;
    … …  
    878867
    879868cancel:
    880         werr = smbconf_transaction_cancel(conf_ctx);
    881         if (!W_ERROR_IS_OK(werr)) {
     869        err = smbconf_transaction_cancel(conf_ctx);
     870        if (!SBC_ERROR_IS_OK(err)) {
    882871                d_printf(_("error cancelling transaction: %s\n"),
    883                          win_errstr(werr));
     872                         sbcErrorString(err));
    884873        }
    885874
    … …  
    893882{
    894883        int ret = -1;
    895         WERROR werr = WERR_OK;
     884        sbcErr err;
    896885        char *service = NULL;
    897886        char *param = NULL;
    … …  
    922911        }
    923912
    924         werr = smbconf_get_parameter(conf_ctx, mem_ctx, service, param, &valstr);
    925 
    926         if (W_ERROR_EQUAL(werr, WERR_NO_SUCH_SERVICE)) {
     913        err = smbconf_get_parameter(conf_ctx, mem_ctx, service, param, &valstr);
     914        if (SBC_ERROR_EQUAL(err, SBC_ERR_NO_SUCH_SERVICE)) {
    927915                d_fprintf(stderr,
    928916                          _("Error: given service '%s' does not exist.\n"),
    929917                          service);
    930918                goto done;
    931         } else if (W_ERROR_EQUAL(werr, WERR_INVALID_PARAM)) {
     919        } else if (SBC_ERROR_EQUAL(err, SBC_ERR_INVALID_PARAM)) {
    932920                d_fprintf(stderr,
    933921                          _("Error: given parameter '%s' is not set.\n"),
    934922                          param);
    935923                goto done;
    936         } else if (!W_ERROR_IS_OK(werr)) {
     924        } else if (!SBC_ERROR_IS_OK(err)) {
    937925                d_fprintf(stderr, _("Error getting value '%s': %s.\n"),
    938                           param, win_errstr(werr));
     926                          param, sbcErrorString(err));
    939927                goto done;
    940928        }
    … …  
    952940{
    953941        int ret = -1;
    954         WERROR werr = WERR_OK;
     942        sbcErr err;
    955943        char *service = NULL;
    956944        char *param = NULL;
    … …  
    978966        }
    979967
    980         werr = smbconf_delete_parameter(conf_ctx, service, param);
    981 
    982         if (W_ERROR_EQUAL(werr, WERR_NO_SUCH_SERVICE)) {
     968        err = smbconf_delete_parameter(conf_ctx, service, param);
     969        if (SBC_ERROR_EQUAL(err, SBC_ERR_NO_SUCH_SERVICE)) {
    983970                d_fprintf(stderr,
    984971                          _("Error: given service '%s' does not exist.\n"),
    985972                          service);
    986973                goto done;
    987         } else if (W_ERROR_EQUAL(werr, WERR_INVALID_PARAM)) {
     974        } else if (SBC_ERROR_EQUAL(err, SBC_ERR_INVALID_PARAM)) {
    988975                d_fprintf(stderr,
    989976                          _("Error: given parameter '%s' is not set.\n"),
    990977                          param);
    991978                goto done;
    992         } else if (!W_ERROR_IS_OK(werr)) {
     979        } else if (!SBC_ERROR_IS_OK(err)) {
    993980                d_fprintf(stderr, _("Error deleting value '%s': %s.\n"),
    994                           param, win_errstr(werr));
     981                          param, sbcErrorString(err));
    995982                goto done;
    996983        }
    … …  
    1007994                                int argc, const char **argv)
    1008995{
    1009         WERROR werr;
     996        sbcErr err;
    1010997        uint32_t num_includes;
    1011998        uint32_t count;
    … …  
    10261013        }
    10271014
    1028         werr = smbconf_get_includes(conf_ctx, mem_ctx, service,
     1015        err = smbconf_get_includes(conf_ctx, mem_ctx, service,
    10291016                                    &num_includes, &includes);
    1030         if (!W_ERROR_IS_OK(werr)) {
    1031                 d_printf(_("error getting includes: %s\n"), win_errstr(werr));
     1017        if (!SBC_ERROR_IS_OK(err)) {
     1018                d_printf(_("error getting includes: %s\n"), sbcErrorString(err));
    10321019                goto done;
    10331020        }
    … …  
    10481035                                int argc, const char **argv)
    10491036{
    1050         WERROR werr;
     1037        sbcErr err;
    10511038        char *service;
    10521039        uint32_t num_includes;
    … …  
    10731060        }
    10741061
    1075         werr = smbconf_set_includes(conf_ctx, service, num_includes, includes);
    1076         if (!W_ERROR_IS_OK(werr)) {
    1077                 d_printf(_("error setting includes: %s\n"), win_errstr(werr));
     1062        err = smbconf_set_includes(conf_ctx, service, num_includes, includes);
     1063        if (!SBC_ERROR_IS_OK(err)) {
     1064                d_printf(_("error setting includes: %s\n"), sbcErrorString(err));
    10781065                goto done;
    10791066        }
    … …  
    10901077                                int argc, const char **argv)
    10911078{
    1092         WERROR werr;
     1079        sbcErr err;
    10931080        char *service;
    10941081        int ret = -1;
    … …  
    11061093        }
    11071094
    1108         werr = smbconf_delete_includes(conf_ctx, service);
    1109         if (!W_ERROR_IS_OK(werr)) {
    1110                 d_printf(_("error deleting includes: %s\n"), win_errstr(werr));
     1095        err = smbconf_delete_includes(conf_ctx, service);
     1096        if (!SBC_ERROR_IS_OK(err)) {
     1097                d_printf(_("error deleting includes: %s\n"), sbcErrorString(err));
    11111098                goto done;
    11121099        }
    … …  
    11371124                                  int argc, const char **argv)
    11381125{
    1139         WERROR werr;
     1126        sbcErr err;
    11401127        TALLOC_CTX *mem_ctx = talloc_stackframe();
    11411128        struct smbconf_ctx *conf_ctx;
    11421129        int ret = -1;
    11431130
    1144         werr = smbconf_init(mem_ctx, &conf_ctx, "registry:");
    1145 
    1146         if (!W_ERROR_IS_OK(werr)) {
     1131        err = smbconf_init(mem_ctx, &conf_ctx, "registry:");
     1132        if (!SBC_ERROR_IS_OK(err)) {
    11471133                return -1;
    11481134        }
Note: See TracChangeset for help on using the changeset viewer.