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

Samba Server: update vendor to 3.6.0

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r414 r740  
    2828 **********************************************************************/
    2929
    30 static WERROR smbconf_global_check(struct smbconf_ctx *ctx)
     30static sbcErr smbconf_global_check(struct smbconf_ctx *ctx)
    3131{
    3232        if (!smbconf_share_exists(ctx, GLOBAL_NAME)) {
    3333                return smbconf_create_share(ctx, GLOBAL_NAME);
    3434        }
    35         return WERR_OK;
     35
     36        return SBC_ERR_OK;
    3637}
    3738
    … …  
    4243 *
    4344 **********************************************************************/
     45
     46const char *sbcErrorString(sbcErr error)
     47{
     48        switch (error) {
     49                case SBC_ERR_OK:
     50                        return "SBC_ERR_OK";
     51                case SBC_ERR_NOT_IMPLEMENTED:
     52                        return "SBC_ERR_NOT_IMPLEMENTED";
     53                case SBC_ERR_NOT_SUPPORTED:
     54                        return "SBC_ERR_NOT_SUPPORTED";
     55                case SBC_ERR_UNKNOWN_FAILURE:
     56                        return "SBC_ERR_UNKNOWN_FAILURE";
     57                case SBC_ERR_NOMEM:
     58                        return "SBC_ERR_NOMEM";
     59                case SBC_ERR_INVALID_PARAM:
     60                        return "SBC_ERR_INVALID_PARAM";
     61                case SBC_ERR_BADFILE:
     62                        return "SBC_ERR_BADFILE";
     63                case SBC_ERR_NO_SUCH_SERVICE:
     64                        return "SBC_ERR_NO_SUCH_SERVICE";
     65                case SBC_ERR_IO_FAILURE:
     66                        return "SBC_ERR_IO_FAILURE";
     67                case SBC_ERR_CAN_NOT_COMPLETE:
     68                        return "SBC_ERR_CAN_NOT_COMPLETE";
     69                case SBC_ERR_NO_MORE_ITEMS:
     70                        return "SBC_ERR_NO_MORE_ITEMS";
     71                case SBC_ERR_FILE_EXISTS:
     72                        return "SBC_ERR_FILE_EXISTS";
     73                case SBC_ERR_ACCESS_DENIED:
     74                        return "SBC_ERR_ACCESS_DENIED";
     75        }
     76
     77        return "unknown sbcErr value";
     78}
     79
    4480
    4581/**
    … …  
    92128 * Drop the whole configuration (restarting empty).
    93129 */
    94 WERROR smbconf_drop(struct smbconf_ctx *ctx)
     130sbcErr smbconf_drop(struct smbconf_ctx *ctx)
    95131{
    96132        return ctx->ops->drop(ctx);
    … …  
    106142 *  param_values : list of lists of parameter values for each share
    107143 */
    108 WERROR smbconf_get_config(struct smbconf_ctx *ctx,
     144sbcErr smbconf_get_config(struct smbconf_ctx *ctx,
    109145                          TALLOC_CTX *mem_ctx,
    110146                          uint32_t *num_shares,
    111147                          struct smbconf_service ***services)
    112148{
    113         WERROR werr = WERR_OK;
     149        sbcErr err;
    114150        TALLOC_CTX *tmp_ctx = NULL;
    115151        uint32_t tmp_num_shares;
    … …  
    119155
    120156        if ((num_shares == NULL) || (services == NULL)) {
    121                 werr = WERR_INVALID_PARAM;
     157                err = SBC_ERR_INVALID_PARAM;
    122158                goto done;
    123159        }
    … …  
    125161        tmp_ctx = talloc_stackframe();
    126162
    127         werr = smbconf_get_share_names(ctx, tmp_ctx, &tmp_num_shares,
    128                                        &tmp_share_names);
    129         if (!W_ERROR_IS_OK(werr)) {
     163        err = smbconf_get_share_names(ctx, tmp_ctx, &tmp_num_shares,
     164                                      &tmp_share_names);
     165        if (!SBC_ERROR_IS_OK(err)) {
    130166                goto done;
    131167        }
    … …  
    133169        tmp_services = talloc_array(tmp_ctx, struct smbconf_service *,
    134170                                    tmp_num_shares);
    135 
    136171        if (tmp_services == NULL) {
    137                 werr = WERR_NOMEM;
     172                err = SBC_ERR_NOMEM;
    138173                goto done;
    139174        }
    140175
    141176        for (count = 0; count < tmp_num_shares; count++) {
    142                 werr = smbconf_get_share(ctx, tmp_services,
    143                                          tmp_share_names[count],
    144                                          &tmp_services[count]);
    145                 if (!W_ERROR_IS_OK(werr)) {
     177                err = smbconf_get_share(ctx, tmp_services,
     178                                        tmp_share_names[count],
     179                                        &tmp_services[count]);
     180                if (!SBC_ERROR_IS_OK(err)) {
    146181                        goto done;
    147182                }
    148183        }
    149184
    150         werr = WERR_OK;
     185        err = SBC_ERR_OK;
    151186
    152187        *num_shares = tmp_num_shares;
    … …  
    159194done:
    160195        talloc_free(tmp_ctx);
    161         return werr;
     196        return err;
    162197}
    163198
    … …  
    165200 * get the list of share names defined in the configuration.
    166201 */
    167 WERROR smbconf_get_share_names(struct smbconf_ctx *ctx,
     202sbcErr smbconf_get_share_names(struct smbconf_ctx *ctx,
    168203                               TALLOC_CTX *mem_ctx,
    169204                               uint32_t *num_shares,
    … …  
    186221 * Add a service if it does not already exist.
    187222 */
    188 WERROR smbconf_create_share(struct smbconf_ctx *ctx,
     223sbcErr smbconf_create_share(struct smbconf_ctx *ctx,
    189224                            const char *servicename)
    190225{
    191226        if ((servicename != NULL) && smbconf_share_exists(ctx, servicename)) {
    192                 return WERR_FILE_EXISTS;
     227                return SBC_ERR_FILE_EXISTS;
    193228        }
    194229
    … …  
    199234 * get a definition of a share (service) from configuration.
    200235 */
    201 WERROR smbconf_get_share(struct smbconf_ctx *ctx,
     236sbcErr smbconf_get_share(struct smbconf_ctx *ctx,
    202237                         TALLOC_CTX *mem_ctx,
    203238                         const char *servicename,
    … …  
    210245 * delete a service from configuration
    211246 */
    212 WERROR smbconf_delete_share(struct smbconf_ctx *ctx, const char *servicename)
     247sbcErr smbconf_delete_share(struct smbconf_ctx *ctx, const char *servicename)
    213248{
    214249        if (!smbconf_share_exists(ctx, servicename)) {
    215                 return WERR_NO_SUCH_SERVICE;
     250                return SBC_ERR_NO_SUCH_SERVICE;
    216251        }
    217252
    … …  
    222257 * set a configuration parameter to the value provided.
    223258 */
    224 WERROR smbconf_set_parameter(struct smbconf_ctx *ctx,
     259sbcErr smbconf_set_parameter(struct smbconf_ctx *ctx,
    225260                             const char *service,
    226261                             const char *param,
    … …  
    236271 * This also creates [global] when it does not exist.
    237272 */
    238 WERROR smbconf_set_global_parameter(struct smbconf_ctx *ctx,
     273sbcErr smbconf_set_global_parameter(struct smbconf_ctx *ctx,
    239274                                    const char *param, const char *val)
    240275{
    241         WERROR werr;
    242 
    243         werr = smbconf_global_check(ctx);
    244         if (W_ERROR_IS_OK(werr)) {
    245                 werr = smbconf_set_parameter(ctx, GLOBAL_NAME, param, val);
    246         }
    247 
    248         return werr;
     276        sbcErr err;
     277
     278        err = smbconf_global_check(ctx);
     279        if (!SBC_ERROR_IS_OK(err)) {
     280                return err;
     281        }
     282        err = smbconf_set_parameter(ctx, GLOBAL_NAME, param, val);
     283
     284        return err;
    249285}
    250286
    … …  
    252288 * get the value of a configuration parameter as a string
    253289 */
    254 WERROR smbconf_get_parameter(struct smbconf_ctx *ctx,
     290sbcErr smbconf_get_parameter(struct smbconf_ctx *ctx,
    255291                             TALLOC_CTX *mem_ctx,
    256292                             const char *service,
    … …  
    259295{
    260296        if (valstr == NULL) {
    261                 return WERR_INVALID_PARAM;
     297                return SBC_ERR_INVALID_PARAM;
    262298        }
    263299
    … …  
    270306 * Create [global] if it does not exist.
    271307 */
    272 WERROR smbconf_get_global_parameter(struct smbconf_ctx *ctx,
     308sbcErr smbconf_get_global_parameter(struct smbconf_ctx *ctx,
    273309                                    TALLOC_CTX *mem_ctx,
    274310                                    const char *param,
    275311                                    char **valstr)
    276312{
    277         WERROR werr;
    278 
    279         werr = smbconf_global_check(ctx);
    280         if (W_ERROR_IS_OK(werr)) {
    281                 werr = smbconf_get_parameter(ctx, mem_ctx, GLOBAL_NAME, param,
    282                                              valstr);
    283         }
    284 
    285         return werr;
     313        sbcErr err;
     314
     315        err = smbconf_global_check(ctx);
     316        if (!SBC_ERROR_IS_OK(err)) {
     317                return err;
     318        }
     319
     320        err = smbconf_get_parameter(ctx, mem_ctx, GLOBAL_NAME, param,
     321                                    valstr);
     322
     323        return err;
    286324}
    287325
    … …  
    289327 * delete a parameter from configuration
    290328 */
    291 WERROR smbconf_delete_parameter(struct smbconf_ctx *ctx,
     329sbcErr smbconf_delete_parameter(struct smbconf_ctx *ctx,
    292330                                const char *service, const char *param)
    293331{
    … …  
    300338 * Create [global] if it does not exist.
    301339 */
    302 WERROR smbconf_delete_global_parameter(struct smbconf_ctx *ctx,
     340sbcErr smbconf_delete_global_parameter(struct smbconf_ctx *ctx,
    303341                                       const char *param)
    304342{
    305         WERROR werr;
    306 
    307         werr = smbconf_global_check(ctx);
    308         if (W_ERROR_IS_OK(werr)) {
    309                 werr = smbconf_delete_parameter(ctx, GLOBAL_NAME, param);
    310         }
    311 
    312         return werr;
    313 }
    314 
    315 WERROR smbconf_get_includes(struct smbconf_ctx *ctx,
     343        sbcErr err;
     344
     345        err = smbconf_global_check(ctx);
     346        if (!SBC_ERROR_IS_OK(err)) {
     347                return err;
     348        }
     349        err = smbconf_delete_parameter(ctx, GLOBAL_NAME, param);
     350
     351        return err;
     352}
     353
     354sbcErr smbconf_get_includes(struct smbconf_ctx *ctx,
    316355                            TALLOC_CTX *mem_ctx,
    317356                            const char *service,
    … …  
    322361}
    323362
    324 WERROR smbconf_get_global_includes(struct smbconf_ctx *ctx,
     363sbcErr smbconf_get_global_includes(struct smbconf_ctx *ctx,
    325364                                   TALLOC_CTX *mem_ctx,
    326365                                   uint32_t *num_includes, char ***includes)
    327366{
    328         WERROR werr;
    329 
    330         werr = smbconf_global_check(ctx);
    331         if (W_ERROR_IS_OK(werr)) {
    332                 werr = smbconf_get_includes(ctx, mem_ctx, GLOBAL_NAME,
    333                                             num_includes, includes);
    334         }
    335 
    336         return werr;
    337 }
    338 
    339 WERROR smbconf_set_includes(struct smbconf_ctx *ctx,
     367        sbcErr err;
     368
     369        err = smbconf_global_check(ctx);
     370        if (!SBC_ERROR_IS_OK(err)) {
     371                return err;
     372        }
     373        err = smbconf_get_includes(ctx, mem_ctx, GLOBAL_NAME,
     374                                    num_includes, includes);
     375
     376        return err;
     377}
     378
     379sbcErr smbconf_set_includes(struct smbconf_ctx *ctx,
    340380                            const char *service,
    341381                            uint32_t num_includes, const char **includes)
    … …  
    344384}
    345385
    346 WERROR smbconf_set_global_includes(struct smbconf_ctx *ctx,
     386sbcErr smbconf_set_global_includes(struct smbconf_ctx *ctx,
    347387                                   uint32_t num_includes,
    348388                                   const char **includes)
    349389{
    350         WERROR werr;
    351 
    352         werr = smbconf_global_check(ctx);
    353         if (W_ERROR_IS_OK(werr)) {
    354                 werr = smbconf_set_includes(ctx, GLOBAL_NAME,
    355                                             num_includes, includes);
    356         }
    357 
    358         return werr;
    359 }
    360 
    361 
    362 WERROR smbconf_delete_includes(struct smbconf_ctx *ctx, const char *service)
     390        sbcErr err;
     391
     392        err = smbconf_global_check(ctx);
     393        if (!SBC_ERROR_IS_OK(err)) {
     394                return err;
     395        }
     396        err = smbconf_set_includes(ctx, GLOBAL_NAME,
     397                                   num_includes, includes);
     398
     399        return err;
     400}
     401
     402
     403sbcErr smbconf_delete_includes(struct smbconf_ctx *ctx, const char *service)
    363404{
    364405        return ctx->ops->delete_includes(ctx, service);
    365406}
    366407
    367 WERROR smbconf_delete_global_includes(struct smbconf_ctx *ctx)
    368 {
    369         WERROR werr;
    370 
    371         werr = smbconf_global_check(ctx);
    372         if (W_ERROR_IS_OK(werr)) {
    373                 werr = smbconf_delete_includes(ctx, GLOBAL_NAME);
    374         }
    375 
    376         return werr;
    377 }
    378 
    379 WERROR smbconf_transaction_start(struct smbconf_ctx *ctx)
     408sbcErr smbconf_delete_global_includes(struct smbconf_ctx *ctx)
     409{
     410        sbcErr err;
     411
     412        err = smbconf_global_check(ctx);
     413        if (!SBC_ERROR_IS_OK(err)) {
     414                return err;
     415        }
     416        err = smbconf_delete_includes(ctx, GLOBAL_NAME);
     417
     418        return err;
     419}
     420
     421sbcErr smbconf_transaction_start(struct smbconf_ctx *ctx)
    380422{
    381423        return ctx->ops->transaction_start(ctx);
    382424}
    383425
    384 WERROR smbconf_transaction_commit(struct smbconf_ctx *ctx)
     426sbcErr smbconf_transaction_commit(struct smbconf_ctx *ctx)
    385427{
    386428        return ctx->ops->transaction_commit(ctx);
    387429}
    388430
    389 WERROR smbconf_transaction_cancel(struct smbconf_ctx *ctx)
     431sbcErr smbconf_transaction_cancel(struct smbconf_ctx *ctx)
    390432{
    391433        return ctx->ops->transaction_cancel(ctx);
Note: See TracChangeset for help on using the changeset viewer.