2007-12-11 23:21:17 +03:00
/*
* Unix SMB / CIFS implementation .
2008-04-07 17:12:44 +04:00
* libsmbconf - Samba configuration library
2008-01-03 02:44:47 +03:00
* Copyright ( C ) Michael Adam 2007 - 2008
2007-12-11 23:21:17 +03:00
* Copyright ( C ) Guenther Deschner 2007
*
* 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/>.
*/
# include "includes.h"
2008-03-19 14:37:17 +03:00
# include "smbconf_private.h"
2007-12-11 23:21:17 +03:00
2007-12-23 05:47:16 +03:00
/**********************************************************************
*
2008-03-21 18:40:20 +03:00
* internal helper functions
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2011-04-08 17:48:01 +04:00
static sbcErr smbconf_global_check ( struct smbconf_ctx * ctx )
2008-03-21 18:40:20 +03:00
{
if ( ! smbconf_share_exists ( ctx , GLOBAL_NAME ) ) {
return smbconf_create_share ( ctx , GLOBAL_NAME ) ;
}
2011-04-08 17:48:01 +04:00
return SBC_ERR_OK ;
2008-03-21 18:40:20 +03:00
}
/**********************************************************************
*
* The actual libsmbconf API functions that are exported .
*
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2011-04-07 17:27:52 +04:00
const char * sbcErrorString ( sbcErr error )
{
switch ( error ) {
case SBC_ERR_OK :
return " SBC_ERR_OK " ;
case SBC_ERR_NOT_IMPLEMENTED :
return " SBC_ERR_NOT_IMPLEMENTED " ;
case SBC_ERR_NOT_SUPPORTED :
return " SBC_ERR_NOT_SUPPORTED " ;
case SBC_ERR_UNKNOWN_FAILURE :
return " SBC_ERR_UNKNOWN_FAILURE " ;
case SBC_ERR_NOMEM :
return " SBC_ERR_NOMEM " ;
case SBC_ERR_INVALID_PARAM :
return " SBC_ERR_INVALID_PARAM " ;
case SBC_ERR_BADFILE :
return " SBC_ERR_BADFILE " ;
case SBC_ERR_NO_SUCH_SERVICE :
return " SBC_ERR_NO_SUCH_SERVICE " ;
case SBC_ERR_IO_FAILURE :
return " SBC_ERR_IO_FAILURE " ;
case SBC_ERR_CAN_NOT_COMPLETE :
return " SBC_ERR_CAN_NOT_COMPLETE " ;
case SBC_ERR_NO_MORE_ITEMS :
return " SBC_ERR_NO_MORE_ITEMS " ;
case SBC_ERR_FILE_EXISTS :
return " SBC_ERR_FILE_EXISTS " ;
case SBC_ERR_ACCESS_DENIED :
return " SBC_ERR_ACCESS_DENIED " ;
}
return " unknown sbcErr value " ;
}
2008-10-21 01:52:02 +04:00
/**
* Tell whether the backend requires messaging to be set up
* for the backend to work correctly .
*/
bool smbconf_backend_requires_messaging ( struct smbconf_ctx * ctx )
{
return ctx - > ops - > requires_messaging ( ctx ) ;
}
2008-10-23 13:16:50 +04:00
/**
* Tell whether the source is writeable .
*/
bool smbconf_is_writeable ( struct smbconf_ctx * ctx )
{
return ctx - > ops - > is_writeable ( ctx ) ;
}
2008-01-13 03:40:05 +03:00
/**
* Close the configuration .
*/
2008-03-21 03:04:57 +03:00
void smbconf_shutdown ( struct smbconf_ctx * ctx )
2008-01-13 03:40:05 +03:00
{
2009-01-21 19:10:20 +03:00
talloc_free ( ctx ) ;
2008-01-13 03:40:05 +03:00
}
2008-02-18 20:21:14 +03:00
/**
2008-03-19 01:29:11 +03:00
* Detect changes in the configuration .
* The given csn struct is filled with the current csn .
* smbconf_changed ( ) can also be used for initial retrieval
* of the csn .
2008-02-18 20:21:14 +03:00
*/
2008-03-19 01:29:11 +03:00
bool smbconf_changed ( struct smbconf_ctx * ctx , struct smbconf_csn * csn ,
const char * service , const char * param )
2008-02-18 20:21:14 +03:00
{
2008-03-19 01:29:11 +03:00
struct smbconf_csn old_csn ;
if ( csn = = NULL ) {
return false ;
}
old_csn = * csn ;
2008-03-20 14:28:41 +03:00
ctx - > ops - > get_csn ( ctx , csn , service , param ) ;
2008-03-19 01:29:11 +03:00
return ( csn - > csn ! = old_csn . csn ) ;
2008-02-18 20:21:14 +03:00
}
2007-12-25 05:08:00 +03:00
/**
* Drop the whole configuration ( restarting empty ) .
*/
2011-04-08 12:40:02 +04:00
sbcErr smbconf_drop ( struct smbconf_ctx * ctx )
2007-12-25 04:55:07 +03:00
{
2008-03-20 14:28:41 +03:00
return ctx - > ops - > drop ( ctx ) ;
2007-12-25 04:55:07 +03:00
}
2007-12-30 00:08:11 +03:00
/**
* Get the whole configuration as lists of strings with counts :
*
* num_shares : number of shares
* share_names : list of length num_shares of share names
* num_params : list of length num_shares of parameter counts for each share
* param_names : list of lists of parameter names for each share
* param_values : list of lists of parameter values for each share
*/
2011-04-11 19:43:10 +04:00
sbcErr smbconf_get_config ( struct smbconf_ctx * ctx ,
2008-03-19 12:47:23 +03:00
TALLOC_CTX * mem_ctx ,
uint32_t * num_shares ,
2008-04-22 18:31:16 +04:00
struct smbconf_service * * * services )
2007-12-30 00:08:11 +03:00
{
2011-04-08 16:19:15 +04:00
sbcErr err ;
2007-12-30 00:08:11 +03:00
TALLOC_CTX * tmp_ctx = NULL ;
uint32_t tmp_num_shares ;
char * * tmp_share_names ;
2008-04-22 18:31:16 +04:00
struct smbconf_service * * tmp_services ;
2007-12-30 00:08:11 +03:00
uint32_t count ;
2008-04-22 18:31:16 +04:00
if ( ( num_shares = = NULL ) | | ( services = = NULL ) ) {
2011-04-11 19:43:10 +04:00
err = SBC_ERR_INVALID_PARAM ;
2007-12-30 00:08:11 +03:00
goto done ;
}
2008-01-21 17:28:04 +03:00
tmp_ctx = talloc_stackframe ( ) ;
2007-12-30 00:08:11 +03:00
2011-04-08 16:19:15 +04:00
err = smbconf_get_share_names ( ctx , tmp_ctx , & tmp_num_shares ,
& tmp_share_names ) ;
if ( ! SBC_ERROR_IS_OK ( err ) ) {
2007-12-30 00:08:11 +03:00
goto done ;
}
2009-01-21 20:50:16 +03:00
tmp_services = talloc_array ( tmp_ctx , struct smbconf_service * ,
2008-04-22 18:31:16 +04:00
tmp_num_shares ) ;
if ( tmp_services = = NULL ) {
2011-04-11 19:43:10 +04:00
err = SBC_ERR_NOMEM ;
2007-12-30 00:08:11 +03:00
goto done ;
}
for ( count = 0 ; count < tmp_num_shares ; count + + ) {
2011-04-08 19:20:35 +04:00
err = smbconf_get_share ( ctx , tmp_services ,
tmp_share_names [ count ] ,
& tmp_services [ count ] ) ;
if ( ! SBC_ERROR_IS_OK ( err ) ) {
2007-12-30 00:08:11 +03:00
goto done ;
}
}
2011-04-11 19:43:10 +04:00
err = SBC_ERR_OK ;
2007-12-30 00:08:11 +03:00
* num_shares = tmp_num_shares ;
if ( tmp_num_shares > 0 ) {
2008-04-22 18:31:16 +04:00
* services = talloc_move ( mem_ctx , & tmp_services ) ;
2007-12-30 00:08:11 +03:00
} else {
2008-04-22 18:31:16 +04:00
* services = NULL ;
2007-12-30 00:08:11 +03:00
}
done :
2009-01-21 19:10:20 +03:00
talloc_free ( tmp_ctx ) ;
2011-04-11 19:43:10 +04:00
return err ;
2007-12-30 00:08:11 +03:00
}
2007-12-29 14:53:19 +03:00
/**
* get the list of share names defined in the configuration .
*/
2011-04-08 16:19:15 +04:00
sbcErr smbconf_get_share_names ( struct smbconf_ctx * ctx ,
2008-03-19 12:47:23 +03:00
TALLOC_CTX * mem_ctx ,
2008-03-17 20:01:33 +03:00
uint32_t * num_shares ,
char * * * share_names )
2007-12-29 14:52:09 +03:00
{
2008-03-20 14:28:41 +03:00
return ctx - > ops - > get_share_names ( ctx , mem_ctx , num_shares ,
share_names ) ;
2007-12-29 14:52:09 +03:00
}
2007-12-31 03:14:44 +03:00
/**
* check if a share / service of a given name exists
*/
2008-03-17 20:01:33 +03:00
bool smbconf_share_exists ( struct smbconf_ctx * ctx ,
const char * servicename )
2007-12-31 03:14:44 +03:00
{
2008-03-20 14:28:41 +03:00
return ctx - > ops - > share_exists ( ctx , servicename ) ;
2007-12-31 03:14:44 +03:00
}
2008-01-03 13:30:14 +03:00
/**
* Add a service if it does not already exist .
*/
2011-04-08 17:48:01 +04:00
sbcErr smbconf_create_share ( struct smbconf_ctx * ctx ,
2008-03-17 20:01:33 +03:00
const char * servicename )
2008-01-03 13:30:14 +03:00
{
2008-04-15 19:37:39 +04:00
if ( ( servicename ! = NULL ) & & smbconf_share_exists ( ctx , servicename ) ) {
2011-04-08 17:48:01 +04:00
return SBC_ERR_FILE_EXISTS ;
2008-01-03 13:30:14 +03:00
}
2008-03-20 14:28:41 +03:00
return ctx - > ops - > create_share ( ctx , servicename ) ;
2008-01-03 13:30:14 +03:00
}
2007-12-29 05:38:13 +03:00
/**
* get a definition of a share ( service ) from configuration .
*/
2011-04-08 19:20:35 +04:00
sbcErr smbconf_get_share ( struct smbconf_ctx * ctx ,
2008-03-19 12:47:23 +03:00
TALLOC_CTX * mem_ctx ,
2008-04-22 18:31:16 +04:00
const char * servicename ,
struct smbconf_service * * service )
2007-12-29 05:38:13 +03:00
{
2008-04-22 18:31:16 +04:00
return ctx - > ops - > get_share ( ctx , mem_ctx , servicename , service ) ;
2007-12-29 05:38:13 +03:00
}
2007-12-25 04:24:39 +03:00
/**
* delete a service from configuration
2007-12-25 04:21:30 +03:00
*/
2011-04-11 13:39:03 +04:00
sbcErr smbconf_delete_share ( struct smbconf_ctx * ctx , const char * servicename )
2007-12-25 04:21:30 +03:00
{
2008-03-20 13:54:30 +03:00
if ( ! smbconf_share_exists ( ctx , servicename ) ) {
2011-04-11 13:39:03 +04:00
return SBC_ERR_NO_SUCH_SERVICE ;
2008-03-20 13:54:30 +03:00
}
2008-03-20 14:28:41 +03:00
return ctx - > ops - > delete_share ( ctx , servicename ) ;
2007-12-25 04:21:30 +03:00
}
2007-12-29 04:26:33 +03:00
/**
* set a configuration parameter to the value provided .
*/
2011-04-11 15:23:26 +04:00
sbcErr smbconf_set_parameter ( struct smbconf_ctx * ctx ,
2008-03-17 20:01:33 +03:00
const char * service ,
const char * param ,
const char * valstr )
2007-12-23 05:41:55 +03:00
{
2008-03-20 14:28:41 +03:00
return ctx - > ops - > set_parameter ( ctx , service , param , valstr ) ;
2007-12-23 05:41:55 +03:00
}
2008-01-14 01:00:16 +03:00
/**
* Set a global parameter
* ( i . e . a parameter in the [ global ] service ) .
*
* This also creates [ global ] when it does not exist .
*/
2011-04-11 15:23:26 +04:00
sbcErr smbconf_set_global_parameter ( struct smbconf_ctx * ctx ,
2008-03-17 20:01:33 +03:00
const char * param , const char * val )
2008-01-14 01:00:16 +03:00
{
2011-04-08 17:48:01 +04:00
sbcErr err ;
2008-01-14 01:00:16 +03:00
2011-04-08 17:48:01 +04:00
err = smbconf_global_check ( ctx ) ;
if ( ! SBC_ERROR_IS_OK ( err ) ) {
2011-04-11 15:23:26 +04:00
return err ;
2008-01-14 01:00:16 +03:00
}
2011-04-11 15:23:26 +04:00
err = smbconf_set_parameter ( ctx , GLOBAL_NAME , param , val ) ;
2008-01-14 01:00:16 +03:00
2011-04-11 15:23:26 +04:00
return err ;
2008-01-14 01:00:16 +03:00
}
2007-12-29 04:26:33 +03:00
/**
* get the value of a configuration parameter as a string
*/
2011-04-11 15:50:53 +04:00
sbcErr smbconf_get_parameter ( struct smbconf_ctx * ctx ,
2008-03-19 12:47:23 +03:00
TALLOC_CTX * mem_ctx ,
2008-03-17 20:01:33 +03:00
const char * service ,
const char * param ,
char * * valstr )
2007-12-23 17:07:20 +03:00
{
2007-12-29 04:12:33 +03:00
if ( valstr = = NULL ) {
2011-04-11 15:50:53 +04:00
return SBC_ERR_INVALID_PARAM ;
2007-12-29 04:12:33 +03:00
}
2008-03-20 14:28:41 +03:00
return ctx - > ops - > get_parameter ( ctx , mem_ctx , service , param , valstr ) ;
2007-12-23 17:07:20 +03:00
}
2008-01-14 01:12:27 +03:00
/**
* Get the value of a global parameter .
*
* Create [ global ] if it does not exist .
*/
2011-04-11 15:50:53 +04:00
sbcErr smbconf_get_global_parameter ( struct smbconf_ctx * ctx ,
2008-03-19 12:47:23 +03:00
TALLOC_CTX * mem_ctx ,
2008-03-17 20:01:33 +03:00
const char * param ,
char * * valstr )
2008-01-14 01:12:27 +03:00
{
2011-04-08 17:48:01 +04:00
sbcErr err ;
2008-01-14 01:12:27 +03:00
2011-04-08 17:48:01 +04:00
err = smbconf_global_check ( ctx ) ;
if ( ! SBC_ERROR_IS_OK ( err ) ) {
2011-04-11 15:50:53 +04:00
return err ;
2008-01-14 01:12:27 +03:00
}
2011-04-11 15:50:53 +04:00
err = smbconf_get_parameter ( ctx , mem_ctx , GLOBAL_NAME , param ,
valstr ) ;
2011-04-08 17:48:01 +04:00
2011-04-11 15:50:53 +04:00
return err ;
2008-01-14 01:12:27 +03:00
}
2007-12-29 04:26:33 +03:00
/**
* delete a parameter from configuration
*/
2011-04-11 16:20:32 +04:00
sbcErr smbconf_delete_parameter ( struct smbconf_ctx * ctx ,
2008-03-17 20:01:33 +03:00
const char * service , const char * param )
2007-12-23 04:55:25 +03:00
{
2008-03-20 14:28:41 +03:00
return ctx - > ops - > delete_parameter ( ctx , service , param ) ;
2007-12-23 04:55:25 +03:00
}
2007-12-23 05:52:00 +03:00
2008-01-14 01:16:01 +03:00
/**
* Delete a global parameter .
*
* Create [ global ] if it does not exist .
*/
2011-04-11 16:20:32 +04:00
sbcErr smbconf_delete_global_parameter ( struct smbconf_ctx * ctx ,
2008-03-17 20:01:33 +03:00
const char * param )
2008-01-14 01:16:01 +03:00
{
2011-04-08 17:48:01 +04:00
sbcErr err ;
2008-01-14 01:16:01 +03:00
2011-04-08 17:48:01 +04:00
err = smbconf_global_check ( ctx ) ;
if ( ! SBC_ERROR_IS_OK ( err ) ) {
2011-04-11 16:20:32 +04:00
return err ;
2008-01-14 01:16:01 +03:00
}
2011-04-11 16:20:32 +04:00
err = smbconf_delete_parameter ( ctx , GLOBAL_NAME , param ) ;
2008-01-14 01:16:01 +03:00
2011-04-11 16:20:32 +04:00
return err ;
2008-01-14 01:16:01 +03:00
}
2008-04-08 03:56:32 +04:00
2011-04-11 16:52:52 +04:00
sbcErr smbconf_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 )
{
2008-04-08 12:16:03 +04:00
return ctx - > ops - > get_includes ( ctx , mem_ctx , service , num_includes ,
includes ) ;
2008-04-08 03:56:32 +04:00
}
2011-04-11 16:52:52 +04:00
sbcErr smbconf_get_global_includes ( struct smbconf_ctx * ctx ,
2008-04-08 16:24:42 +04:00
TALLOC_CTX * mem_ctx ,
uint32_t * num_includes , char * * * includes )
{
2011-04-08 17:48:01 +04:00
sbcErr err ;
2008-04-08 16:24:42 +04:00
2011-04-08 17:48:01 +04:00
err = smbconf_global_check ( ctx ) ;
2011-04-11 16:52:52 +04:00
if ( ! SBC_ERROR_IS_OK ( err ) ) {
return err ;
2008-04-08 16:24:42 +04:00
}
2011-04-11 16:52:52 +04:00
err = smbconf_get_includes ( ctx , mem_ctx , GLOBAL_NAME ,
2011-04-08 17:48:01 +04:00
num_includes , includes ) ;
2008-04-08 16:24:42 +04:00
2011-04-11 16:52:52 +04:00
return err ;
2008-04-08 16:24:42 +04:00
}
2011-04-11 17:14:52 +04:00
sbcErr smbconf_set_includes ( struct smbconf_ctx * ctx ,
2008-04-08 03:56:32 +04:00
const char * service ,
uint32_t num_includes , const char * * includes )
{
return ctx - > ops - > set_includes ( ctx , service , num_includes , includes ) ;
}
2008-04-08 16:24:42 +04:00
2011-04-11 17:14:52 +04:00
sbcErr smbconf_set_global_includes ( struct smbconf_ctx * ctx ,
2008-04-08 16:24:42 +04:00
uint32_t num_includes ,
const char * * includes )
{
2011-04-08 17:48:01 +04:00
sbcErr err ;
2008-04-08 16:24:42 +04:00
2011-04-08 17:48:01 +04:00
err = smbconf_global_check ( ctx ) ;
if ( ! SBC_ERROR_IS_OK ( err ) ) {
2011-04-11 17:14:52 +04:00
return err ;
2008-04-08 16:24:42 +04:00
}
2011-04-11 17:14:52 +04:00
err = smbconf_set_includes ( ctx , GLOBAL_NAME ,
num_includes , includes ) ;
2008-04-08 16:24:42 +04:00
2011-04-11 17:14:52 +04:00
return err ;
2008-04-08 16:24:42 +04:00
}
2008-04-10 00:21:15 +04:00
2011-04-11 18:01:22 +04:00
sbcErr smbconf_delete_includes ( struct smbconf_ctx * ctx , const char * service )
2008-04-10 00:21:15 +04:00
{
return ctx - > ops - > delete_includes ( ctx , service ) ;
}
2011-04-11 18:01:22 +04:00
sbcErr smbconf_delete_global_includes ( struct smbconf_ctx * ctx )
2008-04-10 00:21:15 +04:00
{
2011-04-08 17:48:01 +04:00
sbcErr err ;
2008-04-10 00:21:15 +04:00
2011-04-08 17:48:01 +04:00
err = smbconf_global_check ( ctx ) ;
if ( ! SBC_ERROR_IS_OK ( err ) ) {
2011-04-11 18:01:22 +04:00
return err ;
2008-04-10 00:21:15 +04:00
}
2011-04-11 18:01:22 +04:00
err = smbconf_delete_includes ( ctx , GLOBAL_NAME ) ;
2008-04-10 00:21:15 +04:00
2011-04-11 18:01:22 +04:00
return err ;
2008-04-10 00:21:15 +04:00
}
2009-02-24 12:52:30 +03:00
2011-04-11 19:24:13 +04:00
sbcErr smbconf_transaction_start ( struct smbconf_ctx * ctx )
2009-02-24 12:52:30 +03:00
{
return ctx - > ops - > transaction_start ( ctx ) ;
}
2011-04-11 19:24:13 +04:00
sbcErr smbconf_transaction_commit ( struct smbconf_ctx * ctx )
2009-02-24 12:52:30 +03:00
{
return ctx - > ops - > transaction_commit ( ctx ) ;
}
2011-04-11 19:24:13 +04:00
sbcErr smbconf_transaction_cancel ( struct smbconf_ctx * ctx )
2009-02-24 12:52:30 +03:00
{
return ctx - > ops - > transaction_cancel ( ctx ) ;
}