2008-03-26 16:30:36 +03:00
/*
* Unix SMB / CIFS implementation .
2008-04-22 17:51:36 +04:00
* libsmbconf - Samba configuration library , text backend
2008-03-26 16:30:36 +03:00
* Copyright ( C ) Michael Adam 2008
*
* This program is free software ; you can redistribute it and / or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation ; either version 3 of the License , or
* ( at your option ) any later version .
*
* This program is distributed in the hope that it will be useful ,
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the
* GNU General Public License for more details .
*
* You should have received a copy of the GNU General Public License
* along with this program ; if not , see < http : //www.gnu.org/licenses/>.
*/
/*
* This is a sample implementation of a libsmbconf text backend
* using the params . c parser .
*
* It is read only .
* Don ' t expect brilliant performance , since it is not hashing the lists .
*/
# include "includes.h"
# include "smbconf_private.h"
2010-05-18 04:27:34 +04:00
# include "lib/smbconf/smbconf_txt.h"
2008-03-26 16:30:36 +03:00
2008-03-27 01:58:01 +03:00
struct txt_cache {
uint32_t current_share ;
uint32_t num_shares ;
char * * share_names ;
uint32_t * num_params ;
char * * * param_names ;
char * * * param_values ;
} ;
2008-03-26 16:30:36 +03:00
struct txt_private_data {
2008-03-27 01:58:01 +03:00
struct txt_cache * cache ;
2008-03-26 16:30:36 +03:00
uint64_t csn ;
2008-04-08 00:33:01 +04:00
bool verbatim ;
2008-03-26 16:30:36 +03:00
} ;
/**********************************************************************
*
* helper functions
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/**
* a convenience helper to cast the private data structure
*/
static struct txt_private_data * pd ( struct smbconf_ctx * ctx )
{
return ( struct txt_private_data * ) ( ctx - > data ) ;
}
static bool smbconf_txt_do_section ( const char * section , void * private_data )
{
2011-04-08 16:19:15 +04:00
sbcErr err ;
2008-03-26 16:30:36 +03:00
uint32_t idx ;
2008-04-08 00:43:33 +04:00
struct txt_private_data * tpd = ( struct txt_private_data * ) private_data ;
struct txt_cache * cache = tpd - > cache ;
2008-03-26 16:30:36 +03:00
2008-04-07 17:05:33 +04:00
if ( smbconf_find_in_array ( section , cache - > share_names ,
cache - > num_shares , & idx ) )
2008-03-26 16:30:36 +03:00
{
2008-03-27 01:58:52 +03:00
cache - > current_share = idx ;
2008-03-26 16:30:36 +03:00
return true ;
}
2011-04-08 16:19:15 +04:00
err = smbconf_add_string_to_array ( cache , & ( cache - > share_names ) ,
cache - > num_shares , section ) ;
if ( ! SBC_ERROR_IS_OK ( err ) ) {
2008-03-26 16:30:36 +03:00
return false ;
}
2008-03-27 01:58:52 +03:00
cache - > current_share = cache - > num_shares ;
cache - > num_shares + + ;
2009-01-21 20:50:16 +03:00
cache - > param_names = talloc_realloc ( cache ,
2008-03-27 01:58:52 +03:00
cache - > param_names ,
char * * ,
cache - > num_shares ) ;
if ( cache - > param_names = = NULL ) {
2008-03-26 16:30:36 +03:00
return false ;
}
2008-03-27 01:58:52 +03:00
cache - > param_names [ cache - > current_share ] = NULL ;
2008-03-26 16:30:36 +03:00
2009-01-21 20:50:16 +03:00
cache - > param_values = talloc_realloc ( cache ,
2008-03-27 01:58:52 +03:00
cache - > param_values ,
char * * ,
cache - > num_shares ) ;
if ( cache - > param_values = = NULL ) {
2008-03-26 16:30:36 +03:00
return false ;
}
2008-03-27 01:58:52 +03:00
cache - > param_values [ cache - > current_share ] = NULL ;
2008-03-26 16:30:36 +03:00
2009-01-21 20:50:16 +03:00
cache - > num_params = talloc_realloc ( cache ,
2008-03-27 01:58:52 +03:00
cache - > num_params ,
uint32_t ,
cache - > num_shares ) ;
if ( cache - > num_params = = NULL ) {
2008-03-26 16:30:36 +03:00
return false ;
}
2008-03-27 01:58:52 +03:00
cache - > num_params [ cache - > current_share ] = 0 ;
2008-03-26 16:30:36 +03:00
return true ;
}
static bool smbconf_txt_do_parameter ( const char * param_name ,
const char * param_value ,
void * private_data )
{
2011-04-08 16:19:15 +04:00
sbcErr err ;
2008-03-26 16:30:36 +03:00
char * * param_names , * * param_values ;
uint32_t num_params ;
uint32_t idx ;
2008-04-08 00:43:33 +04:00
struct txt_private_data * tpd = ( struct txt_private_data * ) private_data ;
struct txt_cache * cache = tpd - > cache ;
2008-03-26 16:30:36 +03:00
2008-03-27 01:58:52 +03:00
if ( cache - > num_shares = = 0 ) {
2008-04-15 16:37:15 +04:00
/*
* not in any share yet ,
* initialize the " empty " section ( NULL ) :
* parameters without a previous [ section ] are stored here .
*/
if ( ! smbconf_txt_do_section ( NULL , private_data ) ) {
return false ;
}
2008-03-26 16:30:36 +03:00
}
2008-03-27 01:58:52 +03:00
param_names = cache - > param_names [ cache - > current_share ] ;
param_values = cache - > param_values [ cache - > current_share ] ;
num_params = cache - > num_params [ cache - > current_share ] ;
2008-03-26 16:30:36 +03:00
2008-04-08 00:49:11 +04:00
if ( ! ( tpd - > verbatim ) & &
smbconf_find_in_array ( param_name , param_names , num_params , & idx ) )
2008-03-26 16:30:36 +03:00
{
2009-01-21 19:14:56 +03:00
talloc_free ( param_values [ idx ] ) ;
2008-03-27 01:58:52 +03:00
param_values [ idx ] = talloc_strdup ( cache , param_value ) ;
2008-03-26 16:30:36 +03:00
if ( param_values [ idx ] = = NULL ) {
return false ;
}
return true ;
}
2011-04-08 16:19:15 +04:00
err = smbconf_add_string_to_array ( cache ,
2008-03-27 01:58:52 +03:00
& ( cache - > param_names [ cache - > current_share ] ) ,
num_params , param_name ) ;
2011-04-08 16:19:15 +04:00
if ( ! SBC_ERROR_IS_OK ( err ) ) {
2008-03-26 16:30:36 +03:00
return false ;
}
2011-04-08 16:19:15 +04:00
err = smbconf_add_string_to_array ( cache ,
2008-03-27 01:58:52 +03:00
& ( cache - > param_values [ cache - > current_share ] ) ,
num_params , param_value ) ;
cache - > num_params [ cache - > current_share ] + + ;
2011-04-08 16:19:15 +04:00
return SBC_ERROR_IS_OK ( err ) ;
2008-03-26 16:30:36 +03:00
}
2008-03-27 01:11:04 +03:00
static void smbconf_txt_flush_cache ( struct smbconf_ctx * ctx )
{
2009-01-21 19:14:56 +03:00
talloc_free ( pd ( ctx ) - > cache ) ;
pd ( ctx ) - > cache = NULL ;
2008-03-27 01:58:01 +03:00
}
2011-04-07 19:19:03 +04:00
static sbcErr smbconf_txt_init_cache ( struct smbconf_ctx * ctx )
2008-03-27 01:58:01 +03:00
{
if ( pd ( ctx ) - > cache ! = NULL ) {
smbconf_txt_flush_cache ( ctx ) ;
}
2009-01-21 20:50:16 +03:00
pd ( ctx ) - > cache = talloc_zero ( pd ( ctx ) , struct txt_cache ) ;
2008-03-27 01:58:01 +03:00
if ( pd ( ctx ) - > cache = = NULL ) {
2011-04-07 19:19:03 +04:00
return SBC_ERR_NOMEM ;
2008-03-27 01:58:01 +03:00
}
2011-04-07 19:19:03 +04:00
return SBC_ERR_OK ;
2008-03-27 01:11:04 +03:00
}
2011-04-07 19:19:03 +04:00
static sbcErr smbconf_txt_load_file ( struct smbconf_ctx * ctx )
2008-03-26 16:30:36 +03:00
{
2011-04-07 19:19:03 +04:00
sbcErr err ;
2008-04-09 17:16:45 +04:00
uint64_t new_csn ;
2023-01-26 20:39:10 +03:00
int rc ;
struct timespec mt = { 0 } ;
2008-03-26 16:30:36 +03:00
2008-10-17 14:48:19 +04:00
if ( ! file_exist ( ctx - > path ) ) {
2011-04-07 19:19:03 +04:00
return SBC_ERR_BADFILE ;
2008-04-09 17:16:45 +04:00
}
2023-01-26 20:39:10 +03:00
rc = file_modtime ( ctx - > path , & mt ) ;
if ( rc ! = 0 ) {
/*
* Not worth mapping errno returned
* in rc to SBC_ERR_XXX . Just assume
* access denied .
*/
return SBC_ERR_ACCESS_DENIED ;
}
new_csn = ( uint64_t ) mt . tv_sec ;
2008-03-26 16:30:36 +03:00
if ( new_csn = = pd ( ctx ) - > csn ) {
2011-04-07 19:19:03 +04:00
return SBC_ERR_OK ;
2008-03-26 16:30:36 +03:00
}
2011-04-07 19:19:03 +04:00
err = smbconf_txt_init_cache ( ctx ) ;
if ( ! SBC_ERROR_IS_OK ( err ) ) {
return err ;
2008-03-27 01:58:01 +03:00
}
2008-03-26 16:30:36 +03:00
if ( ! pm_process ( ctx - > path , smbconf_txt_do_section ,
2008-04-08 00:43:33 +04:00
smbconf_txt_do_parameter , pd ( ctx ) ) )
2008-03-26 16:30:36 +03:00
{
2011-04-07 19:19:03 +04:00
return SBC_ERR_CAN_NOT_COMPLETE ;
2008-03-26 16:30:36 +03:00
}
pd ( ctx ) - > csn = new_csn ;
2011-04-07 19:19:03 +04:00
return SBC_ERR_OK ;
2008-03-26 16:30:36 +03:00
}
/**********************************************************************
*
2008-04-22 17:51:36 +04:00
* smbconf operations : text backend implementations
2008-03-26 16:30:36 +03:00
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/**
* initialize the text based smbconf backend
*/
2011-04-07 19:19:03 +04:00
static sbcErr smbconf_txt_init ( struct smbconf_ctx * ctx , const char * path )
2008-03-26 16:30:36 +03:00
{
if ( path = = NULL ) {
2011-04-07 19:19:03 +04:00
return SBC_ERR_BADFILE ;
2008-03-26 16:30:36 +03:00
}
ctx - > path = talloc_strdup ( ctx , path ) ;
if ( ctx - > path = = NULL ) {
2011-04-07 19:19:03 +04:00
return SBC_ERR_NOMEM ;
2008-03-26 16:30:36 +03:00
}
2009-01-21 20:50:16 +03:00
ctx - > data = talloc_zero ( ctx , struct txt_private_data ) ;
2008-04-13 18:34:40 +04:00
if ( ctx - > data = = NULL ) {
2011-04-07 19:19:03 +04:00
return SBC_ERR_NOMEM ;
2008-04-13 18:34:40 +04:00
}
2008-03-26 16:30:36 +03:00
2008-04-13 18:36:30 +04:00
pd ( ctx ) - > verbatim = true ;
2011-04-07 19:19:03 +04:00
return SBC_ERR_OK ;
2008-03-26 16:30:36 +03:00
}
static int smbconf_txt_shutdown ( struct smbconf_ctx * ctx )
{
return ctx - > ops - > close_conf ( ctx ) ;
}
2008-10-21 01:52:02 +04:00
static bool smbconf_txt_requires_messaging ( struct smbconf_ctx * ctx )
{
return false ;
}
2008-10-23 13:16:50 +04:00
static bool smbconf_txt_is_writeable ( struct smbconf_ctx * ctx )
{
/* no write support in this backend yet... */
return false ;
}
2011-04-08 12:28:17 +04:00
static sbcErr smbconf_txt_open ( struct smbconf_ctx * ctx )
2008-03-26 16:30:36 +03:00
{
2011-04-08 12:28:17 +04:00
return smbconf_txt_load_file ( ctx ) ;
2008-03-26 16:30:36 +03:00
}
static int smbconf_txt_close ( struct smbconf_ctx * ctx )
{
2008-03-27 01:11:04 +03:00
smbconf_txt_flush_cache ( ctx ) ;
2008-03-26 16:30:36 +03:00
return 0 ;
}
/**
* Get the change sequence number of the given service / parameter .
* service and parameter strings may be NULL .
*/
static void smbconf_txt_get_csn ( struct smbconf_ctx * ctx ,
struct smbconf_csn * csn ,
const char * service , const char * param )
{
2023-01-26 20:39:10 +03:00
struct timespec mt = { 0 } ;
2008-03-26 16:30:36 +03:00
if ( csn = = NULL ) {
return ;
}
2023-01-26 20:39:10 +03:00
( void ) file_modtime ( ctx - > path , & mt ) ;
csn - > csn = ( uint64_t ) mt . tv_sec ;
2008-03-26 16:30:36 +03:00
}
/**
* Drop the whole configuration ( restarting empty )
*/
2011-04-08 12:40:02 +04:00
static sbcErr smbconf_txt_drop ( struct smbconf_ctx * ctx )
2008-03-26 16:30:36 +03:00
{
2011-04-08 12:40:02 +04:00
return SBC_ERR_NOT_SUPPORTED ;
2008-03-26 16:30:36 +03:00
}
/**
* get the list of share names defined in the configuration .
*/
2011-04-08 16:19:15 +04:00
static sbcErr smbconf_txt_get_share_names ( struct smbconf_ctx * ctx ,
2008-03-26 16:30:36 +03:00
TALLOC_CTX * mem_ctx ,
uint32_t * num_shares ,
char * * * share_names )
{
uint32_t count ;
uint32_t added_count = 0 ;
TALLOC_CTX * tmp_ctx = NULL ;
2011-04-07 19:19:03 +04:00
sbcErr err = SBC_ERR_OK ;
2008-03-26 16:30:36 +03:00
char * * tmp_share_names = NULL ;
if ( ( num_shares = = NULL ) | | ( share_names = = NULL ) ) {
2011-04-08 16:19:15 +04:00
return SBC_ERR_INVALID_PARAM ;
2008-03-26 16:30:36 +03:00
}
2011-04-07 19:19:03 +04:00
err = smbconf_txt_load_file ( ctx ) ;
if ( ! SBC_ERROR_IS_OK ( err ) ) {
2011-04-08 16:19:15 +04:00
return err ;
2008-03-26 16:30:36 +03:00
}
tmp_ctx = talloc_stackframe ( ) ;
2008-04-15 18:06:57 +04:00
/* make sure "global" is always listed first,
* possibly after NULL section */
if ( smbconf_share_exists ( ctx , NULL ) ) {
2011-04-08 16:19:15 +04:00
err = smbconf_add_string_to_array ( tmp_ctx , & tmp_share_names ,
0 , NULL ) ;
if ( ! SBC_ERROR_IS_OK ( err ) ) {
2008-04-15 18:06:57 +04:00
goto done ;
}
added_count + + ;
}
2008-03-26 16:30:36 +03:00
if ( smbconf_share_exists ( ctx , GLOBAL_NAME ) ) {
2011-04-08 16:19:15 +04:00
err = smbconf_add_string_to_array ( tmp_ctx , & tmp_share_names ,
2008-04-15 18:06:57 +04:00
added_count , GLOBAL_NAME ) ;
2011-04-08 16:19:15 +04:00
if ( ! SBC_ERROR_IS_OK ( err ) ) {
2008-03-26 16:30:36 +03:00
goto done ;
}
added_count + + ;
}
2008-03-27 01:58:01 +03:00
for ( count = 0 ; count < pd ( ctx ) - > cache - > num_shares ; count + + ) {
2008-04-15 18:06:57 +04:00
if ( strequal ( pd ( ctx ) - > cache - > share_names [ count ] , GLOBAL_NAME ) | |
( pd ( ctx ) - > cache - > share_names [ count ] = = NULL ) )
{
2008-03-26 16:30:36 +03:00
continue ;
}
2011-04-08 16:19:15 +04:00
err = smbconf_add_string_to_array ( tmp_ctx , & tmp_share_names ,
2008-03-26 16:30:36 +03:00
added_count ,
2008-03-27 01:58:01 +03:00
pd ( ctx ) - > cache - > share_names [ count ] ) ;
2011-04-08 16:19:15 +04:00
if ( ! SBC_ERROR_IS_OK ( err ) ) {
2008-03-26 16:30:36 +03:00
goto done ;
}
added_count + + ;
}
* num_shares = added_count ;
if ( added_count > 0 ) {
* share_names = talloc_move ( mem_ctx , & tmp_share_names ) ;
} else {
* share_names = NULL ;
}
done :
2009-01-21 19:14:56 +03:00
talloc_free ( tmp_ctx ) ;
2011-04-08 16:19:15 +04:00
return err ;
2008-03-26 16:30:36 +03:00
}
/**
* check if a share / service of a given name exists
*/
static bool smbconf_txt_share_exists ( struct smbconf_ctx * ctx ,
const char * servicename )
{
2011-04-07 19:19:03 +04:00
sbcErr err ;
2008-03-26 16:30:36 +03:00
2011-04-07 19:19:03 +04:00
err = smbconf_txt_load_file ( ctx ) ;
if ( ! SBC_ERROR_IS_OK ( err ) ) {
2008-03-26 16:30:36 +03:00
return false ;
}
2008-04-07 17:05:33 +04:00
return smbconf_find_in_array ( servicename ,
pd ( ctx ) - > cache - > share_names ,
pd ( ctx ) - > cache - > num_shares , NULL ) ;
2008-03-26 16:30:36 +03:00
}
/**
* Add a service if it does not already exist
*/
2011-04-08 17:48:01 +04:00
static sbcErr smbconf_txt_create_share ( struct smbconf_ctx * ctx ,
2008-03-26 16:30:36 +03:00
const char * servicename )
{
2011-04-08 17:48:01 +04:00
return SBC_ERR_NOT_SUPPORTED ;
2008-03-26 16:30:36 +03:00
}
/**
* get a definition of a share ( service ) from configuration .
*/
2011-04-08 19:20:35 +04:00
static sbcErr smbconf_txt_get_share ( struct smbconf_ctx * ctx ,
2008-03-26 16:30:36 +03:00
TALLOC_CTX * mem_ctx ,
const char * servicename ,
2008-04-22 18:31:16 +04:00
struct smbconf_service * * service )
2008-03-26 16:30:36 +03:00
{
2011-04-07 19:19:03 +04:00
sbcErr err ;
2008-03-26 16:30:36 +03:00
uint32_t sidx , count ;
bool found ;
TALLOC_CTX * tmp_ctx = NULL ;
2008-04-22 18:31:16 +04:00
struct smbconf_service * tmp_service = NULL ;
2008-03-26 16:30:36 +03:00
2011-04-07 19:19:03 +04:00
err = smbconf_txt_load_file ( ctx ) ;
if ( ! SBC_ERROR_IS_OK ( err ) ) {
2011-04-08 19:20:35 +04:00
return err ;
2008-03-26 16:30:36 +03:00
}
2008-04-07 17:05:33 +04:00
found = smbconf_find_in_array ( servicename ,
pd ( ctx ) - > cache - > share_names ,
pd ( ctx ) - > cache - > num_shares ,
& sidx ) ;
2008-03-26 16:30:36 +03:00
if ( ! found ) {
2011-04-08 19:20:35 +04:00
return SBC_ERR_NO_SUCH_SERVICE ;
2008-03-26 16:30:36 +03:00
}
tmp_ctx = talloc_stackframe ( ) ;
2009-01-21 20:50:16 +03:00
tmp_service = talloc_zero ( tmp_ctx , struct smbconf_service ) ;
2008-04-22 18:31:16 +04:00
if ( tmp_service = = NULL ) {
2011-04-08 19:20:35 +04:00
err = SBC_ERR_NOMEM ;
2008-04-22 18:31:16 +04:00
goto done ;
}
if ( servicename ! = NULL ) {
tmp_service - > name = talloc_strdup ( tmp_service , servicename ) ;
if ( tmp_service - > name = = NULL ) {
2011-04-08 19:20:35 +04:00
err = SBC_ERR_NOMEM ;
2008-04-22 18:31:16 +04:00
goto done ;
}
}
2008-03-27 01:58:01 +03:00
for ( count = 0 ; count < pd ( ctx ) - > cache - > num_params [ sidx ] ; count + + ) {
2011-04-08 16:19:15 +04:00
err = smbconf_add_string_to_array ( tmp_service ,
2008-04-22 18:31:16 +04:00
& ( tmp_service - > param_names ) ,
2008-03-26 16:30:36 +03:00
count ,
2008-03-27 01:58:01 +03:00
pd ( ctx ) - > cache - > param_names [ sidx ] [ count ] ) ;
2011-04-08 16:19:15 +04:00
if ( ! SBC_ERROR_IS_OK ( err ) ) {
2008-03-26 16:30:36 +03:00
goto done ;
}
2011-04-08 16:19:15 +04:00
err = smbconf_add_string_to_array ( tmp_service ,
2008-04-22 18:31:16 +04:00
& ( tmp_service - > param_values ) ,
2008-03-26 16:30:36 +03:00
count ,
2008-03-27 01:58:01 +03:00
pd ( ctx ) - > cache - > param_values [ sidx ] [ count ] ) ;
2011-04-08 16:19:15 +04:00
if ( ! SBC_ERROR_IS_OK ( err ) ) {
2008-03-26 16:30:36 +03:00
goto done ;
}
}
2008-04-22 18:31:16 +04:00
tmp_service - > num_params = count ;
2010-09-27 14:43:39 +04:00
* service = talloc_move ( mem_ctx , & tmp_service ) ;
2008-03-26 16:30:36 +03:00
done :
2009-01-21 19:14:56 +03:00
talloc_free ( tmp_ctx ) ;
2011-04-08 19:20:35 +04:00
return err ;
2008-03-26 16:30:36 +03:00
}
/**
* delete a service from configuration
*/
2011-04-11 13:39:03 +04:00
static sbcErr smbconf_txt_delete_share ( struct smbconf_ctx * ctx ,
2008-03-26 16:30:36 +03:00
const char * servicename )
{
2011-04-11 13:39:03 +04:00
return SBC_ERR_NOT_SUPPORTED ;
2008-03-26 16:30:36 +03:00
}
/**
* set a configuration parameter to the value provided .
*/
2011-04-11 15:23:26 +04:00
static sbcErr smbconf_txt_set_parameter ( struct smbconf_ctx * ctx ,
2008-03-26 16:30:36 +03:00
const char * service ,
const char * param ,
const char * valstr )
{
2011-04-11 15:23:26 +04:00
return SBC_ERR_NOT_SUPPORTED ;
2008-03-26 16:30:36 +03:00
}
/**
* get the value of a configuration parameter as a string
*/
2011-04-11 15:50:53 +04:00
static sbcErr smbconf_txt_get_parameter ( struct smbconf_ctx * ctx ,
2008-03-26 16:30:36 +03:00
TALLOC_CTX * mem_ctx ,
const char * service ,
const char * param ,
char * * valstr )
{
2011-04-07 19:19:03 +04:00
sbcErr err ;
2008-03-26 16:30:36 +03:00
bool found ;
uint32_t share_index , param_index ;
2011-04-07 19:19:03 +04:00
err = smbconf_txt_load_file ( ctx ) ;
if ( ! SBC_ERROR_IS_OK ( err ) ) {
2011-04-11 15:50:53 +04:00
return err ;
2008-03-26 16:30:36 +03:00
}
2008-04-07 17:05:33 +04:00
found = smbconf_find_in_array ( service ,
pd ( ctx ) - > cache - > share_names ,
pd ( ctx ) - > cache - > num_shares ,
& share_index ) ;
2008-03-26 16:30:36 +03:00
if ( ! found ) {
2011-04-11 15:50:53 +04:00
return SBC_ERR_NO_SUCH_SERVICE ;
2008-03-26 16:30:36 +03:00
}
2008-04-08 02:08:41 +04:00
found = smbconf_reverse_find_in_array ( param ,
pd ( ctx ) - > cache - > param_names [ share_index ] ,
pd ( ctx ) - > cache - > num_params [ share_index ] ,
& param_index ) ;
2008-03-26 16:30:36 +03:00
if ( ! found ) {
2011-04-11 15:50:53 +04:00
return SBC_ERR_INVALID_PARAM ;
2008-03-26 16:30:36 +03:00
}
* valstr = talloc_strdup ( mem_ctx ,
2008-03-27 01:58:01 +03:00
pd ( ctx ) - > cache - > param_values [ share_index ] [ param_index ] ) ;
2008-03-26 16:30:36 +03:00
if ( * valstr = = NULL ) {
2011-04-11 15:50:53 +04:00
return SBC_ERR_NOMEM ;
2008-03-26 16:30:36 +03:00
}
2011-04-11 15:50:53 +04:00
return SBC_ERR_OK ;
2008-03-26 16:30:36 +03:00
}
/**
* delete a parameter from configuration
*/
2011-04-11 16:20:32 +04:00
static sbcErr smbconf_txt_delete_parameter ( struct smbconf_ctx * ctx ,
2008-03-26 16:30:36 +03:00
const char * service ,
const char * param )
{
2011-04-11 16:20:32 +04:00
return SBC_ERR_NOT_SUPPORTED ;
2008-03-26 16:30:36 +03:00
}
2011-04-11 16:52:52 +04:00
static sbcErr smbconf_txt_get_includes ( struct smbconf_ctx * ctx ,
2008-04-08 12:16:03 +04:00
TALLOC_CTX * mem_ctx ,
2008-04-08 03:56:32 +04:00
const char * service ,
uint32_t * num_includes ,
char * * * includes )
{
2011-04-07 19:19:03 +04:00
sbcErr err ;
2008-04-08 14:09:24 +04:00
bool found ;
uint32_t sidx , count ;
TALLOC_CTX * tmp_ctx = NULL ;
uint32_t tmp_num_includes = 0 ;
char * * tmp_includes = NULL ;
2011-04-07 19:19:03 +04:00
err = smbconf_txt_load_file ( ctx ) ;
if ( ! SBC_ERROR_IS_OK ( err ) ) {
2011-04-11 16:52:52 +04:00
return err ;
2008-04-08 14:09:24 +04:00
}
found = smbconf_find_in_array ( service ,
pd ( ctx ) - > cache - > share_names ,
pd ( ctx ) - > cache - > num_shares ,
& sidx ) ;
if ( ! found ) {
2011-04-11 16:52:52 +04:00
return SBC_ERR_NO_SUCH_SERVICE ;
2008-04-08 14:09:24 +04:00
}
tmp_ctx = talloc_stackframe ( ) ;
for ( count = 0 ; count < pd ( ctx ) - > cache - > num_params [ sidx ] ; count + + ) {
if ( strequal ( pd ( ctx ) - > cache - > param_names [ sidx ] [ count ] ,
" include " ) )
{
2011-04-08 16:19:15 +04:00
err = smbconf_add_string_to_array ( tmp_ctx ,
2008-04-08 14:09:24 +04:00
& tmp_includes ,
tmp_num_includes ,
pd ( ctx ) - > cache - > param_values [ sidx ] [ count ] ) ;
2011-04-08 16:19:15 +04:00
if ( ! SBC_ERROR_IS_OK ( err ) ) {
2008-04-08 14:09:24 +04:00
goto done ;
}
tmp_num_includes + + ;
}
}
* num_includes = tmp_num_includes ;
if ( * num_includes > 0 ) {
* includes = talloc_move ( mem_ctx , & tmp_includes ) ;
if ( * includes = = NULL ) {
2011-04-11 16:52:52 +04:00
err = SBC_ERR_NOMEM ;
2008-04-08 14:09:24 +04:00
goto done ;
}
} else {
* includes = NULL ;
}
2011-04-11 16:52:52 +04:00
err = SBC_ERR_OK ;
2008-04-08 14:09:24 +04:00
done :
2009-01-21 19:14:56 +03:00
talloc_free ( tmp_ctx ) ;
2011-04-11 16:52:52 +04:00
return err ;
2008-04-08 03:56:32 +04:00
}
2011-04-11 17:14:52 +04:00
static sbcErr smbconf_txt_set_includes ( struct smbconf_ctx * ctx ,
2008-04-08 03:56:32 +04:00
const char * service ,
uint32_t num_includes ,
const char * * includes )
{
2011-04-11 17:14:52 +04:00
return SBC_ERR_NOT_SUPPORTED ;
2008-04-08 03:56:32 +04:00
}
2011-04-11 18:01:22 +04:00
static sbcErr smbconf_txt_delete_includes ( struct smbconf_ctx * ctx ,
2008-04-10 00:21:15 +04:00
const char * service )
{
2011-04-11 18:01:22 +04:00
return SBC_ERR_NOT_SUPPORTED ;
2008-04-10 00:21:15 +04:00
}
2011-04-11 19:24:13 +04:00
static sbcErr smbconf_txt_transaction_start ( struct smbconf_ctx * ctx )
2009-02-24 12:52:30 +03:00
{
2011-04-11 19:24:13 +04:00
return SBC_ERR_OK ;
2009-02-24 12:52:30 +03:00
}
2011-04-11 19:24:13 +04:00
static sbcErr smbconf_txt_transaction_commit ( struct smbconf_ctx * ctx )
2009-02-24 12:52:30 +03:00
{
2011-04-11 19:24:13 +04:00
return SBC_ERR_OK ;
2009-02-24 12:52:30 +03:00
}
2011-04-11 19:24:13 +04:00
static sbcErr smbconf_txt_transaction_cancel ( struct smbconf_ctx * ctx )
2009-02-24 12:52:30 +03:00
{
2011-04-11 19:24:13 +04:00
return SBC_ERR_OK ;
2009-02-24 12:52:30 +03:00
}
2008-04-10 00:21:15 +04:00
2008-03-26 16:30:36 +03:00
static struct smbconf_ops smbconf_ops_txt = {
. init = smbconf_txt_init ,
. shutdown = smbconf_txt_shutdown ,
2008-10-21 01:52:02 +04:00
. requires_messaging = smbconf_txt_requires_messaging ,
2008-10-23 13:16:50 +04:00
. is_writeable = smbconf_txt_is_writeable ,
2008-03-26 16:30:36 +03:00
. open_conf = smbconf_txt_open ,
. close_conf = smbconf_txt_close ,
. get_csn = smbconf_txt_get_csn ,
. drop = smbconf_txt_drop ,
. get_share_names = smbconf_txt_get_share_names ,
. share_exists = smbconf_txt_share_exists ,
. create_share = smbconf_txt_create_share ,
. get_share = smbconf_txt_get_share ,
. delete_share = smbconf_txt_delete_share ,
. set_parameter = smbconf_txt_set_parameter ,
. get_parameter = smbconf_txt_get_parameter ,
2008-04-08 03:56:32 +04:00
. delete_parameter = smbconf_txt_delete_parameter ,
. get_includes = smbconf_txt_get_includes ,
. set_includes = smbconf_txt_set_includes ,
2008-04-10 00:21:15 +04:00
. delete_includes = smbconf_txt_delete_includes ,
2009-02-24 12:52:30 +03:00
. transaction_start = smbconf_txt_transaction_start ,
. transaction_commit = smbconf_txt_transaction_commit ,
. transaction_cancel = smbconf_txt_transaction_cancel ,
2008-03-26 16:30:36 +03:00
} ;
/**
* initialize the smbconf text backend
* the only function that is exported from this module
*/
2011-04-07 19:19:03 +04:00
sbcErr smbconf_init_txt ( TALLOC_CTX * mem_ctx ,
2008-04-22 17:50:42 +04:00
struct smbconf_ctx * * conf_ctx ,
const char * path )
2008-03-26 16:30:36 +03:00
{
2011-04-07 19:19:03 +04:00
sbcErr err ;
2008-04-08 00:33:01 +04:00
2011-04-07 19:19:03 +04:00
err = smbconf_init_internal ( mem_ctx , conf_ctx , path , & smbconf_ops_txt ) ;
if ( ! SBC_ERROR_IS_OK ( err ) ) {
return err ;
2008-04-08 00:33:01 +04:00
}
2008-04-08 01:28:48 +04:00
return smbconf_txt_load_file ( * conf_ctx ) ;
2008-03-26 16:30:36 +03:00
}