2001-08-21 16:56:08 +04:00
/*
2007-07-09 02:51:20 +04:00
* Copyright ( C ) 2001 - 2004 Sistina Software , Inc . All rights reserved .
2007-08-21 00:55:30 +04:00
* Copyright ( C ) 2004 - 2007 Red Hat , Inc . All rights reserved .
2001-08-21 16:56:08 +04:00
*
2004-03-30 23:35:44 +04:00
* This file is part of LVM2 .
*
* This copyrighted material is made available to anyone wishing to use ,
* modify , copy , or redistribute it subject to the terms and conditions
2007-08-21 00:55:30 +04:00
* of the GNU Lesser General Public License v .2 .1 .
2004-03-30 23:35:44 +04:00
*
2007-08-21 00:55:30 +04:00
* You should have received a copy of the GNU Lesser General Public License
2004-03-30 23:35:44 +04:00
* along with this program ; if not , write to the Free Software Foundation ,
* Inc . , 59 Temple Place , Suite 330 , Boston , MA 02111 - 1307 USA
2001-08-21 16:56:08 +04:00
*/
2002-11-18 17:01:16 +03:00
# include "lib.h"
# include "config.h"
# include "crc.h"
# include "device.h"
2004-05-04 22:28:15 +04:00
# include "str_list.h"
# include "toolcontext.h"
2007-04-26 00:38:39 +04:00
# include "lvm-string.h"
2007-07-24 21:48:08 +04:00
# include "lvm-file.h"
2002-11-18 17:01:16 +03:00
2001-08-21 16:56:08 +04:00
# include <sys/stat.h>
# include <sys/mman.h>
# include <unistd.h>
# include <fcntl.h>
# include <ctype.h>
2001-09-13 16:38:31 +04:00
2007-04-26 00:38:39 +04:00
# define SECTION_B_CHAR '{'
# define SECTION_E_CHAR '}'
2001-08-21 16:56:08 +04:00
enum {
2002-04-24 22:20:51 +04:00
TOK_INT ,
TOK_FLOAT ,
2008-03-12 19:03:22 +03:00
TOK_STRING , /* Single quotes */
TOK_STRING_ESCAPED , /* Double quotes */
2002-04-24 22:20:51 +04:00
TOK_EQ ,
TOK_SECTION_B ,
TOK_SECTION_E ,
TOK_ARRAY_B ,
TOK_ARRAY_E ,
TOK_IDENTIFIER ,
2001-08-21 16:56:08 +04:00
TOK_COMMA ,
TOK_EOF
} ;
struct parser {
2006-05-16 20:48:31 +04:00
const char * fb , * fe ; /* file limits */
2001-08-21 16:56:08 +04:00
2002-04-24 22:20:51 +04:00
int t ; /* token limits and type */
2006-05-16 20:48:31 +04:00
const char * tb , * te ;
2001-08-21 16:56:08 +04:00
2002-04-24 22:20:51 +04:00
int fd ; /* descriptor for file being parsed */
2001-08-21 16:56:08 +04:00
int line ; /* line number we are on */
2005-10-17 03:03:59 +04:00
struct dm_pool * mem ;
2001-08-21 16:56:08 +04:00
} ;
struct cs {
2004-03-08 21:28:45 +03:00
struct config_tree cft ;
2005-10-17 03:03:59 +04:00
struct dm_pool * mem ;
2002-11-18 17:01:16 +03:00
time_t timestamp ;
char * filename ;
2004-05-04 22:28:15 +04:00
int exists ;
2006-11-04 06:34:10 +03:00
int keep_open ;
struct device * dev ;
2001-08-21 16:56:08 +04:00
} ;
2007-07-09 02:51:20 +04:00
struct output_line {
FILE * fp ;
struct dm_pool * mem ;
2009-10-16 21:41:49 +04:00
putline_fn putline ;
void * putline_baton ;
2007-07-09 02:51:20 +04:00
} ;
2003-02-03 23:08:45 +03:00
static void _get_token ( struct parser * p , int tok_prev ) ;
2001-08-21 16:56:08 +04:00
static void _eat_space ( struct parser * p ) ;
static struct config_node * _file ( struct parser * p ) ;
static struct config_node * _section ( struct parser * p ) ;
static struct config_value * _value ( struct parser * p ) ;
static struct config_value * _type ( struct parser * p ) ;
static int _match_aux ( struct parser * p , int t ) ;
2009-10-16 21:41:49 +04:00
static struct config_value * _create_value ( struct dm_pool * mem ) ;
static struct config_node * _create_node ( struct dm_pool * mem ) ;
2001-08-21 16:56:08 +04:00
static char * _dup_tok ( struct parser * p ) ;
2004-03-08 21:28:45 +03:00
static const int sep = ' / ' ;
2001-08-21 16:56:08 +04:00
# define MAX_INDENT 32
# define match(t) do {\
if ( ! _match_aux ( p , ( t ) ) ) { \
2007-04-26 20:40:46 +04:00
log_error ( " Parse error at byte % " PRIptrdiff_t " (line %d): unexpected token " , \
p - > tb - p - > fb + 1 , p - > line ) ; \
2001-08-21 16:56:08 +04:00
return 0 ; \
} \
} while ( 0 ) ;
2002-01-07 13:23:52 +03:00
static int _tok_match ( const char * str , const char * b , const char * e )
{
while ( * str & & ( b ! = e ) ) {
if ( * str + + ! = * b + + )
return 0 ;
}
return ! ( * str | | ( b ! = e ) ) ;
}
2001-08-21 16:56:08 +04:00
/*
* public interface
*/
2006-11-04 06:34:10 +03:00
struct config_tree * create_config_tree ( const char * filename , int keep_open )
2001-08-21 16:56:08 +04:00
{
2002-04-24 22:20:51 +04:00
struct cs * c ;
2005-10-17 03:03:59 +04:00
struct dm_pool * mem = dm_pool_create ( " config " , 10 * 1024 ) ;
2002-04-24 22:20:51 +04:00
if ( ! mem ) {
2006-05-16 20:48:31 +04:00
log_error ( " Failed to allocate config pool. " ) ;
2002-04-24 22:20:51 +04:00
return 0 ;
}
2005-10-17 03:03:59 +04:00
if ( ! ( c = dm_pool_zalloc ( mem , sizeof ( * c ) ) ) ) {
2006-05-16 20:48:31 +04:00
log_error ( " Failed to allocate config tree. " ) ;
2005-10-17 03:03:59 +04:00
dm_pool_destroy ( mem ) ;
2002-04-24 22:20:51 +04:00
return 0 ;
}
c - > mem = mem ;
2004-03-08 21:28:45 +03:00
c - > cft . root = ( struct config_node * ) NULL ;
2002-11-18 17:01:16 +03:00
c - > timestamp = 0 ;
2004-05-04 22:28:15 +04:00
c - > exists = 0 ;
2006-11-04 06:34:10 +03:00
c - > keep_open = keep_open ;
c - > dev = 0 ;
2004-05-04 22:28:15 +04:00
if ( filename )
2005-10-17 03:03:59 +04:00
c - > filename = dm_pool_strdup ( c - > mem , filename ) ;
2004-03-08 21:28:45 +03:00
return & c - > cft ;
2001-08-21 16:56:08 +04:00
}
2004-03-08 21:28:45 +03:00
void destroy_config_tree ( struct config_tree * cft )
2001-08-21 16:56:08 +04:00
{
2006-11-04 06:34:10 +03:00
struct cs * c = ( struct cs * ) cft ;
if ( c - > dev )
dev_close ( c - > dev ) ;
dm_pool_destroy ( c - > mem ) ;
2001-08-21 16:56:08 +04:00
}
2006-05-16 20:48:31 +04:00
static int _parse_config_file ( struct parser * p , struct config_tree * cft )
{
p - > tb = p - > te = p - > fb ;
p - > line = 1 ;
_get_token ( p , TOK_SECTION_E ) ;
if ( ! ( cft - > root = _file ( p ) ) )
return_0 ;
return 1 ;
}
2007-08-22 18:38:18 +04:00
struct config_tree * create_config_tree_from_string ( struct cmd_context * cmd __attribute ( ( unused ) ) ,
2006-05-16 20:48:31 +04:00
const char * config_settings )
{
struct cs * c ;
struct config_tree * cft ;
struct parser * p ;
2006-11-04 06:34:10 +03:00
if ( ! ( cft = create_config_tree ( NULL , 0 ) ) )
2006-05-16 20:48:31 +04:00
return_NULL ;
c = ( struct cs * ) cft ;
if ( ! ( p = dm_pool_alloc ( c - > mem , sizeof ( * p ) ) ) ) {
log_error ( " Failed to allocate config tree parser. " ) ;
destroy_config_tree ( cft ) ;
return NULL ;
}
p - > mem = c - > mem ;
p - > fb = config_settings ;
p - > fe = config_settings + strlen ( config_settings ) ;
if ( ! _parse_config_file ( p , cft ) ) {
destroy_config_tree ( cft ) ;
return_NULL ;
}
return cft ;
}
2009-07-28 01:01:56 +04:00
int override_config_tree_from_string ( struct cmd_context * cmd ,
const char * config_settings )
{
if ( ! ( cmd - > cft_override = create_config_tree_from_string ( cmd , config_settings ) ) ) {
log_error ( " Failed to set overridden configuration entries. " ) ;
return 1 ;
}
return 0 ;
}
2004-03-08 21:28:45 +03:00
int read_config_fd ( struct config_tree * cft , struct device * dev ,
2002-12-20 02:25:55 +03:00
off_t offset , size_t size , off_t offset2 , size_t size2 ,
2002-11-18 17:01:16 +03:00
checksum_fn_t checksum_fn , uint32_t checksum )
2001-08-21 16:56:08 +04:00
{
2004-03-08 21:28:45 +03:00
struct cs * c = ( struct cs * ) cft ;
2002-04-24 22:20:51 +04:00
struct parser * p ;
2002-11-18 17:01:16 +03:00
int r = 0 ;
2003-07-05 02:34:56 +04:00
int use_mmap = 1 ;
off_t mmap_offset = 0 ;
2007-06-13 19:11:19 +04:00
char * buf = NULL ;
2002-04-24 22:20:51 +04:00
2008-01-30 16:19:47 +03:00
if ( ! ( p = dm_pool_alloc ( c - > mem , sizeof ( * p ) ) ) )
return_0 ;
2001-08-21 16:56:08 +04:00
p - > mem = c - > mem ;
2003-07-05 02:34:56 +04:00
/* Only use mmap with regular files */
if ( ! ( dev - > flags & DEV_REGULAR ) | | size2 )
use_mmap = 0 ;
if ( use_mmap ) {
2006-08-17 22:23:44 +04:00
mmap_offset = offset % lvm_getpagesize ( ) ;
2002-11-18 17:01:16 +03:00
/* memory map the file */
p - > fb = mmap ( ( caddr_t ) 0 , size + mmap_offset , PROT_READ ,
2003-07-05 02:34:56 +04:00
MAP_PRIVATE , dev_fd ( dev ) , offset - mmap_offset ) ;
2002-11-18 17:01:16 +03:00
if ( p - > fb = = ( caddr_t ) ( - 1 ) ) {
2003-07-05 02:34:56 +04:00
log_sys_error ( " mmap " , dev_name ( dev ) ) ;
2002-11-18 17:01:16 +03:00
goto out ;
}
p - > fb = p - > fb + mmap_offset ;
2003-07-05 02:34:56 +04:00
} else {
2008-01-30 16:19:47 +03:00
if ( ! ( buf = dm_malloc ( size + size2 ) ) )
return_0 ;
2007-04-19 06:10:42 +04:00
if ( ! dev_read_circular ( dev , ( uint64_t ) offset , size ,
( uint64_t ) offset2 , size2 , buf ) ) {
2003-07-05 02:34:56 +04:00
goto out ;
}
2006-05-16 20:48:31 +04:00
p - > fb = buf ;
2002-11-18 17:01:16 +03:00
}
if ( checksum_fn & & checksum ! =
( checksum_fn ( checksum_fn ( INITIAL_CRC , p - > fb , size ) ,
p - > fb + size , size2 ) ) ) {
2003-07-05 02:34:56 +04:00
log_error ( " %s: Checksum error " , dev_name ( dev ) ) ;
2002-11-18 17:01:16 +03:00
goto out ;
}
p - > fe = p - > fb + size + size2 ;
2008-01-30 16:19:47 +03:00
if ( ! _parse_config_file ( p , cft ) )
goto_out ;
2002-11-18 17:01:16 +03:00
r = 1 ;
out :
2003-07-05 02:34:56 +04:00
if ( ! use_mmap )
2006-05-16 20:48:31 +04:00
dm_free ( buf ) ;
2002-11-18 17:01:16 +03:00
else {
/* unmap the file */
2003-03-20 17:29:28 +03:00
if ( munmap ( ( char * ) ( p - > fb - mmap_offset ) , size + mmap_offset ) ) {
2003-07-05 02:34:56 +04:00
log_sys_error ( " munmap " , dev_name ( dev ) ) ;
2002-11-18 17:01:16 +03:00
r = 0 ;
}
}
return r ;
}
2004-05-04 22:28:15 +04:00
int read_config_file ( struct config_tree * cft )
2002-11-18 17:01:16 +03:00
{
2004-03-08 21:28:45 +03:00
struct cs * c = ( struct cs * ) cft ;
2002-11-18 17:01:16 +03:00
struct stat info ;
2003-07-05 02:34:56 +04:00
int r = 1 ;
2002-11-18 17:01:16 +03:00
2004-05-04 22:28:15 +04:00
if ( stat ( c - > filename , & info ) ) {
log_sys_error ( " stat " , c - > filename ) ;
c - > exists = 0 ;
2002-04-24 22:20:51 +04:00
return 0 ;
}
2002-11-18 17:01:16 +03:00
if ( ! S_ISREG ( info . st_mode ) ) {
2004-05-04 22:28:15 +04:00
log_error ( " %s is not a regular file " , c - > filename ) ;
c - > exists = 0 ;
2002-11-18 17:01:16 +03:00
return 0 ;
}
2004-05-04 22:28:15 +04:00
c - > exists = 1 ;
2002-04-24 22:20:51 +04:00
if ( info . st_size = = 0 ) {
2004-05-04 22:28:15 +04:00
log_verbose ( " %s is empty " , c - > filename ) ;
2002-04-24 22:20:51 +04:00
return 1 ;
}
2006-11-04 06:34:10 +03:00
if ( ! c - > dev ) {
if ( ! ( c - > dev = dev_create_file ( c - > filename , NULL , NULL , 1 ) ) )
return_0 ;
2003-07-05 02:34:56 +04:00
2010-04-12 15:52:53 +04:00
if ( ! dev_open_flags ( c - > dev , O_RDONLY , 0 , 0 ) ) {
c - > dev = 0 ;
2006-11-04 06:34:10 +03:00
return_0 ;
2010-04-12 15:52:53 +04:00
}
2002-04-24 22:20:51 +04:00
}
2006-11-04 06:34:10 +03:00
r = read_config_fd ( cft , c - > dev , 0 , ( size_t ) info . st_size , 0 , 0 ,
2002-11-18 17:01:16 +03:00
( checksum_fn_t ) NULL , 0 ) ;
2006-11-04 06:34:10 +03:00
if ( ! c - > keep_open ) {
dev_close ( c - > dev ) ;
c - > dev = 0 ;
}
2002-11-18 17:01:16 +03:00
2006-11-04 06:34:10 +03:00
c - > timestamp = info . st_ctime ;
2002-11-18 17:01:16 +03:00
return r ;
}
2004-03-08 21:28:45 +03:00
time_t config_file_timestamp ( struct config_tree * cft )
2003-01-07 00:09:04 +03:00
{
2004-03-08 21:28:45 +03:00
struct cs * c = ( struct cs * ) cft ;
2003-01-07 00:09:04 +03:00
return c - > timestamp ;
}
2002-11-18 17:01:16 +03:00
/*
2004-05-04 22:28:15 +04:00
* Return 1 if config files ought to be reloaded
2002-11-18 17:01:16 +03:00
*/
2004-05-04 22:28:15 +04:00
int config_file_changed ( struct config_tree * cft )
2002-11-18 17:01:16 +03:00
{
2004-05-04 22:28:15 +04:00
struct cs * c = ( struct cs * ) cft ;
2002-11-18 17:01:16 +03:00
struct stat info ;
2002-11-26 15:14:37 +03:00
if ( ! c - > filename )
return 0 ;
2002-11-18 17:01:16 +03:00
if ( stat ( c - > filename , & info ) = = - 1 ) {
2004-05-04 22:28:15 +04:00
/* Ignore a deleted config file: still use original data */
if ( errno = = ENOENT ) {
if ( ! c - > exists )
return 0 ;
log_very_verbose ( " Config file %s has disappeared! " ,
c - > filename ) ;
goto reload ;
}
2002-11-18 17:01:16 +03:00
log_sys_error ( " stat " , c - > filename ) ;
2004-05-04 22:28:15 +04:00
log_error ( " Failed to reload configuration files " ) ;
2002-04-24 22:20:51 +04:00
return 0 ;
}
2002-11-18 17:01:16 +03:00
if ( ! S_ISREG ( info . st_mode ) ) {
log_error ( " Configuration file %s is not a regular file " ,
c - > filename ) ;
2004-05-04 22:28:15 +04:00
goto reload ;
2002-04-24 22:20:51 +04:00
}
2002-11-18 17:01:16 +03:00
/* Unchanged? */
2006-11-04 06:34:10 +03:00
if ( c - > timestamp = = info . st_ctime )
2002-11-18 17:01:16 +03:00
return 0 ;
2004-05-04 22:28:15 +04:00
reload :
log_verbose ( " Detected config file change to %s " , c - > filename ) ;
return 1 ;
2001-08-21 16:56:08 +04:00
}
2007-07-09 02:51:20 +04:00
static int _line_start ( struct output_line * outline )
{
if ( ! dm_pool_begin_object ( outline - > mem , 128 ) ) {
log_error ( " dm_pool_begin_object failed for config line " ) ;
return 0 ;
}
return 1 ;
}
2007-07-20 19:38:19 +04:00
static int _line_append ( struct output_line * outline , const char * fmt , . . . )
__attribute__ ( ( format ( printf , 2 , 3 ) ) ) ;
2007-07-09 02:51:20 +04:00
static int _line_append ( struct output_line * outline , const char * fmt , . . . )
{
char buf [ 4096 ] ;
va_list ap ;
int n ;
va_start ( ap , fmt ) ;
2007-07-20 19:26:39 +04:00
n = vsnprintf ( & buf [ 0 ] , sizeof buf - 1 , fmt , ap ) ;
2007-08-22 18:38:18 +04:00
if ( n < 0 | | n > ( int ) sizeof buf - 1 ) {
2007-07-09 02:51:20 +04:00
log_error ( " vsnprintf failed for config line " ) ;
return 0 ;
}
va_end ( ap ) ;
if ( ! dm_pool_grow_object ( outline - > mem , & buf [ 0 ] , strlen ( buf ) ) ) {
2008-03-10 21:51:27 +03:00
log_error ( " dm_pool_grow_object failed for config line " ) ;
2007-07-09 02:51:20 +04:00
return 0 ;
}
return 1 ;
}
# define line_append(args...) do {if (!_line_append(outline, args)) {return_0;}} while (0)
static int _line_end ( struct output_line * outline )
{
const char * line ;
if ( ! dm_pool_grow_object ( outline - > mem , " \0 " , 1 ) ) {
log_error ( " dm_pool_grow_object failed for config line " ) ;
return 0 ;
}
line = dm_pool_end_object ( outline - > mem ) ;
2009-10-16 21:41:49 +04:00
if ( outline - > putline )
outline - > putline ( line , outline - > putline_baton ) ;
else {
if ( ! outline - > fp )
log_print ( " %s " , line ) ;
else
fprintf ( outline - > fp , " %s \n " , line ) ;
}
2007-07-09 02:51:20 +04:00
return 1 ;
}
static int _write_value ( struct output_line * outline , struct config_value * v )
2001-08-21 16:56:08 +04:00
{
2008-03-12 19:03:22 +03:00
char * buf ;
2001-08-21 16:56:08 +04:00
switch ( v - > type ) {
case CFG_STRING :
2008-03-12 19:03:22 +03:00
if ( ! ( buf = alloca ( escaped_len ( v - > v . str ) ) ) ) {
log_error ( " temporary stack allocation for a config "
" string failed " ) ;
return 0 ;
}
line_append ( " \" %s \" " , escape_double_quotes ( buf , v - > v . str ) ) ;
2001-08-21 16:56:08 +04:00
break ;
case CFG_FLOAT :
2007-07-09 02:51:20 +04:00
line_append ( " %f " , v - > v . r ) ;
2001-08-21 16:56:08 +04:00
break ;
case CFG_INT :
2007-07-09 02:51:20 +04:00
line_append ( " % " PRId64 , v - > v . i ) ;
2001-08-21 16:56:08 +04:00
break ;
2002-08-01 16:46:52 +04:00
case CFG_EMPTY_ARRAY :
2007-07-09 02:51:20 +04:00
line_append ( " [] " ) ;
2002-08-01 16:46:52 +04:00
break ;
default :
2002-11-18 17:01:16 +03:00
log_error ( " _write_value: Unknown value type: %d " , v - > type ) ;
2001-08-21 16:56:08 +04:00
}
2007-07-09 02:51:20 +04:00
return 1 ;
2001-08-21 16:56:08 +04:00
}
2009-10-22 14:38:07 +04:00
static int _write_config ( const struct config_node * n , int only_one ,
2007-07-09 02:51:20 +04:00
struct output_line * outline , int level )
2001-08-21 16:56:08 +04:00
{
2002-04-24 22:20:51 +04:00
char space [ MAX_INDENT + 1 ] ;
int l = ( level < MAX_INDENT ) ? level : MAX_INDENT ;
int i ;
2001-08-21 16:56:08 +04:00
if ( ! n )
return 1 ;
2002-04-24 22:20:51 +04:00
for ( i = 0 ; i < l ; i + + )
2002-08-01 12:22:09 +04:00
space [ i ] = ' \t ' ;
2002-04-24 22:20:51 +04:00
space [ i ] = ' \0 ' ;
2001-08-21 16:56:08 +04:00
2007-01-10 02:22:31 +03:00
do {
2007-07-09 02:51:20 +04:00
if ( ! _line_start ( outline ) )
return_0 ;
line_append ( " %s%s " , space , n - > key ) ;
2001-08-21 16:56:08 +04:00
if ( ! n - > v ) {
/* it's a sub section */
2007-07-09 02:51:20 +04:00
line_append ( " { " ) ;
if ( ! _line_end ( outline ) )
return_0 ;
2009-03-26 12:25:18 +03:00
_write_config ( n - > child , 0 , outline , level + 1 ) ;
2007-07-09 02:51:20 +04:00
if ( ! _line_start ( outline ) )
return_0 ;
line_append ( " %s} " , space ) ;
2001-08-21 16:56:08 +04:00
} else {
/* it's a value */
struct config_value * v = n - > v ;
2007-07-09 02:51:20 +04:00
line_append ( " = " ) ;
2001-08-21 16:56:08 +04:00
if ( v - > next ) {
2007-07-09 02:51:20 +04:00
line_append ( " [ " ) ;
2001-08-21 16:56:08 +04:00
while ( v ) {
2007-07-09 02:51:20 +04:00
if ( ! _write_value ( outline , v ) )
return_0 ;
2001-08-21 16:56:08 +04:00
v = v - > next ;
if ( v )
2007-07-09 02:51:20 +04:00
line_append ( " , " ) ;
2001-08-21 16:56:08 +04:00
}
2007-07-09 02:51:20 +04:00
line_append ( " ] " ) ;
2001-08-21 16:56:08 +04:00
} else
2007-07-09 02:51:20 +04:00
if ( ! _write_value ( outline , v ) )
return_0 ;
2001-08-21 16:56:08 +04:00
}
2007-07-09 02:51:20 +04:00
if ( ! _line_end ( outline ) )
return_0 ;
2002-04-24 22:20:51 +04:00
n = n - > sib ;
2007-01-10 02:22:31 +03:00
} while ( n & & ! only_one ) ;
2001-08-21 16:56:08 +04:00
/* FIXME: add error checking */
return 1 ;
}
2009-10-22 14:38:07 +04:00
int write_config_node ( const struct config_node * cn , putline_fn putline , void * baton )
2009-10-16 21:41:49 +04:00
{
struct output_line outline ;
outline . fp = NULL ;
outline . mem = dm_pool_create ( " config_line " , 1024 ) ;
outline . putline = putline ;
outline . putline_baton = baton ;
if ( ! _write_config ( cn , 0 , & outline , 0 ) ) {
dm_pool_destroy ( outline . mem ) ;
return_0 ;
}
dm_pool_destroy ( outline . mem ) ;
return 1 ;
}
2007-01-10 02:22:31 +03:00
int write_config_file ( struct config_tree * cft , const char * file ,
int argc , char * * argv )
2001-08-21 16:56:08 +04:00
{
2007-01-10 02:22:31 +03:00
struct config_node * cn ;
2001-08-21 16:56:08 +04:00
int r = 1 ;
2007-07-09 02:51:20 +04:00
struct output_line outline ;
outline . fp = NULL ;
2009-10-16 21:41:49 +04:00
outline . putline = NULL ;
2003-10-16 00:17:19 +04:00
2007-07-09 02:51:20 +04:00
if ( ! file )
2003-10-16 00:17:19 +04:00
file = " stdout " ;
2007-07-09 02:51:20 +04:00
else if ( ! ( outline . fp = fopen ( file , " w " ) ) ) {
2002-04-24 22:20:51 +04:00
log_sys_error ( " open " , file ) ;
return 0 ;
}
2001-08-21 16:56:08 +04:00
2007-07-09 02:51:20 +04:00
outline . mem = dm_pool_create ( " config_line " , 1024 ) ;
2003-10-16 00:17:19 +04:00
log_verbose ( " Dumping configuration to %s " , file ) ;
2007-01-10 02:22:31 +03:00
if ( ! argc ) {
2007-07-09 02:51:20 +04:00
if ( ! _write_config ( cft - > root , 0 , & outline , 0 ) ) {
2007-01-25 17:37:48 +03:00
log_error ( " Failure while writing to %s " , file ) ;
2007-01-10 02:22:31 +03:00
r = 0 ;
}
} else while ( argc - - ) {
if ( ( cn = find_config_node ( cft - > root , * argv ) ) ) {
2007-07-09 02:51:20 +04:00
if ( ! _write_config ( cn , 1 , & outline , 0 ) ) {
2007-01-25 17:37:48 +03:00
log_error ( " Failure while writing to %s " , file ) ;
2007-01-10 02:22:31 +03:00
r = 0 ;
}
} else {
log_error ( " Configuration node %s not found " , * argv ) ;
r = 0 ;
}
argv + + ;
2001-08-21 16:56:08 +04:00
}
2003-10-16 00:17:19 +04:00
2007-07-24 21:48:08 +04:00
if ( outline . fp & & lvm_fclose ( outline . fp , file ) ) {
stack ;
2007-01-25 17:37:48 +03:00
r = 0 ;
}
2003-10-16 00:17:19 +04:00
2007-07-09 02:51:20 +04:00
dm_pool_destroy ( outline . mem ) ;
2001-08-21 16:56:08 +04:00
return r ;
}
/*
* parser
*/
static struct config_node * _file ( struct parser * p )
{
2001-10-25 17:08:29 +04:00
struct config_node * root = NULL , * n , * l = NULL ;
2001-08-21 16:56:08 +04:00
while ( p - > t ! = TOK_EOF ) {
2008-01-30 16:19:47 +03:00
if ( ! ( n = _section ( p ) ) )
return_0 ;
2001-08-21 16:56:08 +04:00
if ( ! root )
root = n ;
else
l - > sib = n ;
2009-07-09 15:29:00 +04:00
n - > parent = root ;
2001-08-21 16:56:08 +04:00
l = n ;
}
return root ;
}
static struct config_node * _section ( struct parser * p )
{
2007-04-26 00:38:39 +04:00
/* IDENTIFIER SECTION_B_CHAR VALUE* SECTION_E_CHAR */
2001-10-25 17:08:29 +04:00
struct config_node * root , * n , * l = NULL ;
2009-10-16 21:41:49 +04:00
if ( ! ( root = _create_node ( p - > mem ) ) )
2008-01-30 16:19:47 +03:00
return_0 ;
2001-08-21 16:56:08 +04:00
2008-01-30 16:19:47 +03:00
if ( ! ( root - > key = _dup_tok ( p ) ) )
return_0 ;
2001-08-21 16:56:08 +04:00
2002-04-24 22:20:51 +04:00
match ( TOK_IDENTIFIER ) ;
2001-08-21 16:56:08 +04:00
if ( p - > t = = TOK_SECTION_B ) {
match ( TOK_SECTION_B ) ;
while ( p - > t ! = TOK_SECTION_E ) {
2008-01-30 16:19:47 +03:00
if ( ! ( n = _section ( p ) ) )
return_0 ;
2001-08-21 16:56:08 +04:00
if ( ! root - > child )
root - > child = n ;
else
l - > sib = n ;
2009-07-09 15:29:00 +04:00
n - > parent = root ;
2001-08-21 16:56:08 +04:00
l = n ;
}
match ( TOK_SECTION_E ) ;
} else {
match ( TOK_EQ ) ;
2008-01-30 16:19:47 +03:00
if ( ! ( root - > v = _value ( p ) ) )
return_0 ;
2001-08-21 16:56:08 +04:00
}
2002-04-24 22:20:51 +04:00
return root ;
2001-08-21 16:56:08 +04:00
}
static struct config_value * _value ( struct parser * p )
{
2002-04-24 22:20:51 +04:00
/* '[' TYPE* ']' | TYPE */
2002-08-01 12:22:09 +04:00
struct config_value * h = NULL , * l , * ll = NULL ;
2002-04-24 22:20:51 +04:00
if ( p - > t = = TOK_ARRAY_B ) {
match ( TOK_ARRAY_B ) ;
while ( p - > t ! = TOK_ARRAY_E ) {
2008-01-30 16:19:47 +03:00
if ( ! ( l = _type ( p ) ) )
return_0 ;
2001-08-21 16:56:08 +04:00
if ( ! h )
h = l ;
else
ll - > next = l ;
ll = l ;
if ( p - > t = = TOK_COMMA )
match ( TOK_COMMA ) ;
}
2002-04-24 22:20:51 +04:00
match ( TOK_ARRAY_E ) ;
2002-08-01 16:46:52 +04:00
/*
2002-11-18 17:01:16 +03:00
* Special case for an empty array .
2002-08-01 16:46:52 +04:00
*/
if ( ! h ) {
2009-10-16 21:41:49 +04:00
if ( ! ( h = _create_value ( p - > mem ) ) )
2002-08-01 16:46:52 +04:00
return NULL ;
h - > type = CFG_EMPTY_ARRAY ;
}
2002-11-18 17:01:16 +03:00
2002-04-24 22:20:51 +04:00
} else
2001-08-21 16:56:08 +04:00
h = _type ( p ) ;
2002-04-24 22:20:51 +04:00
return h ;
2001-08-21 16:56:08 +04:00
}
2001-10-25 15:34:55 +04:00
static struct config_value * _type ( struct parser * p )
{
2003-07-15 20:32:20 +04:00
/* [+-]{0,1}[0-9]+ | [0-9]*\.[0-9]* | ".*" */
2009-10-16 21:41:49 +04:00
struct config_value * v = _create_value ( p - > mem ) ;
2002-11-18 17:01:16 +03:00
2002-08-01 16:46:52 +04:00
if ( ! v )
return NULL ;
2001-08-21 16:56:08 +04:00
2002-04-24 22:20:51 +04:00
switch ( p - > t ) {
case TOK_INT :
2001-08-21 16:56:08 +04:00
v - > type = CFG_INT ;
2007-04-28 00:41:50 +04:00
v - > v . i = strtoll ( p - > tb , NULL , 0 ) ; /* FIXME: check error */
2002-04-24 22:20:51 +04:00
match ( TOK_INT ) ;
break ;
2001-08-21 16:56:08 +04:00
2002-04-24 22:20:51 +04:00
case TOK_FLOAT :
2001-08-21 16:56:08 +04:00
v - > type = CFG_FLOAT ;
2002-08-01 12:22:09 +04:00
v - > v . r = strtod ( p - > tb , NULL ) ; /* FIXME: check error */
2002-04-24 22:20:51 +04:00
match ( TOK_FLOAT ) ;
break ;
2001-08-21 16:56:08 +04:00
2002-04-24 22:20:51 +04:00
case TOK_STRING :
2001-08-21 16:56:08 +04:00
v - > type = CFG_STRING ;
2002-04-24 22:20:51 +04:00
p - > tb + + , p - > te - - ; /* strip "'s */
2008-01-30 16:19:47 +03:00
if ( ! ( v - > v . str = _dup_tok ( p ) ) )
return_0 ;
2001-08-21 16:56:08 +04:00
p - > te + + ;
2002-04-24 22:20:51 +04:00
match ( TOK_STRING ) ;
break ;
2001-08-21 16:56:08 +04:00
2008-03-12 19:03:22 +03:00
case TOK_STRING_ESCAPED :
v - > type = CFG_STRING ;
p - > tb + + , p - > te - - ; /* strip "'s */
if ( ! ( v - > v . str = _dup_tok ( p ) ) )
return_0 ;
unescape_double_quotes ( v - > v . str ) ;
p - > te + + ;
match ( TOK_STRING_ESCAPED ) ;
break ;
2002-04-24 22:20:51 +04:00
default :
2007-04-26 20:40:46 +04:00
log_error ( " Parse error at byte % " PRIptrdiff_t " (line %d): expected a value " ,
p - > tb - p - > fb + 1 , p - > line ) ;
2002-04-24 22:20:51 +04:00
return 0 ;
}
return v ;
2001-08-21 16:56:08 +04:00
}
static int _match_aux ( struct parser * p , int t )
{
if ( p - > t ! = t )
return 0 ;
2003-02-03 23:08:45 +03:00
_get_token ( p , t ) ;
2001-08-21 16:56:08 +04:00
return 1 ;
}
/*
* tokeniser
*/
2003-02-03 23:08:45 +03:00
static void _get_token ( struct parser * p , int tok_prev )
2001-08-21 16:56:08 +04:00
{
2003-02-03 23:08:45 +03:00
int values_allowed = 0 ;
2002-04-24 22:20:51 +04:00
p - > tb = p - > te ;
_eat_space ( p ) ;
2002-11-18 17:01:16 +03:00
if ( p - > tb = = p - > fe | | ! * p - > tb ) {
2001-08-21 16:56:08 +04:00
p - > t = TOK_EOF ;
return ;
}
2003-02-03 23:08:45 +03:00
/* Should next token be interpreted as value instead of identifier? */
if ( tok_prev = = TOK_EQ | | tok_prev = = TOK_ARRAY_B | |
tok_prev = = TOK_COMMA )
values_allowed = 1 ;
2002-04-24 22:20:51 +04:00
p - > t = TOK_INT ; /* fudge so the fall through for
floats works */
switch ( * p - > te ) {
2007-04-26 00:38:39 +04:00
case SECTION_B_CHAR :
2002-04-24 22:20:51 +04:00
p - > t = TOK_SECTION_B ;
p - > te + + ;
break ;
2007-04-26 00:38:39 +04:00
case SECTION_E_CHAR :
2002-04-24 22:20:51 +04:00
p - > t = TOK_SECTION_E ;
p - > te + + ;
break ;
case ' [ ' :
p - > t = TOK_ARRAY_B ;
p - > te + + ;
break ;
case ' ] ' :
p - > t = TOK_ARRAY_E ;
p - > te + + ;
break ;
case ' , ' :
p - > t = TOK_COMMA ;
p - > te + + ;
break ;
case ' = ' :
p - > t = TOK_EQ ;
p - > te + + ;
break ;
case ' " ' :
2008-03-12 19:03:22 +03:00
p - > t = TOK_STRING_ESCAPED ;
2002-04-24 22:20:51 +04:00
p - > te + + ;
2002-11-18 17:01:16 +03:00
while ( ( p - > te ! = p - > fe ) & & ( * p - > te ) & & ( * p - > te ! = ' " ' ) ) {
if ( ( * p - > te = = ' \\ ' ) & & ( p - > te + 1 ! = p - > fe ) & &
* ( p - > te + 1 ) )
2002-04-24 22:20:51 +04:00
p - > te + + ;
p - > te + + ;
}
2002-11-18 17:01:16 +03:00
if ( ( p - > te ! = p - > fe ) & & ( * p - > te ) )
2002-04-24 22:20:51 +04:00
p - > te + + ;
break ;
2003-01-28 20:20:11 +03:00
case ' \' ' :
p - > t = TOK_STRING ;
p - > te + + ;
while ( ( p - > te ! = p - > fe ) & & ( * p - > te ) & & ( * p - > te ! = ' \' ' ) )
p - > te + + ;
if ( ( p - > te ! = p - > fe ) & & ( * p - > te ) )
p - > te + + ;
break ;
2002-04-24 22:20:51 +04:00
case ' . ' :
p - > t = TOK_FLOAT ;
case ' 0 ' :
case ' 1 ' :
case ' 2 ' :
case ' 3 ' :
case ' 4 ' :
case ' 5 ' :
case ' 6 ' :
case ' 7 ' :
case ' 8 ' :
case ' 9 ' :
2003-07-15 20:32:20 +04:00
case ' + ' :
case ' - ' :
2003-02-03 23:08:45 +03:00
if ( values_allowed ) {
2002-04-24 22:20:51 +04:00
p - > te + + ;
2003-02-03 23:08:45 +03:00
while ( ( p - > te ! = p - > fe ) & & ( * p - > te ) ) {
if ( * p - > te = = ' . ' ) {
if ( p - > t = = TOK_FLOAT )
break ;
p - > t = TOK_FLOAT ;
} else if ( ! isdigit ( ( int ) * p - > te ) )
break ;
p - > te + + ;
}
break ;
2002-04-24 22:20:51 +04:00
}
default :
p - > t = TOK_IDENTIFIER ;
2002-11-18 17:01:16 +03:00
while ( ( p - > te ! = p - > fe ) & & ( * p - > te ) & & ! isspace ( * p - > te ) & &
2007-04-26 00:38:39 +04:00
( * p - > te ! = ' # ' ) & & ( * p - > te ! = ' = ' ) & &
( * p - > te ! = SECTION_B_CHAR ) & &
( * p - > te ! = SECTION_E_CHAR ) )
2002-04-24 22:20:51 +04:00
p - > te + + ;
break ;
}
2001-08-21 16:56:08 +04:00
}
static void _eat_space ( struct parser * p )
{
2002-11-18 17:01:16 +03:00
while ( ( p - > tb ! = p - > fe ) & & ( * p - > tb ) ) {
2008-06-03 21:51:04 +04:00
if ( * p - > te = = ' # ' )
2002-11-18 17:01:16 +03:00
while ( ( p - > te ! = p - > fe ) & & ( * p - > te ) & & ( * p - > te ! = ' \n ' ) )
2002-04-24 22:20:51 +04:00
p - > te + + ;
2001-08-21 16:56:08 +04:00
else if ( isspace ( * p - > te ) ) {
2002-11-18 17:01:16 +03:00
while ( ( p - > te ! = p - > fe ) & & ( * p - > te ) & & isspace ( * p - > te ) ) {
2001-08-21 16:56:08 +04:00
if ( * p - > te = = ' \n ' )
p - > line + + ;
2002-04-24 22:20:51 +04:00
p - > te + + ;
2001-08-21 16:56:08 +04:00
}
}
2002-04-24 22:20:51 +04:00
else
return ;
2001-08-21 16:56:08 +04:00
2002-04-24 22:20:51 +04:00
p - > tb = p - > te ;
}
2001-08-21 16:56:08 +04:00
}
/*
* memory management
*/
2009-10-16 21:41:49 +04:00
static struct config_value * _create_value ( struct dm_pool * mem )
2001-08-21 16:56:08 +04:00
{
2009-10-16 21:41:49 +04:00
struct config_value * v = dm_pool_alloc ( mem , sizeof ( * v ) ) ;
2006-05-10 21:49:25 +04:00
if ( v )
memset ( v , 0 , sizeof ( * v ) ) ;
2001-08-21 16:56:08 +04:00
return v ;
}
2009-10-16 21:41:49 +04:00
static struct config_node * _create_node ( struct dm_pool * mem )
2001-08-21 16:56:08 +04:00
{
2009-10-16 21:41:49 +04:00
struct config_node * n = dm_pool_alloc ( mem , sizeof ( * n ) ) ;
2006-05-10 21:49:25 +04:00
if ( n )
memset ( n , 0 , sizeof ( * n ) ) ;
2001-08-21 16:56:08 +04:00
return n ;
}
static char * _dup_tok ( struct parser * p )
{
2002-12-20 02:25:55 +03:00
size_t len = p - > te - p - > tb ;
2005-10-17 03:03:59 +04:00
char * str = dm_pool_alloc ( p - > mem , len + 1 ) ;
2008-01-30 16:19:47 +03:00
if ( ! str )
return_0 ;
2001-08-21 16:56:08 +04:00
strncpy ( str , p - > tb , len ) ;
str [ len ] = ' \0 ' ;
return str ;
}
/*
* utility functions
*/
2006-05-16 20:48:31 +04:00
static struct config_node * _find_config_node ( const struct config_node * cn ,
const char * path )
2001-08-21 16:56:08 +04:00
{
const char * e ;
2006-11-21 18:13:36 +03:00
const struct config_node * cn_found = NULL ;
2001-08-21 16:56:08 +04:00
while ( cn ) {
/* trim any leading slashes */
while ( * path & & ( * path = = sep ) )
path + + ;
/* find the end of this segment */
2002-04-24 22:20:51 +04:00
for ( e = path ; * e & & ( * e ! = sep ) ; e + + ) ;
2001-08-21 16:56:08 +04:00
/* hunt for the node */
2006-11-16 20:36:00 +03:00
cn_found = NULL ;
2001-08-21 16:56:08 +04:00
while ( cn ) {
2006-11-16 20:36:00 +03:00
if ( _tok_match ( cn - > key , path , e ) ) {
/* Inefficient */
if ( ! cn_found )
cn_found = cn ;
else
2010-04-01 14:34:09 +04:00
log_warn ( " WARNING: Ignoring duplicate "
" config node: %s ( "
" seeking %s) " , cn - > key , path ) ;
2006-11-16 20:36:00 +03:00
}
2001-08-21 16:56:08 +04:00
cn = cn - > sib ;
}
2006-11-16 20:36:00 +03:00
if ( cn_found & & * e )
cn = cn_found - > child ;
2001-08-21 16:56:08 +04:00
else
break ; /* don't move into the last node */
path = e ;
}
2006-11-16 20:36:00 +03:00
return ( struct config_node * ) cn_found ;
2001-08-21 16:56:08 +04:00
}
2006-05-16 20:48:31 +04:00
static struct config_node * _find_first_config_node ( const struct config_node * cn1 ,
const struct config_node * cn2 ,
const char * path )
{
struct config_node * cn ;
if ( cn1 & & ( cn = _find_config_node ( cn1 , path ) ) )
return cn ;
if ( cn2 & & ( cn = _find_config_node ( cn2 , path ) ) )
return cn ;
return NULL ;
}
struct config_node * find_config_node ( const struct config_node * cn ,
const char * path )
2001-08-21 16:56:08 +04:00
{
2006-05-16 20:48:31 +04:00
return _find_config_node ( cn , path ) ;
}
static const char * _find_config_str ( const struct config_node * cn1 ,
const struct config_node * cn2 ,
const char * path , const char * fail )
{
const struct config_node * n = _find_first_config_node ( cn1 , cn2 , path ) ;
2001-08-21 16:56:08 +04:00
2006-04-28 17:30:59 +04:00
/* Empty strings are ignored */
2007-01-17 19:22:59 +03:00
if ( ( n & & n - > v & & n - > v - > type = = CFG_STRING ) & & ( * n - > v - > v . str ) ) {
2006-04-28 17:30:59 +04:00
log_very_verbose ( " Setting %s to %s " , path , n - > v - > v . str ) ;
2001-08-21 16:56:08 +04:00
return n - > v - > v . str ;
2002-01-16 02:34:13 +03:00
}
2001-08-21 16:56:08 +04:00
2001-10-23 22:20:27 +04:00
if ( fail )
2002-01-28 00:30:47 +03:00
log_very_verbose ( " %s not found in config: defaulting to %s " ,
2002-04-24 22:20:51 +04:00
path , fail ) ;
2001-08-21 16:56:08 +04:00
return fail ;
}
2006-05-16 20:48:31 +04:00
const char * find_config_str ( const struct config_node * cn ,
const char * path , const char * fail )
2001-08-21 16:56:08 +04:00
{
2006-05-16 20:48:31 +04:00
return _find_config_str ( cn , NULL , path , fail ) ;
}
2007-04-28 00:41:50 +04:00
static int64_t _find_config_int64 ( const struct config_node * cn1 ,
const struct config_node * cn2 ,
const char * path , int64_t fail )
2006-05-16 20:48:31 +04:00
{
const struct config_node * n = _find_first_config_node ( cn1 , cn2 , path ) ;
2001-08-21 16:56:08 +04:00
2007-03-08 22:22:52 +03:00
if ( n & & n - > v & & n - > v - > type = = CFG_INT ) {
2007-04-28 00:41:50 +04:00
log_very_verbose ( " Setting %s to % " PRId64 , path , n - > v - > v . i ) ;
2001-08-21 16:56:08 +04:00
return n - > v - > v . i ;
2002-01-16 02:34:13 +03:00
}
2001-08-21 16:56:08 +04:00
2007-04-28 00:41:50 +04:00
log_very_verbose ( " %s not found in config: defaulting to % " PRId64 ,
2002-01-28 00:30:47 +03:00
path , fail ) ;
2001-08-21 16:56:08 +04:00
return fail ;
}
2006-05-16 20:48:31 +04:00
int find_config_int ( const struct config_node * cn , const char * path , int fail )
{
2007-04-28 00:41:50 +04:00
/* FIXME Add log_error message on overflow */
return ( int ) _find_config_int64 ( cn , NULL , path , ( int64_t ) fail ) ;
2006-05-16 20:48:31 +04:00
}
static float _find_config_float ( const struct config_node * cn1 ,
const struct config_node * cn2 ,
const char * path , float fail )
2001-08-21 16:56:08 +04:00
{
2006-05-16 20:48:31 +04:00
const struct config_node * n = _find_first_config_node ( cn1 , cn2 , path ) ;
2001-08-21 16:56:08 +04:00
2007-03-08 22:22:52 +03:00
if ( n & & n - > v & & n - > v - > type = = CFG_FLOAT ) {
2002-01-28 00:30:47 +03:00
log_very_verbose ( " Setting %s to %f " , path , n - > v - > v . r ) ;
2001-08-21 16:56:08 +04:00
return n - > v - > v . r ;
2002-01-16 02:34:13 +03:00
}
2002-01-28 00:30:47 +03:00
log_very_verbose ( " %s not found in config: defaulting to %f " ,
2002-04-24 22:20:51 +04:00
path , fail ) ;
2001-08-21 16:56:08 +04:00
return fail ;
}
2006-05-16 20:48:31 +04:00
float find_config_float ( const struct config_node * cn , const char * path ,
float fail )
{
return _find_config_float ( cn , NULL , path , fail ) ;
}
struct config_node * find_config_tree_node ( struct cmd_context * cmd ,
2007-07-09 02:51:20 +04:00
const char * path )
2006-05-16 20:48:31 +04:00
{
return _find_first_config_node ( cmd - > cft_override ? cmd - > cft_override - > root : NULL , cmd - > cft - > root , path ) ;
}
const char * find_config_tree_str ( struct cmd_context * cmd ,
2007-07-09 02:51:20 +04:00
const char * path , const char * fail )
2006-05-16 20:48:31 +04:00
{
return _find_config_str ( cmd - > cft_override ? cmd - > cft_override - > root : NULL , cmd - > cft - > root , path , fail ) ;
}
int find_config_tree_int ( struct cmd_context * cmd , const char * path ,
2007-07-09 02:51:20 +04:00
int fail )
2006-05-16 20:48:31 +04:00
{
2007-04-28 00:41:50 +04:00
/* FIXME Add log_error message on overflow */
return ( int ) _find_config_int64 ( cmd - > cft_override ? cmd - > cft_override - > root : NULL , cmd - > cft - > root , path , ( int64_t ) fail ) ;
2006-05-16 20:48:31 +04:00
}
float find_config_tree_float ( struct cmd_context * cmd , const char * path ,
2007-07-09 02:51:20 +04:00
float fail )
2006-05-16 20:48:31 +04:00
{
return _find_config_float ( cmd - > cft_override ? cmd - > cft_override - > root : NULL , cmd - > cft - > root , path , fail ) ;
}
2008-08-07 18:02:32 +04:00
static int _str_in_array ( const char * str , const char * const values [ ] )
2001-08-21 16:56:08 +04:00
{
2002-01-07 13:23:52 +03:00
int i ;
for ( i = 0 ; values [ i ] ; i + + )
if ( ! strcasecmp ( str , values [ i ] ) )
return 1 ;
return 0 ;
}
static int _str_to_bool ( const char * str , int fail )
{
2008-08-07 18:02:32 +04:00
const char * const _true_values [ ] = { " y " , " yes " , " on " , " true " , NULL } ;
const char * const _false_values [ ] = { " n " , " no " , " off " , " false " , NULL } ;
2002-01-07 13:23:52 +03:00
if ( _str_in_array ( str , _true_values ) )
return 1 ;
if ( _str_in_array ( str , _false_values ) )
return 0 ;
return fail ;
}
2006-05-16 20:48:31 +04:00
static int _find_config_bool ( const struct config_node * cn1 ,
const struct config_node * cn2 ,
const char * path , int fail )
2002-01-07 13:23:52 +03:00
{
2006-05-16 20:48:31 +04:00
const struct config_node * n = _find_first_config_node ( cn1 , cn2 , path ) ;
2002-01-07 13:23:52 +03:00
struct config_value * v ;
if ( ! n )
return fail ;
v = n - > v ;
switch ( v - > type ) {
case CFG_INT :
return v - > v . i ? 1 : 0 ;
case CFG_STRING :
return _str_to_bool ( v - > v . str , fail ) ;
2001-08-21 16:56:08 +04:00
}
2002-01-07 13:23:52 +03:00
return fail ;
2001-08-21 16:56:08 +04:00
}
2006-05-16 20:48:31 +04:00
int find_config_bool ( const struct config_node * cn , const char * path , int fail )
{
return _find_config_bool ( cn , NULL , path , fail ) ;
}
int find_config_tree_bool ( struct cmd_context * cmd , const char * path , int fail )
{
return _find_config_bool ( cmd - > cft_override ? cmd - > cft_override - > root : NULL , cmd - > cft - > root , path , fail ) ;
}
2004-05-04 22:28:15 +04:00
int get_config_uint32 ( const struct config_node * cn , const char * path ,
2004-03-08 21:28:45 +03:00
uint32_t * result )
2002-01-10 19:47:58 +03:00
{
2004-05-04 22:28:15 +04:00
const struct config_node * n ;
2002-01-10 19:47:58 +03:00
2004-03-08 21:28:45 +03:00
n = find_config_node ( cn , path ) ;
2002-01-10 19:47:58 +03:00
if ( ! n | | ! n - > v | | n - > v - > type ! = CFG_INT )
return 0 ;
* result = n - > v - > v . i ;
return 1 ;
}
2004-05-04 22:28:15 +04:00
int get_config_uint64 ( const struct config_node * cn , const char * path ,
2004-03-08 21:28:45 +03:00
uint64_t * result )
2002-01-10 19:47:58 +03:00
{
2004-05-04 22:28:15 +04:00
const struct config_node * n ;
2002-01-10 19:47:58 +03:00
2004-03-08 21:28:45 +03:00
n = find_config_node ( cn , path ) ;
2002-01-10 19:47:58 +03:00
if ( ! n | | ! n - > v | | n - > v - > type ! = CFG_INT )
return 0 ;
* result = ( uint64_t ) n - > v - > v . i ;
return 1 ;
}
2002-07-11 18:07:43 +04:00
2004-05-04 22:28:15 +04:00
int get_config_str ( const struct config_node * cn , const char * path ,
char * * result )
2002-07-11 18:07:43 +04:00
{
2004-05-04 22:28:15 +04:00
const struct config_node * n ;
2002-07-11 18:07:43 +04:00
2004-03-08 21:28:45 +03:00
n = find_config_node ( cn , path ) ;
2002-07-11 18:07:43 +04:00
if ( ! n | | ! n - > v | | n - > v - > type ! = CFG_STRING )
return 0 ;
* result = n - > v - > v . str ;
return 1 ;
}
2004-05-04 22:28:15 +04:00
/* Insert cn2 after cn1 */
static void _insert_config_node ( struct config_node * * cn1 ,
struct config_node * cn2 )
{
if ( ! * cn1 ) {
* cn1 = cn2 ;
cn2 - > sib = NULL ;
} else {
cn2 - > sib = ( * cn1 ) - > sib ;
( * cn1 ) - > sib = cn2 ;
}
}
/*
* Merge section cn2 into section cn1 ( which has the same name )
* overwriting any existing cn1 nodes with matching names .
*/
static void _merge_section ( struct config_node * cn1 , struct config_node * cn2 )
{
struct config_node * cn , * nextn , * oldn ;
struct config_value * cv ;
for ( cn = cn2 - > child ; cn ; cn = nextn ) {
nextn = cn - > sib ;
/* Skip "tags" */
if ( ! strcmp ( cn - > key , " tags " ) )
continue ;
/* Subsection? */
if ( ! cn - > v )
/* Ignore - we don't have any of these yet */
continue ;
/* Not already present? */
if ( ! ( oldn = find_config_node ( cn1 - > child , cn - > key ) ) ) {
_insert_config_node ( & cn1 - > child , cn ) ;
continue ;
}
/* Merge certain value lists */
if ( ( ! strcmp ( cn1 - > key , " activation " ) & &
! strcmp ( cn - > key , " volume_list " ) ) | |
( ! strcmp ( cn1 - > key , " devices " ) & &
( ! strcmp ( cn - > key , " filter " ) | | ! strcmp ( cn - > key , " types " ) ) ) ) {
cv = cn - > v ;
while ( cv - > next )
cv = cv - > next ;
cv - > next = oldn - > v ;
}
/* Replace values */
oldn - > v = cn - > v ;
}
}
2008-11-04 01:14:30 +03:00
static int _match_host_tags ( struct dm_list * tags , struct config_node * tn )
2004-05-04 22:28:15 +04:00
{
struct config_value * tv ;
const char * str ;
for ( tv = tn - > v ; tv ; tv = tv - > next ) {
if ( tv - > type ! = CFG_STRING )
continue ;
str = tv - > v . str ;
if ( * str = = ' @ ' )
str + + ;
if ( ! * str )
continue ;
if ( str_list_match_item ( tags , str ) )
return 1 ;
}
return 0 ;
}
/* Destructively merge a new config tree into an existing one */
int merge_config_tree ( struct cmd_context * cmd , struct config_tree * cft ,
struct config_tree * newdata )
{
struct config_node * root = cft - > root ;
struct config_node * cn , * nextn , * oldn , * tn , * cn2 ;
for ( cn = newdata - > root ; cn ; cn = nextn ) {
nextn = cn - > sib ;
/* Ignore tags section */
if ( ! strcmp ( cn - > key , " tags " ) )
continue ;
/* If there's a tags node, skip if host tags don't match */
if ( ( tn = find_config_node ( cn - > child , " tags " ) ) ) {
if ( ! _match_host_tags ( & cmd - > tags , tn ) )
continue ;
}
if ( ! ( oldn = find_config_node ( root , cn - > key ) ) ) {
_insert_config_node ( & cft - > root , cn ) ;
/* Remove any "tags" nodes */
for ( cn2 = cn - > child ; cn2 ; cn2 = cn2 - > sib ) {
if ( ! strcmp ( cn2 - > key , " tags " ) ) {
cn - > child = cn2 - > sib ;
continue ;
}
if ( cn2 - > sib & & ! strcmp ( cn2 - > sib - > key , " tags " ) ) {
cn2 - > sib = cn2 - > sib - > sib ;
continue ;
}
}
continue ;
}
_merge_section ( oldn , cn ) ;
}
return 1 ;
}
2007-04-26 00:38:39 +04:00
/*
* Convert a token type to the char it represents .
*/
static char _token_type_to_char ( int type )
{
switch ( type ) {
case TOK_SECTION_B :
return SECTION_B_CHAR ;
case TOK_SECTION_E :
return SECTION_E_CHAR ;
default :
return 0 ;
}
}
/*
* Returns :
* # of ' type ' tokens in ' str ' .
*/
2007-08-22 18:38:18 +04:00
static unsigned _count_tokens ( const char * str , unsigned len , int type )
2007-04-26 00:38:39 +04:00
{
char c ;
c = _token_type_to_char ( type ) ;
2008-03-12 19:03:22 +03:00
return count_chars ( str , len , c ) ;
2007-04-26 00:38:39 +04:00
}
2009-07-09 15:29:00 +04:00
const char * config_parent_name ( const struct config_node * n )
{
return ( n - > parent ? n - > parent - > key : " (root) " ) ;
}
2007-04-26 00:38:39 +04:00
/*
* Heuristic function to make a quick guess as to whether a text
* region probably contains a valid config " section " . ( Useful for
* scanning areas of the disk for old metadata . )
* Config sections contain various tokens , may contain other sections
* and strings , and are delimited by begin ( type ' TOK_SECTION_B ' ) and
* end ( type ' TOK_SECTION_E ' ) tokens . As a quick heuristic , we just
* count the number of begin and end tokens , and see if they are
* non - zero and the counts match .
* Full validation of the section should be done with another function
* ( for example , read_config_fd ) .
*
* Returns :
* 0 - probably is not a valid config section
* 1 - probably _is_ a valid config section
*/
unsigned maybe_config_section ( const char * str , unsigned len )
{
int begin_count ;
int end_count ;
begin_count = _count_tokens ( str , len , TOK_SECTION_B ) ;
end_count = _count_tokens ( str , len , TOK_SECTION_E ) ;
2008-07-31 17:07:01 +04:00
if ( begin_count & & end_count & & ( begin_count = = end_count ) )
2007-04-26 00:38:39 +04:00
return 1 ;
else
return 0 ;
}
2009-10-16 21:41:49 +04:00
static struct config_value * _clone_config_value ( struct dm_pool * mem , const struct config_value * v )
{
if ( ! v )
return NULL ;
struct config_value * new = _create_value ( mem ) ;
new - > type = v - > type ;
if ( v - > type = = CFG_STRING )
new - > v . str = dm_pool_strdup ( mem , v - > v . str ) ;
else
new - > v = v - > v ;
new - > next = _clone_config_value ( mem , v - > next ) ;
return new ;
}
struct config_node * clone_config_node ( struct dm_pool * mem , const struct config_node * cn ,
int siblings )
{
if ( ! cn )
return NULL ;
struct config_node * new = _create_node ( mem ) ;
new - > key = dm_pool_strdup ( mem , cn - > key ) ;
new - > child = clone_config_node ( mem , cn - > child , 1 ) ;
new - > v = _clone_config_value ( mem , cn - > v ) ;
if ( siblings )
new - > sib = clone_config_node ( mem , cn - > sib , siblings ) ;
else
new - > sib = NULL ;
return new ;
}