2011-08-30 18:55:15 +04:00
/*
* Copyright ( C ) 2001 - 2004 Sistina Software , Inc . All rights reserved .
* Copyright ( C ) 2004 - 2011 Red Hat , Inc . All rights reserved .
*
* 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
* of the GNU Lesser General Public License v .2 .1 .
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program ; if not , write to the Free Software Foundation ,
* Inc . , 59 Temple Place , Suite 330 , Boston , MA 02111 - 1307 USA
*/
# include "dmlib.h"
# include <sys/stat.h>
# include <sys/mman.h>
# include <unistd.h>
# include <fcntl.h>
# include <ctype.h>
# define SECTION_B_CHAR '{'
# define SECTION_E_CHAR '}'
enum {
TOK_INT ,
TOK_FLOAT ,
TOK_STRING , /* Single quotes */
TOK_STRING_ESCAPED , /* Double quotes */
TOK_EQ ,
TOK_SECTION_B ,
TOK_SECTION_E ,
TOK_ARRAY_B ,
TOK_ARRAY_E ,
TOK_IDENTIFIER ,
TOK_COMMA ,
TOK_EOF
} ;
struct parser {
const char * fb , * fe ; /* file limits */
int t ; /* token limits and type */
const char * tb , * te ;
int line ; /* line number we are on */
struct dm_pool * mem ;
} ;
config: add support for enhanced config node output
There's a possibility to interconnect the dm_config_node with an
ID, which in our case is used to reference the configuration
definition ID from config_settings.h. So simply interconnecting
struct dm_config_node with struct cfg_def_item.
This patch also adds support for enhanced config node output besides
existing "output line by line". This patch adds a possibility to
register a callback that gets called *before* the config node is
processed line by line (for example to include any headers on output)
and *after* the config node is processed line by line (to include any
footers on output). Also, it adds the config node reference itself
as the callback arg in addition to have a possibility to extract more
information from the config node itself if needed when processing the
output callback (e.g. the key name, the id, or whether this is a
section or a value etc...).
If the config node from lvm.conf/--config tree is recognized and valid,
it's always coupled with the config node definition ID from
config_settings.h:
struct dm_config_node {
int id;
const char *key;
struct dm_config_node *parent, *sib, *child;
struct dm_config_value *v;
}
For example if the dm_config_node *cn holds "devices/dev" configuration,
then the cn->id holds "devices_dev_CFG" ID from config_settings.h, -1 if
not found in config_settings.h and 0 if matching has not yet been done.
To support the enhanced config node output, a new structure has been
defined in libdevmapper to register it:
struct dm_config_node_out_spec {
dm_config_node_out_fn prefix_fn; /* called before processing config node lines */
dm_config_node_out_fn line_fn; /* called for each config node line */
dm_config_node_out_fn suffix_fn; /* called after processing config node lines */
};
Where dm_config_node_out_fn is:
typedef int (*dm_config_node_out_fn)(const struct dm_config_node *cn, const char *line, void *baton);
(so in comparison to existing callbacks for config node output, it has
an extra dm_config_node *cn arg in addition)
This patch also adds these functions to libdevmapper:
- dm_config_write_node_out
- dm_config_write_one_node_out
...which have exactly the same functionality as their counterparts
without the "out" suffix. The "*_out" functions adds the extra hooks
for enhanced config output (prefix_fn and suffix_fn mentioned above).
One can still use the old interface for config node output, this is
just an enhancement for those who'd like to modify the output more
extensively.
2013-03-05 21:02:13 +04:00
struct config_output {
2011-08-30 18:55:15 +04:00
struct dm_pool * mem ;
dm_putline_fn putline ;
config: add support for enhanced config node output
There's a possibility to interconnect the dm_config_node with an
ID, which in our case is used to reference the configuration
definition ID from config_settings.h. So simply interconnecting
struct dm_config_node with struct cfg_def_item.
This patch also adds support for enhanced config node output besides
existing "output line by line". This patch adds a possibility to
register a callback that gets called *before* the config node is
processed line by line (for example to include any headers on output)
and *after* the config node is processed line by line (to include any
footers on output). Also, it adds the config node reference itself
as the callback arg in addition to have a possibility to extract more
information from the config node itself if needed when processing the
output callback (e.g. the key name, the id, or whether this is a
section or a value etc...).
If the config node from lvm.conf/--config tree is recognized and valid,
it's always coupled with the config node definition ID from
config_settings.h:
struct dm_config_node {
int id;
const char *key;
struct dm_config_node *parent, *sib, *child;
struct dm_config_value *v;
}
For example if the dm_config_node *cn holds "devices/dev" configuration,
then the cn->id holds "devices_dev_CFG" ID from config_settings.h, -1 if
not found in config_settings.h and 0 if matching has not yet been done.
To support the enhanced config node output, a new structure has been
defined in libdevmapper to register it:
struct dm_config_node_out_spec {
dm_config_node_out_fn prefix_fn; /* called before processing config node lines */
dm_config_node_out_fn line_fn; /* called for each config node line */
dm_config_node_out_fn suffix_fn; /* called after processing config node lines */
};
Where dm_config_node_out_fn is:
typedef int (*dm_config_node_out_fn)(const struct dm_config_node *cn, const char *line, void *baton);
(so in comparison to existing callbacks for config node output, it has
an extra dm_config_node *cn arg in addition)
This patch also adds these functions to libdevmapper:
- dm_config_write_node_out
- dm_config_write_one_node_out
...which have exactly the same functionality as their counterparts
without the "out" suffix. The "*_out" functions adds the extra hooks
for enhanced config output (prefix_fn and suffix_fn mentioned above).
One can still use the old interface for config node output, this is
just an enhancement for those who'd like to modify the output more
extensively.
2013-03-05 21:02:13 +04:00
const struct dm_config_node_out_spec * spec ;
void * baton ;
2011-08-30 18:55:15 +04:00
} ;
static void _get_token ( struct parser * p , int tok_prev ) ;
static void _eat_space ( struct parser * p ) ;
static struct dm_config_node * _file ( struct parser * p ) ;
static struct dm_config_node * _section ( struct parser * p ) ;
static struct dm_config_value * _value ( struct parser * p ) ;
static struct dm_config_value * _type ( struct parser * p ) ;
static int _match_aux ( struct parser * p , int t ) ;
static struct dm_config_value * _create_value ( struct dm_pool * mem ) ;
static struct dm_config_node * _create_node ( struct dm_pool * mem ) ;
static char * _dup_tok ( struct parser * p ) ;
static const int sep = ' / ' ;
# define MAX_INDENT 32
# define match(t) do {\
if ( ! _match_aux ( p , ( t ) ) ) { \
log_error ( " Parse error at byte % " PRIptrdiff_t " (line %d): unexpected token " , \
p - > tb - p - > fb + 1 , p - > line ) ; \
return 0 ; \
} \
2012-08-02 13:38:19 +04:00
} while ( 0 )
2011-08-30 18:55:15 +04: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 ) ) ;
}
2012-01-19 19:16:39 +04:00
struct dm_config_tree * dm_config_create ( void )
2011-08-30 18:55:15 +04:00
{
2011-12-19 01:56:03 +04:00
struct dm_config_tree * cft ;
2011-08-30 18:55:15 +04:00
struct dm_pool * mem = dm_pool_create ( " config " , 10 * 1024 ) ;
if ( ! mem ) {
log_error ( " Failed to allocate config pool. " ) ;
return 0 ;
}
2011-12-19 01:56:03 +04:00
if ( ! ( cft = dm_pool_zalloc ( mem , sizeof ( * cft ) ) ) ) {
2011-08-30 18:55:15 +04:00
log_error ( " Failed to allocate config tree. " ) ;
dm_pool_destroy ( mem ) ;
return 0 ;
}
2011-12-19 01:56:03 +04:00
cft - > mem = mem ;
2013-04-23 13:52:17 +04:00
2011-12-19 01:56:03 +04:00
return cft ;
2011-08-30 18:55:15 +04:00
}
void dm_config_set_custom ( struct dm_config_tree * cft , void * custom )
{
2011-12-19 01:56:03 +04:00
cft - > custom = custom ;
2011-08-30 18:55:15 +04:00
}
void * dm_config_get_custom ( struct dm_config_tree * cft )
{
2011-12-19 01:56:03 +04:00
return cft - > custom ;
2011-08-30 18:55:15 +04:00
}
void dm_config_destroy ( struct dm_config_tree * cft )
{
2011-12-19 01:56:03 +04:00
dm_pool_destroy ( cft - > mem ) ;
2011-08-30 18:55:15 +04:00
}
2011-09-02 05:32:08 +04:00
/*
* If there ' s a cascaded dm_config_tree , remove and return it , otherwise
* return NULL .
*/
struct dm_config_tree * dm_config_remove_cascaded_tree ( struct dm_config_tree * cft )
{
2011-10-29 00:07:38 +04:00
struct dm_config_tree * second_cft ;
2011-09-02 05:32:08 +04:00
2011-10-29 00:07:38 +04:00
if ( ! cft )
return NULL ;
second_cft = cft - > cascade ;
2011-09-02 05:32:08 +04:00
cft - > cascade = NULL ;
return second_cft ;
}
/*
* When searching , first_cft is checked before second_cft .
*/
struct dm_config_tree * dm_config_insert_cascaded_tree ( struct dm_config_tree * first_cft , struct dm_config_tree * second_cft )
{
first_cft - > cascade = second_cft ;
return first_cft ;
}
2011-08-30 18:55:15 +04:00
int dm_config_parse ( struct dm_config_tree * cft , const char * start , const char * end )
{
/* TODO? if (start == end) return 1; */
struct parser * p ;
2011-12-19 01:56:03 +04:00
if ( ! ( p = dm_pool_alloc ( cft - > mem , sizeof ( * p ) ) ) )
2011-08-30 18:55:15 +04:00
return_0 ;
2011-12-19 01:56:03 +04:00
p - > mem = cft - > mem ;
2011-08-30 18:55:15 +04:00
p - > fb = start ;
p - > fe = end ;
p - > tb = p - > te = p - > fb ;
p - > line = 1 ;
_get_token ( p , TOK_SECTION_E ) ;
if ( ! ( cft - > root = _file ( p ) ) )
return_0 ;
return 1 ;
}
struct dm_config_tree * dm_config_from_string ( const char * config_settings )
{
struct dm_config_tree * cft ;
2011-12-19 01:56:03 +04:00
if ( ! ( cft = dm_config_create ( ) ) )
2011-08-30 18:55:15 +04:00
return_NULL ;
if ( ! dm_config_parse ( cft , config_settings , config_settings + strlen ( config_settings ) ) ) {
dm_config_destroy ( cft ) ;
return_NULL ;
}
return cft ;
}
config: add support for enhanced config node output
There's a possibility to interconnect the dm_config_node with an
ID, which in our case is used to reference the configuration
definition ID from config_settings.h. So simply interconnecting
struct dm_config_node with struct cfg_def_item.
This patch also adds support for enhanced config node output besides
existing "output line by line". This patch adds a possibility to
register a callback that gets called *before* the config node is
processed line by line (for example to include any headers on output)
and *after* the config node is processed line by line (to include any
footers on output). Also, it adds the config node reference itself
as the callback arg in addition to have a possibility to extract more
information from the config node itself if needed when processing the
output callback (e.g. the key name, the id, or whether this is a
section or a value etc...).
If the config node from lvm.conf/--config tree is recognized and valid,
it's always coupled with the config node definition ID from
config_settings.h:
struct dm_config_node {
int id;
const char *key;
struct dm_config_node *parent, *sib, *child;
struct dm_config_value *v;
}
For example if the dm_config_node *cn holds "devices/dev" configuration,
then the cn->id holds "devices_dev_CFG" ID from config_settings.h, -1 if
not found in config_settings.h and 0 if matching has not yet been done.
To support the enhanced config node output, a new structure has been
defined in libdevmapper to register it:
struct dm_config_node_out_spec {
dm_config_node_out_fn prefix_fn; /* called before processing config node lines */
dm_config_node_out_fn line_fn; /* called for each config node line */
dm_config_node_out_fn suffix_fn; /* called after processing config node lines */
};
Where dm_config_node_out_fn is:
typedef int (*dm_config_node_out_fn)(const struct dm_config_node *cn, const char *line, void *baton);
(so in comparison to existing callbacks for config node output, it has
an extra dm_config_node *cn arg in addition)
This patch also adds these functions to libdevmapper:
- dm_config_write_node_out
- dm_config_write_one_node_out
...which have exactly the same functionality as their counterparts
without the "out" suffix. The "*_out" functions adds the extra hooks
for enhanced config output (prefix_fn and suffix_fn mentioned above).
One can still use the old interface for config node output, this is
just an enhancement for those who'd like to modify the output more
extensively.
2013-03-05 21:02:13 +04:00
static int _line_start ( struct config_output * out )
2011-08-30 18:55:15 +04:00
{
config: add support for enhanced config node output
There's a possibility to interconnect the dm_config_node with an
ID, which in our case is used to reference the configuration
definition ID from config_settings.h. So simply interconnecting
struct dm_config_node with struct cfg_def_item.
This patch also adds support for enhanced config node output besides
existing "output line by line". This patch adds a possibility to
register a callback that gets called *before* the config node is
processed line by line (for example to include any headers on output)
and *after* the config node is processed line by line (to include any
footers on output). Also, it adds the config node reference itself
as the callback arg in addition to have a possibility to extract more
information from the config node itself if needed when processing the
output callback (e.g. the key name, the id, or whether this is a
section or a value etc...).
If the config node from lvm.conf/--config tree is recognized and valid,
it's always coupled with the config node definition ID from
config_settings.h:
struct dm_config_node {
int id;
const char *key;
struct dm_config_node *parent, *sib, *child;
struct dm_config_value *v;
}
For example if the dm_config_node *cn holds "devices/dev" configuration,
then the cn->id holds "devices_dev_CFG" ID from config_settings.h, -1 if
not found in config_settings.h and 0 if matching has not yet been done.
To support the enhanced config node output, a new structure has been
defined in libdevmapper to register it:
struct dm_config_node_out_spec {
dm_config_node_out_fn prefix_fn; /* called before processing config node lines */
dm_config_node_out_fn line_fn; /* called for each config node line */
dm_config_node_out_fn suffix_fn; /* called after processing config node lines */
};
Where dm_config_node_out_fn is:
typedef int (*dm_config_node_out_fn)(const struct dm_config_node *cn, const char *line, void *baton);
(so in comparison to existing callbacks for config node output, it has
an extra dm_config_node *cn arg in addition)
This patch also adds these functions to libdevmapper:
- dm_config_write_node_out
- dm_config_write_one_node_out
...which have exactly the same functionality as their counterparts
without the "out" suffix. The "*_out" functions adds the extra hooks
for enhanced config output (prefix_fn and suffix_fn mentioned above).
One can still use the old interface for config node output, this is
just an enhancement for those who'd like to modify the output more
extensively.
2013-03-05 21:02:13 +04:00
if ( ! dm_pool_begin_object ( out - > mem , 128 ) ) {
2011-08-30 18:55:15 +04:00
log_error ( " dm_pool_begin_object failed for config line " ) ;
return 0 ;
}
return 1 ;
}
2011-09-25 23:40:29 +04:00
__attribute__ ( ( format ( printf , 2 , 3 ) ) )
config: add support for enhanced config node output
There's a possibility to interconnect the dm_config_node with an
ID, which in our case is used to reference the configuration
definition ID from config_settings.h. So simply interconnecting
struct dm_config_node with struct cfg_def_item.
This patch also adds support for enhanced config node output besides
existing "output line by line". This patch adds a possibility to
register a callback that gets called *before* the config node is
processed line by line (for example to include any headers on output)
and *after* the config node is processed line by line (to include any
footers on output). Also, it adds the config node reference itself
as the callback arg in addition to have a possibility to extract more
information from the config node itself if needed when processing the
output callback (e.g. the key name, the id, or whether this is a
section or a value etc...).
If the config node from lvm.conf/--config tree is recognized and valid,
it's always coupled with the config node definition ID from
config_settings.h:
struct dm_config_node {
int id;
const char *key;
struct dm_config_node *parent, *sib, *child;
struct dm_config_value *v;
}
For example if the dm_config_node *cn holds "devices/dev" configuration,
then the cn->id holds "devices_dev_CFG" ID from config_settings.h, -1 if
not found in config_settings.h and 0 if matching has not yet been done.
To support the enhanced config node output, a new structure has been
defined in libdevmapper to register it:
struct dm_config_node_out_spec {
dm_config_node_out_fn prefix_fn; /* called before processing config node lines */
dm_config_node_out_fn line_fn; /* called for each config node line */
dm_config_node_out_fn suffix_fn; /* called after processing config node lines */
};
Where dm_config_node_out_fn is:
typedef int (*dm_config_node_out_fn)(const struct dm_config_node *cn, const char *line, void *baton);
(so in comparison to existing callbacks for config node output, it has
an extra dm_config_node *cn arg in addition)
This patch also adds these functions to libdevmapper:
- dm_config_write_node_out
- dm_config_write_one_node_out
...which have exactly the same functionality as their counterparts
without the "out" suffix. The "*_out" functions adds the extra hooks
for enhanced config output (prefix_fn and suffix_fn mentioned above).
One can still use the old interface for config node output, this is
just an enhancement for those who'd like to modify the output more
extensively.
2013-03-05 21:02:13 +04:00
static int _line_append ( struct config_output * out , const char * fmt , . . . )
2011-08-30 18:55:15 +04:00
{
char buf [ 4096 ] ;
va_list ap ;
int n ;
va_start ( ap , fmt ) ;
n = vsnprintf ( & buf [ 0 ] , sizeof buf - 1 , fmt , ap ) ;
va_end ( ap ) ;
if ( n < 0 | | n > ( int ) sizeof buf - 1 ) {
log_error ( " vsnprintf failed for config line " ) ;
return 0 ;
}
config: add support for enhanced config node output
There's a possibility to interconnect the dm_config_node with an
ID, which in our case is used to reference the configuration
definition ID from config_settings.h. So simply interconnecting
struct dm_config_node with struct cfg_def_item.
This patch also adds support for enhanced config node output besides
existing "output line by line". This patch adds a possibility to
register a callback that gets called *before* the config node is
processed line by line (for example to include any headers on output)
and *after* the config node is processed line by line (to include any
footers on output). Also, it adds the config node reference itself
as the callback arg in addition to have a possibility to extract more
information from the config node itself if needed when processing the
output callback (e.g. the key name, the id, or whether this is a
section or a value etc...).
If the config node from lvm.conf/--config tree is recognized and valid,
it's always coupled with the config node definition ID from
config_settings.h:
struct dm_config_node {
int id;
const char *key;
struct dm_config_node *parent, *sib, *child;
struct dm_config_value *v;
}
For example if the dm_config_node *cn holds "devices/dev" configuration,
then the cn->id holds "devices_dev_CFG" ID from config_settings.h, -1 if
not found in config_settings.h and 0 if matching has not yet been done.
To support the enhanced config node output, a new structure has been
defined in libdevmapper to register it:
struct dm_config_node_out_spec {
dm_config_node_out_fn prefix_fn; /* called before processing config node lines */
dm_config_node_out_fn line_fn; /* called for each config node line */
dm_config_node_out_fn suffix_fn; /* called after processing config node lines */
};
Where dm_config_node_out_fn is:
typedef int (*dm_config_node_out_fn)(const struct dm_config_node *cn, const char *line, void *baton);
(so in comparison to existing callbacks for config node output, it has
an extra dm_config_node *cn arg in addition)
This patch also adds these functions to libdevmapper:
- dm_config_write_node_out
- dm_config_write_one_node_out
...which have exactly the same functionality as their counterparts
without the "out" suffix. The "*_out" functions adds the extra hooks
for enhanced config output (prefix_fn and suffix_fn mentioned above).
One can still use the old interface for config node output, this is
just an enhancement for those who'd like to modify the output more
extensively.
2013-03-05 21:02:13 +04:00
if ( ! dm_pool_grow_object ( out - > mem , & buf [ 0 ] , strlen ( buf ) ) ) {
2011-08-30 18:55:15 +04:00
log_error ( " dm_pool_grow_object failed for config line " ) ;
return 0 ;
}
return 1 ;
}
config: add support for enhanced config node output
There's a possibility to interconnect the dm_config_node with an
ID, which in our case is used to reference the configuration
definition ID from config_settings.h. So simply interconnecting
struct dm_config_node with struct cfg_def_item.
This patch also adds support for enhanced config node output besides
existing "output line by line". This patch adds a possibility to
register a callback that gets called *before* the config node is
processed line by line (for example to include any headers on output)
and *after* the config node is processed line by line (to include any
footers on output). Also, it adds the config node reference itself
as the callback arg in addition to have a possibility to extract more
information from the config node itself if needed when processing the
output callback (e.g. the key name, the id, or whether this is a
section or a value etc...).
If the config node from lvm.conf/--config tree is recognized and valid,
it's always coupled with the config node definition ID from
config_settings.h:
struct dm_config_node {
int id;
const char *key;
struct dm_config_node *parent, *sib, *child;
struct dm_config_value *v;
}
For example if the dm_config_node *cn holds "devices/dev" configuration,
then the cn->id holds "devices_dev_CFG" ID from config_settings.h, -1 if
not found in config_settings.h and 0 if matching has not yet been done.
To support the enhanced config node output, a new structure has been
defined in libdevmapper to register it:
struct dm_config_node_out_spec {
dm_config_node_out_fn prefix_fn; /* called before processing config node lines */
dm_config_node_out_fn line_fn; /* called for each config node line */
dm_config_node_out_fn suffix_fn; /* called after processing config node lines */
};
Where dm_config_node_out_fn is:
typedef int (*dm_config_node_out_fn)(const struct dm_config_node *cn, const char *line, void *baton);
(so in comparison to existing callbacks for config node output, it has
an extra dm_config_node *cn arg in addition)
This patch also adds these functions to libdevmapper:
- dm_config_write_node_out
- dm_config_write_one_node_out
...which have exactly the same functionality as their counterparts
without the "out" suffix. The "*_out" functions adds the extra hooks
for enhanced config output (prefix_fn and suffix_fn mentioned above).
One can still use the old interface for config node output, this is
just an enhancement for those who'd like to modify the output more
extensively.
2013-03-05 21:02:13 +04:00
# define line_append(args...) do {if (!_line_append(out, args)) {return_0;}} while (0)
2011-08-30 18:55:15 +04:00
config: add support for enhanced config node output
There's a possibility to interconnect the dm_config_node with an
ID, which in our case is used to reference the configuration
definition ID from config_settings.h. So simply interconnecting
struct dm_config_node with struct cfg_def_item.
This patch also adds support for enhanced config node output besides
existing "output line by line". This patch adds a possibility to
register a callback that gets called *before* the config node is
processed line by line (for example to include any headers on output)
and *after* the config node is processed line by line (to include any
footers on output). Also, it adds the config node reference itself
as the callback arg in addition to have a possibility to extract more
information from the config node itself if needed when processing the
output callback (e.g. the key name, the id, or whether this is a
section or a value etc...).
If the config node from lvm.conf/--config tree is recognized and valid,
it's always coupled with the config node definition ID from
config_settings.h:
struct dm_config_node {
int id;
const char *key;
struct dm_config_node *parent, *sib, *child;
struct dm_config_value *v;
}
For example if the dm_config_node *cn holds "devices/dev" configuration,
then the cn->id holds "devices_dev_CFG" ID from config_settings.h, -1 if
not found in config_settings.h and 0 if matching has not yet been done.
To support the enhanced config node output, a new structure has been
defined in libdevmapper to register it:
struct dm_config_node_out_spec {
dm_config_node_out_fn prefix_fn; /* called before processing config node lines */
dm_config_node_out_fn line_fn; /* called for each config node line */
dm_config_node_out_fn suffix_fn; /* called after processing config node lines */
};
Where dm_config_node_out_fn is:
typedef int (*dm_config_node_out_fn)(const struct dm_config_node *cn, const char *line, void *baton);
(so in comparison to existing callbacks for config node output, it has
an extra dm_config_node *cn arg in addition)
This patch also adds these functions to libdevmapper:
- dm_config_write_node_out
- dm_config_write_one_node_out
...which have exactly the same functionality as their counterparts
without the "out" suffix. The "*_out" functions adds the extra hooks
for enhanced config output (prefix_fn and suffix_fn mentioned above).
One can still use the old interface for config node output, this is
just an enhancement for those who'd like to modify the output more
extensively.
2013-03-05 21:02:13 +04:00
static int _line_end ( const struct dm_config_node * cn , struct config_output * out )
2011-08-30 18:55:15 +04:00
{
const char * line ;
config: add support for enhanced config node output
There's a possibility to interconnect the dm_config_node with an
ID, which in our case is used to reference the configuration
definition ID from config_settings.h. So simply interconnecting
struct dm_config_node with struct cfg_def_item.
This patch also adds support for enhanced config node output besides
existing "output line by line". This patch adds a possibility to
register a callback that gets called *before* the config node is
processed line by line (for example to include any headers on output)
and *after* the config node is processed line by line (to include any
footers on output). Also, it adds the config node reference itself
as the callback arg in addition to have a possibility to extract more
information from the config node itself if needed when processing the
output callback (e.g. the key name, the id, or whether this is a
section or a value etc...).
If the config node from lvm.conf/--config tree is recognized and valid,
it's always coupled with the config node definition ID from
config_settings.h:
struct dm_config_node {
int id;
const char *key;
struct dm_config_node *parent, *sib, *child;
struct dm_config_value *v;
}
For example if the dm_config_node *cn holds "devices/dev" configuration,
then the cn->id holds "devices_dev_CFG" ID from config_settings.h, -1 if
not found in config_settings.h and 0 if matching has not yet been done.
To support the enhanced config node output, a new structure has been
defined in libdevmapper to register it:
struct dm_config_node_out_spec {
dm_config_node_out_fn prefix_fn; /* called before processing config node lines */
dm_config_node_out_fn line_fn; /* called for each config node line */
dm_config_node_out_fn suffix_fn; /* called after processing config node lines */
};
Where dm_config_node_out_fn is:
typedef int (*dm_config_node_out_fn)(const struct dm_config_node *cn, const char *line, void *baton);
(so in comparison to existing callbacks for config node output, it has
an extra dm_config_node *cn arg in addition)
This patch also adds these functions to libdevmapper:
- dm_config_write_node_out
- dm_config_write_one_node_out
...which have exactly the same functionality as their counterparts
without the "out" suffix. The "*_out" functions adds the extra hooks
for enhanced config output (prefix_fn and suffix_fn mentioned above).
One can still use the old interface for config node output, this is
just an enhancement for those who'd like to modify the output more
extensively.
2013-03-05 21:02:13 +04:00
if ( ! dm_pool_grow_object ( out - > mem , " \0 " , 1 ) ) {
2011-08-30 18:55:15 +04:00
log_error ( " dm_pool_grow_object failed for config line " ) ;
return 0 ;
}
config: add support for enhanced config node output
There's a possibility to interconnect the dm_config_node with an
ID, which in our case is used to reference the configuration
definition ID from config_settings.h. So simply interconnecting
struct dm_config_node with struct cfg_def_item.
This patch also adds support for enhanced config node output besides
existing "output line by line". This patch adds a possibility to
register a callback that gets called *before* the config node is
processed line by line (for example to include any headers on output)
and *after* the config node is processed line by line (to include any
footers on output). Also, it adds the config node reference itself
as the callback arg in addition to have a possibility to extract more
information from the config node itself if needed when processing the
output callback (e.g. the key name, the id, or whether this is a
section or a value etc...).
If the config node from lvm.conf/--config tree is recognized and valid,
it's always coupled with the config node definition ID from
config_settings.h:
struct dm_config_node {
int id;
const char *key;
struct dm_config_node *parent, *sib, *child;
struct dm_config_value *v;
}
For example if the dm_config_node *cn holds "devices/dev" configuration,
then the cn->id holds "devices_dev_CFG" ID from config_settings.h, -1 if
not found in config_settings.h and 0 if matching has not yet been done.
To support the enhanced config node output, a new structure has been
defined in libdevmapper to register it:
struct dm_config_node_out_spec {
dm_config_node_out_fn prefix_fn; /* called before processing config node lines */
dm_config_node_out_fn line_fn; /* called for each config node line */
dm_config_node_out_fn suffix_fn; /* called after processing config node lines */
};
Where dm_config_node_out_fn is:
typedef int (*dm_config_node_out_fn)(const struct dm_config_node *cn, const char *line, void *baton);
(so in comparison to existing callbacks for config node output, it has
an extra dm_config_node *cn arg in addition)
This patch also adds these functions to libdevmapper:
- dm_config_write_node_out
- dm_config_write_one_node_out
...which have exactly the same functionality as their counterparts
without the "out" suffix. The "*_out" functions adds the extra hooks
for enhanced config output (prefix_fn and suffix_fn mentioned above).
One can still use the old interface for config node output, this is
just an enhancement for those who'd like to modify the output more
extensively.
2013-03-05 21:02:13 +04:00
line = dm_pool_end_object ( out - > mem ) ;
2011-12-12 03:18:20 +04:00
config: add support for enhanced config node output
There's a possibility to interconnect the dm_config_node with an
ID, which in our case is used to reference the configuration
definition ID from config_settings.h. So simply interconnecting
struct dm_config_node with struct cfg_def_item.
This patch also adds support for enhanced config node output besides
existing "output line by line". This patch adds a possibility to
register a callback that gets called *before* the config node is
processed line by line (for example to include any headers on output)
and *after* the config node is processed line by line (to include any
footers on output). Also, it adds the config node reference itself
as the callback arg in addition to have a possibility to extract more
information from the config node itself if needed when processing the
output callback (e.g. the key name, the id, or whether this is a
section or a value etc...).
If the config node from lvm.conf/--config tree is recognized and valid,
it's always coupled with the config node definition ID from
config_settings.h:
struct dm_config_node {
int id;
const char *key;
struct dm_config_node *parent, *sib, *child;
struct dm_config_value *v;
}
For example if the dm_config_node *cn holds "devices/dev" configuration,
then the cn->id holds "devices_dev_CFG" ID from config_settings.h, -1 if
not found in config_settings.h and 0 if matching has not yet been done.
To support the enhanced config node output, a new structure has been
defined in libdevmapper to register it:
struct dm_config_node_out_spec {
dm_config_node_out_fn prefix_fn; /* called before processing config node lines */
dm_config_node_out_fn line_fn; /* called for each config node line */
dm_config_node_out_fn suffix_fn; /* called after processing config node lines */
};
Where dm_config_node_out_fn is:
typedef int (*dm_config_node_out_fn)(const struct dm_config_node *cn, const char *line, void *baton);
(so in comparison to existing callbacks for config node output, it has
an extra dm_config_node *cn arg in addition)
This patch also adds these functions to libdevmapper:
- dm_config_write_node_out
- dm_config_write_one_node_out
...which have exactly the same functionality as their counterparts
without the "out" suffix. The "*_out" functions adds the extra hooks
for enhanced config output (prefix_fn and suffix_fn mentioned above).
One can still use the old interface for config node output, this is
just an enhancement for those who'd like to modify the output more
extensively.
2013-03-05 21:02:13 +04:00
if ( ! out - > putline & & ! out - > spec )
2011-12-12 03:18:20 +04:00
return 0 ;
config: add support for enhanced config node output
There's a possibility to interconnect the dm_config_node with an
ID, which in our case is used to reference the configuration
definition ID from config_settings.h. So simply interconnecting
struct dm_config_node with struct cfg_def_item.
This patch also adds support for enhanced config node output besides
existing "output line by line". This patch adds a possibility to
register a callback that gets called *before* the config node is
processed line by line (for example to include any headers on output)
and *after* the config node is processed line by line (to include any
footers on output). Also, it adds the config node reference itself
as the callback arg in addition to have a possibility to extract more
information from the config node itself if needed when processing the
output callback (e.g. the key name, the id, or whether this is a
section or a value etc...).
If the config node from lvm.conf/--config tree is recognized and valid,
it's always coupled with the config node definition ID from
config_settings.h:
struct dm_config_node {
int id;
const char *key;
struct dm_config_node *parent, *sib, *child;
struct dm_config_value *v;
}
For example if the dm_config_node *cn holds "devices/dev" configuration,
then the cn->id holds "devices_dev_CFG" ID from config_settings.h, -1 if
not found in config_settings.h and 0 if matching has not yet been done.
To support the enhanced config node output, a new structure has been
defined in libdevmapper to register it:
struct dm_config_node_out_spec {
dm_config_node_out_fn prefix_fn; /* called before processing config node lines */
dm_config_node_out_fn line_fn; /* called for each config node line */
dm_config_node_out_fn suffix_fn; /* called after processing config node lines */
};
Where dm_config_node_out_fn is:
typedef int (*dm_config_node_out_fn)(const struct dm_config_node *cn, const char *line, void *baton);
(so in comparison to existing callbacks for config node output, it has
an extra dm_config_node *cn arg in addition)
This patch also adds these functions to libdevmapper:
- dm_config_write_node_out
- dm_config_write_one_node_out
...which have exactly the same functionality as their counterparts
without the "out" suffix. The "*_out" functions adds the extra hooks
for enhanced config output (prefix_fn and suffix_fn mentioned above).
One can still use the old interface for config node output, this is
just an enhancement for those who'd like to modify the output more
extensively.
2013-03-05 21:02:13 +04:00
if ( out - > putline )
out - > putline ( line , out - > baton ) ;
if ( out - > spec & & out - > spec - > line_fn )
out - > spec - > line_fn ( cn , line , out - > baton ) ;
2011-08-30 18:55:15 +04:00
return 1 ;
}
config: add support for enhanced config node output
There's a possibility to interconnect the dm_config_node with an
ID, which in our case is used to reference the configuration
definition ID from config_settings.h. So simply interconnecting
struct dm_config_node with struct cfg_def_item.
This patch also adds support for enhanced config node output besides
existing "output line by line". This patch adds a possibility to
register a callback that gets called *before* the config node is
processed line by line (for example to include any headers on output)
and *after* the config node is processed line by line (to include any
footers on output). Also, it adds the config node reference itself
as the callback arg in addition to have a possibility to extract more
information from the config node itself if needed when processing the
output callback (e.g. the key name, the id, or whether this is a
section or a value etc...).
If the config node from lvm.conf/--config tree is recognized and valid,
it's always coupled with the config node definition ID from
config_settings.h:
struct dm_config_node {
int id;
const char *key;
struct dm_config_node *parent, *sib, *child;
struct dm_config_value *v;
}
For example if the dm_config_node *cn holds "devices/dev" configuration,
then the cn->id holds "devices_dev_CFG" ID from config_settings.h, -1 if
not found in config_settings.h and 0 if matching has not yet been done.
To support the enhanced config node output, a new structure has been
defined in libdevmapper to register it:
struct dm_config_node_out_spec {
dm_config_node_out_fn prefix_fn; /* called before processing config node lines */
dm_config_node_out_fn line_fn; /* called for each config node line */
dm_config_node_out_fn suffix_fn; /* called after processing config node lines */
};
Where dm_config_node_out_fn is:
typedef int (*dm_config_node_out_fn)(const struct dm_config_node *cn, const char *line, void *baton);
(so in comparison to existing callbacks for config node output, it has
an extra dm_config_node *cn arg in addition)
This patch also adds these functions to libdevmapper:
- dm_config_write_node_out
- dm_config_write_one_node_out
...which have exactly the same functionality as their counterparts
without the "out" suffix. The "*_out" functions adds the extra hooks
for enhanced config output (prefix_fn and suffix_fn mentioned above).
One can still use the old interface for config node output, this is
just an enhancement for those who'd like to modify the output more
extensively.
2013-03-05 21:02:13 +04:00
static int _write_value ( struct config_output * out , const struct dm_config_value * v )
2011-08-30 18:55:15 +04:00
{
char * buf ;
switch ( v - > type ) {
case DM_CFG_STRING :
2013-12-05 05:09:03 +04:00
buf = alloca ( dm_escaped_len ( v - > v . str ) ) ;
2011-08-30 18:55:15 +04:00
line_append ( " \" %s \" " , dm_escape_double_quotes ( buf , v - > v . str ) ) ;
break ;
case DM_CFG_FLOAT :
2011-09-02 01:04:14 +04:00
line_append ( " %f " , v - > v . f ) ;
2011-08-30 18:55:15 +04:00
break ;
case DM_CFG_INT :
line_append ( " % " PRId64 , v - > v . i ) ;
break ;
case DM_CFG_EMPTY_ARRAY :
line_append ( " [] " ) ;
break ;
default :
log_error ( " _write_value: Unknown value type: %d " , v - > type ) ;
}
return 1 ;
}
static int _write_config ( const struct dm_config_node * n , int only_one ,
config: add support for enhanced config node output
There's a possibility to interconnect the dm_config_node with an
ID, which in our case is used to reference the configuration
definition ID from config_settings.h. So simply interconnecting
struct dm_config_node with struct cfg_def_item.
This patch also adds support for enhanced config node output besides
existing "output line by line". This patch adds a possibility to
register a callback that gets called *before* the config node is
processed line by line (for example to include any headers on output)
and *after* the config node is processed line by line (to include any
footers on output). Also, it adds the config node reference itself
as the callback arg in addition to have a possibility to extract more
information from the config node itself if needed when processing the
output callback (e.g. the key name, the id, or whether this is a
section or a value etc...).
If the config node from lvm.conf/--config tree is recognized and valid,
it's always coupled with the config node definition ID from
config_settings.h:
struct dm_config_node {
int id;
const char *key;
struct dm_config_node *parent, *sib, *child;
struct dm_config_value *v;
}
For example if the dm_config_node *cn holds "devices/dev" configuration,
then the cn->id holds "devices_dev_CFG" ID from config_settings.h, -1 if
not found in config_settings.h and 0 if matching has not yet been done.
To support the enhanced config node output, a new structure has been
defined in libdevmapper to register it:
struct dm_config_node_out_spec {
dm_config_node_out_fn prefix_fn; /* called before processing config node lines */
dm_config_node_out_fn line_fn; /* called for each config node line */
dm_config_node_out_fn suffix_fn; /* called after processing config node lines */
};
Where dm_config_node_out_fn is:
typedef int (*dm_config_node_out_fn)(const struct dm_config_node *cn, const char *line, void *baton);
(so in comparison to existing callbacks for config node output, it has
an extra dm_config_node *cn arg in addition)
This patch also adds these functions to libdevmapper:
- dm_config_write_node_out
- dm_config_write_one_node_out
...which have exactly the same functionality as their counterparts
without the "out" suffix. The "*_out" functions adds the extra hooks
for enhanced config output (prefix_fn and suffix_fn mentioned above).
One can still use the old interface for config node output, this is
just an enhancement for those who'd like to modify the output more
extensively.
2013-03-05 21:02:13 +04:00
struct config_output * out , int level )
2011-08-30 18:55:15 +04:00
{
char space [ MAX_INDENT + 1 ] ;
int l = ( level < MAX_INDENT ) ? level : MAX_INDENT ;
int i ;
2013-12-01 23:02:28 +04:00
char * escaped_key = NULL ;
2011-08-30 18:55:15 +04:00
if ( ! n )
return 1 ;
for ( i = 0 ; i < l ; i + + )
space [ i ] = ' \t ' ;
space [ i ] = ' \0 ' ;
do {
config: add support for enhanced config node output
There's a possibility to interconnect the dm_config_node with an
ID, which in our case is used to reference the configuration
definition ID from config_settings.h. So simply interconnecting
struct dm_config_node with struct cfg_def_item.
This patch also adds support for enhanced config node output besides
existing "output line by line". This patch adds a possibility to
register a callback that gets called *before* the config node is
processed line by line (for example to include any headers on output)
and *after* the config node is processed line by line (to include any
footers on output). Also, it adds the config node reference itself
as the callback arg in addition to have a possibility to extract more
information from the config node itself if needed when processing the
output callback (e.g. the key name, the id, or whether this is a
section or a value etc...).
If the config node from lvm.conf/--config tree is recognized and valid,
it's always coupled with the config node definition ID from
config_settings.h:
struct dm_config_node {
int id;
const char *key;
struct dm_config_node *parent, *sib, *child;
struct dm_config_value *v;
}
For example if the dm_config_node *cn holds "devices/dev" configuration,
then the cn->id holds "devices_dev_CFG" ID from config_settings.h, -1 if
not found in config_settings.h and 0 if matching has not yet been done.
To support the enhanced config node output, a new structure has been
defined in libdevmapper to register it:
struct dm_config_node_out_spec {
dm_config_node_out_fn prefix_fn; /* called before processing config node lines */
dm_config_node_out_fn line_fn; /* called for each config node line */
dm_config_node_out_fn suffix_fn; /* called after processing config node lines */
};
Where dm_config_node_out_fn is:
typedef int (*dm_config_node_out_fn)(const struct dm_config_node *cn, const char *line, void *baton);
(so in comparison to existing callbacks for config node output, it has
an extra dm_config_node *cn arg in addition)
This patch also adds these functions to libdevmapper:
- dm_config_write_node_out
- dm_config_write_one_node_out
...which have exactly the same functionality as their counterparts
without the "out" suffix. The "*_out" functions adds the extra hooks
for enhanced config output (prefix_fn and suffix_fn mentioned above).
One can still use the old interface for config node output, this is
just an enhancement for those who'd like to modify the output more
extensively.
2013-03-05 21:02:13 +04:00
if ( out - > spec & & out - > spec - > prefix_fn )
out - > spec - > prefix_fn ( n , space , out - > baton ) ;
if ( ! _line_start ( out ) )
2011-08-30 18:55:15 +04:00
return_0 ;
2013-12-01 23:02:28 +04:00
if ( strchr ( n - > key , ' # ' ) | | strchr ( n - > key , ' " ' ) | | strchr ( n - > key , ' ! ' ) ) {
escaped_key = alloca ( dm_escaped_len ( n - > key ) + 2 ) ;
* escaped_key = ' " ' ;
dm_escape_double_quotes ( escaped_key + 1 , n - > key ) ;
strcat ( escaped_key , " \" " ) ;
}
line_append ( " %s%s " , space , escaped_key ? escaped_key : n - > key ) ;
escaped_key = NULL ;
2011-08-30 18:55:15 +04:00
if ( ! n - > v ) {
/* it's a sub section */
line_append ( " { " ) ;
config: add support for enhanced config node output
There's a possibility to interconnect the dm_config_node with an
ID, which in our case is used to reference the configuration
definition ID from config_settings.h. So simply interconnecting
struct dm_config_node with struct cfg_def_item.
This patch also adds support for enhanced config node output besides
existing "output line by line". This patch adds a possibility to
register a callback that gets called *before* the config node is
processed line by line (for example to include any headers on output)
and *after* the config node is processed line by line (to include any
footers on output). Also, it adds the config node reference itself
as the callback arg in addition to have a possibility to extract more
information from the config node itself if needed when processing the
output callback (e.g. the key name, the id, or whether this is a
section or a value etc...).
If the config node from lvm.conf/--config tree is recognized and valid,
it's always coupled with the config node definition ID from
config_settings.h:
struct dm_config_node {
int id;
const char *key;
struct dm_config_node *parent, *sib, *child;
struct dm_config_value *v;
}
For example if the dm_config_node *cn holds "devices/dev" configuration,
then the cn->id holds "devices_dev_CFG" ID from config_settings.h, -1 if
not found in config_settings.h and 0 if matching has not yet been done.
To support the enhanced config node output, a new structure has been
defined in libdevmapper to register it:
struct dm_config_node_out_spec {
dm_config_node_out_fn prefix_fn; /* called before processing config node lines */
dm_config_node_out_fn line_fn; /* called for each config node line */
dm_config_node_out_fn suffix_fn; /* called after processing config node lines */
};
Where dm_config_node_out_fn is:
typedef int (*dm_config_node_out_fn)(const struct dm_config_node *cn, const char *line, void *baton);
(so in comparison to existing callbacks for config node output, it has
an extra dm_config_node *cn arg in addition)
This patch also adds these functions to libdevmapper:
- dm_config_write_node_out
- dm_config_write_one_node_out
...which have exactly the same functionality as their counterparts
without the "out" suffix. The "*_out" functions adds the extra hooks
for enhanced config output (prefix_fn and suffix_fn mentioned above).
One can still use the old interface for config node output, this is
just an enhancement for those who'd like to modify the output more
extensively.
2013-03-05 21:02:13 +04:00
if ( ! _line_end ( n , out ) )
2011-08-30 18:55:15 +04:00
return_0 ;
config: add support for enhanced config node output
There's a possibility to interconnect the dm_config_node with an
ID, which in our case is used to reference the configuration
definition ID from config_settings.h. So simply interconnecting
struct dm_config_node with struct cfg_def_item.
This patch also adds support for enhanced config node output besides
existing "output line by line". This patch adds a possibility to
register a callback that gets called *before* the config node is
processed line by line (for example to include any headers on output)
and *after* the config node is processed line by line (to include any
footers on output). Also, it adds the config node reference itself
as the callback arg in addition to have a possibility to extract more
information from the config node itself if needed when processing the
output callback (e.g. the key name, the id, or whether this is a
section or a value etc...).
If the config node from lvm.conf/--config tree is recognized and valid,
it's always coupled with the config node definition ID from
config_settings.h:
struct dm_config_node {
int id;
const char *key;
struct dm_config_node *parent, *sib, *child;
struct dm_config_value *v;
}
For example if the dm_config_node *cn holds "devices/dev" configuration,
then the cn->id holds "devices_dev_CFG" ID from config_settings.h, -1 if
not found in config_settings.h and 0 if matching has not yet been done.
To support the enhanced config node output, a new structure has been
defined in libdevmapper to register it:
struct dm_config_node_out_spec {
dm_config_node_out_fn prefix_fn; /* called before processing config node lines */
dm_config_node_out_fn line_fn; /* called for each config node line */
dm_config_node_out_fn suffix_fn; /* called after processing config node lines */
};
Where dm_config_node_out_fn is:
typedef int (*dm_config_node_out_fn)(const struct dm_config_node *cn, const char *line, void *baton);
(so in comparison to existing callbacks for config node output, it has
an extra dm_config_node *cn arg in addition)
This patch also adds these functions to libdevmapper:
- dm_config_write_node_out
- dm_config_write_one_node_out
...which have exactly the same functionality as their counterparts
without the "out" suffix. The "*_out" functions adds the extra hooks
for enhanced config output (prefix_fn and suffix_fn mentioned above).
One can still use the old interface for config node output, this is
just an enhancement for those who'd like to modify the output more
extensively.
2013-03-05 21:02:13 +04:00
_write_config ( n - > child , 0 , out , level + 1 ) ;
if ( ! _line_start ( out ) )
2011-08-30 18:55:15 +04:00
return_0 ;
line_append ( " %s} " , space ) ;
} else {
/* it's a value */
const struct dm_config_value * v = n - > v ;
line_append ( " = " ) ;
if ( v - > next ) {
line_append ( " [ " ) ;
while ( v & & v - > type ! = DM_CFG_EMPTY_ARRAY ) {
config: add support for enhanced config node output
There's a possibility to interconnect the dm_config_node with an
ID, which in our case is used to reference the configuration
definition ID from config_settings.h. So simply interconnecting
struct dm_config_node with struct cfg_def_item.
This patch also adds support for enhanced config node output besides
existing "output line by line". This patch adds a possibility to
register a callback that gets called *before* the config node is
processed line by line (for example to include any headers on output)
and *after* the config node is processed line by line (to include any
footers on output). Also, it adds the config node reference itself
as the callback arg in addition to have a possibility to extract more
information from the config node itself if needed when processing the
output callback (e.g. the key name, the id, or whether this is a
section or a value etc...).
If the config node from lvm.conf/--config tree is recognized and valid,
it's always coupled with the config node definition ID from
config_settings.h:
struct dm_config_node {
int id;
const char *key;
struct dm_config_node *parent, *sib, *child;
struct dm_config_value *v;
}
For example if the dm_config_node *cn holds "devices/dev" configuration,
then the cn->id holds "devices_dev_CFG" ID from config_settings.h, -1 if
not found in config_settings.h and 0 if matching has not yet been done.
To support the enhanced config node output, a new structure has been
defined in libdevmapper to register it:
struct dm_config_node_out_spec {
dm_config_node_out_fn prefix_fn; /* called before processing config node lines */
dm_config_node_out_fn line_fn; /* called for each config node line */
dm_config_node_out_fn suffix_fn; /* called after processing config node lines */
};
Where dm_config_node_out_fn is:
typedef int (*dm_config_node_out_fn)(const struct dm_config_node *cn, const char *line, void *baton);
(so in comparison to existing callbacks for config node output, it has
an extra dm_config_node *cn arg in addition)
This patch also adds these functions to libdevmapper:
- dm_config_write_node_out
- dm_config_write_one_node_out
...which have exactly the same functionality as their counterparts
without the "out" suffix. The "*_out" functions adds the extra hooks
for enhanced config output (prefix_fn and suffix_fn mentioned above).
One can still use the old interface for config node output, this is
just an enhancement for those who'd like to modify the output more
extensively.
2013-03-05 21:02:13 +04:00
if ( ! _write_value ( out , v ) )
2011-08-30 18:55:15 +04:00
return_0 ;
v = v - > next ;
if ( v & & v - > type ! = DM_CFG_EMPTY_ARRAY )
line_append ( " , " ) ;
}
line_append ( " ] " ) ;
} else
config: add support for enhanced config node output
There's a possibility to interconnect the dm_config_node with an
ID, which in our case is used to reference the configuration
definition ID from config_settings.h. So simply interconnecting
struct dm_config_node with struct cfg_def_item.
This patch also adds support for enhanced config node output besides
existing "output line by line". This patch adds a possibility to
register a callback that gets called *before* the config node is
processed line by line (for example to include any headers on output)
and *after* the config node is processed line by line (to include any
footers on output). Also, it adds the config node reference itself
as the callback arg in addition to have a possibility to extract more
information from the config node itself if needed when processing the
output callback (e.g. the key name, the id, or whether this is a
section or a value etc...).
If the config node from lvm.conf/--config tree is recognized and valid,
it's always coupled with the config node definition ID from
config_settings.h:
struct dm_config_node {
int id;
const char *key;
struct dm_config_node *parent, *sib, *child;
struct dm_config_value *v;
}
For example if the dm_config_node *cn holds "devices/dev" configuration,
then the cn->id holds "devices_dev_CFG" ID from config_settings.h, -1 if
not found in config_settings.h and 0 if matching has not yet been done.
To support the enhanced config node output, a new structure has been
defined in libdevmapper to register it:
struct dm_config_node_out_spec {
dm_config_node_out_fn prefix_fn; /* called before processing config node lines */
dm_config_node_out_fn line_fn; /* called for each config node line */
dm_config_node_out_fn suffix_fn; /* called after processing config node lines */
};
Where dm_config_node_out_fn is:
typedef int (*dm_config_node_out_fn)(const struct dm_config_node *cn, const char *line, void *baton);
(so in comparison to existing callbacks for config node output, it has
an extra dm_config_node *cn arg in addition)
This patch also adds these functions to libdevmapper:
- dm_config_write_node_out
- dm_config_write_one_node_out
...which have exactly the same functionality as their counterparts
without the "out" suffix. The "*_out" functions adds the extra hooks
for enhanced config output (prefix_fn and suffix_fn mentioned above).
One can still use the old interface for config node output, this is
just an enhancement for those who'd like to modify the output more
extensively.
2013-03-05 21:02:13 +04:00
if ( ! _write_value ( out , v ) )
2011-08-30 18:55:15 +04:00
return_0 ;
}
config: add support for enhanced config node output
There's a possibility to interconnect the dm_config_node with an
ID, which in our case is used to reference the configuration
definition ID from config_settings.h. So simply interconnecting
struct dm_config_node with struct cfg_def_item.
This patch also adds support for enhanced config node output besides
existing "output line by line". This patch adds a possibility to
register a callback that gets called *before* the config node is
processed line by line (for example to include any headers on output)
and *after* the config node is processed line by line (to include any
footers on output). Also, it adds the config node reference itself
as the callback arg in addition to have a possibility to extract more
information from the config node itself if needed when processing the
output callback (e.g. the key name, the id, or whether this is a
section or a value etc...).
If the config node from lvm.conf/--config tree is recognized and valid,
it's always coupled with the config node definition ID from
config_settings.h:
struct dm_config_node {
int id;
const char *key;
struct dm_config_node *parent, *sib, *child;
struct dm_config_value *v;
}
For example if the dm_config_node *cn holds "devices/dev" configuration,
then the cn->id holds "devices_dev_CFG" ID from config_settings.h, -1 if
not found in config_settings.h and 0 if matching has not yet been done.
To support the enhanced config node output, a new structure has been
defined in libdevmapper to register it:
struct dm_config_node_out_spec {
dm_config_node_out_fn prefix_fn; /* called before processing config node lines */
dm_config_node_out_fn line_fn; /* called for each config node line */
dm_config_node_out_fn suffix_fn; /* called after processing config node lines */
};
Where dm_config_node_out_fn is:
typedef int (*dm_config_node_out_fn)(const struct dm_config_node *cn, const char *line, void *baton);
(so in comparison to existing callbacks for config node output, it has
an extra dm_config_node *cn arg in addition)
This patch also adds these functions to libdevmapper:
- dm_config_write_node_out
- dm_config_write_one_node_out
...which have exactly the same functionality as their counterparts
without the "out" suffix. The "*_out" functions adds the extra hooks
for enhanced config output (prefix_fn and suffix_fn mentioned above).
One can still use the old interface for config node output, this is
just an enhancement for those who'd like to modify the output more
extensively.
2013-03-05 21:02:13 +04:00
if ( ! _line_end ( n , out ) )
2011-08-30 18:55:15 +04:00
return_0 ;
config: add support for enhanced config node output
There's a possibility to interconnect the dm_config_node with an
ID, which in our case is used to reference the configuration
definition ID from config_settings.h. So simply interconnecting
struct dm_config_node with struct cfg_def_item.
This patch also adds support for enhanced config node output besides
existing "output line by line". This patch adds a possibility to
register a callback that gets called *before* the config node is
processed line by line (for example to include any headers on output)
and *after* the config node is processed line by line (to include any
footers on output). Also, it adds the config node reference itself
as the callback arg in addition to have a possibility to extract more
information from the config node itself if needed when processing the
output callback (e.g. the key name, the id, or whether this is a
section or a value etc...).
If the config node from lvm.conf/--config tree is recognized and valid,
it's always coupled with the config node definition ID from
config_settings.h:
struct dm_config_node {
int id;
const char *key;
struct dm_config_node *parent, *sib, *child;
struct dm_config_value *v;
}
For example if the dm_config_node *cn holds "devices/dev" configuration,
then the cn->id holds "devices_dev_CFG" ID from config_settings.h, -1 if
not found in config_settings.h and 0 if matching has not yet been done.
To support the enhanced config node output, a new structure has been
defined in libdevmapper to register it:
struct dm_config_node_out_spec {
dm_config_node_out_fn prefix_fn; /* called before processing config node lines */
dm_config_node_out_fn line_fn; /* called for each config node line */
dm_config_node_out_fn suffix_fn; /* called after processing config node lines */
};
Where dm_config_node_out_fn is:
typedef int (*dm_config_node_out_fn)(const struct dm_config_node *cn, const char *line, void *baton);
(so in comparison to existing callbacks for config node output, it has
an extra dm_config_node *cn arg in addition)
This patch also adds these functions to libdevmapper:
- dm_config_write_node_out
- dm_config_write_one_node_out
...which have exactly the same functionality as their counterparts
without the "out" suffix. The "*_out" functions adds the extra hooks
for enhanced config output (prefix_fn and suffix_fn mentioned above).
One can still use the old interface for config node output, this is
just an enhancement for those who'd like to modify the output more
extensively.
2013-03-05 21:02:13 +04:00
if ( out - > spec & & out - > spec - > suffix_fn )
out - > spec - > suffix_fn ( n , space , out - > baton ) ;
2011-08-30 18:55:15 +04:00
n = n - > sib ;
} while ( n & & ! only_one ) ;
/* FIXME: add error checking */
return 1 ;
}
2012-07-20 17:53:04 +04:00
static int _write_node ( const struct dm_config_node * cn , int only_one ,
config: add support for enhanced config node output
There's a possibility to interconnect the dm_config_node with an
ID, which in our case is used to reference the configuration
definition ID from config_settings.h. So simply interconnecting
struct dm_config_node with struct cfg_def_item.
This patch also adds support for enhanced config node output besides
existing "output line by line". This patch adds a possibility to
register a callback that gets called *before* the config node is
processed line by line (for example to include any headers on output)
and *after* the config node is processed line by line (to include any
footers on output). Also, it adds the config node reference itself
as the callback arg in addition to have a possibility to extract more
information from the config node itself if needed when processing the
output callback (e.g. the key name, the id, or whether this is a
section or a value etc...).
If the config node from lvm.conf/--config tree is recognized and valid,
it's always coupled with the config node definition ID from
config_settings.h:
struct dm_config_node {
int id;
const char *key;
struct dm_config_node *parent, *sib, *child;
struct dm_config_value *v;
}
For example if the dm_config_node *cn holds "devices/dev" configuration,
then the cn->id holds "devices_dev_CFG" ID from config_settings.h, -1 if
not found in config_settings.h and 0 if matching has not yet been done.
To support the enhanced config node output, a new structure has been
defined in libdevmapper to register it:
struct dm_config_node_out_spec {
dm_config_node_out_fn prefix_fn; /* called before processing config node lines */
dm_config_node_out_fn line_fn; /* called for each config node line */
dm_config_node_out_fn suffix_fn; /* called after processing config node lines */
};
Where dm_config_node_out_fn is:
typedef int (*dm_config_node_out_fn)(const struct dm_config_node *cn, const char *line, void *baton);
(so in comparison to existing callbacks for config node output, it has
an extra dm_config_node *cn arg in addition)
This patch also adds these functions to libdevmapper:
- dm_config_write_node_out
- dm_config_write_one_node_out
...which have exactly the same functionality as their counterparts
without the "out" suffix. The "*_out" functions adds the extra hooks
for enhanced config output (prefix_fn and suffix_fn mentioned above).
One can still use the old interface for config node output, this is
just an enhancement for those who'd like to modify the output more
extensively.
2013-03-05 21:02:13 +04:00
dm_putline_fn putline ,
const struct dm_config_node_out_spec * out_spec ,
void * baton )
2011-08-30 18:55:15 +04:00
{
2013-06-15 00:00:44 +04:00
struct config_output out = {
. mem = dm_pool_create ( " config_output " , 1024 ) ,
. putline = putline ,
. spec = out_spec ,
. baton = baton
} ;
if ( ! out . mem )
2011-08-30 18:55:15 +04:00
return_0 ;
2013-06-15 00:00:44 +04:00
config: add support for enhanced config node output
There's a possibility to interconnect the dm_config_node with an
ID, which in our case is used to reference the configuration
definition ID from config_settings.h. So simply interconnecting
struct dm_config_node with struct cfg_def_item.
This patch also adds support for enhanced config node output besides
existing "output line by line". This patch adds a possibility to
register a callback that gets called *before* the config node is
processed line by line (for example to include any headers on output)
and *after* the config node is processed line by line (to include any
footers on output). Also, it adds the config node reference itself
as the callback arg in addition to have a possibility to extract more
information from the config node itself if needed when processing the
output callback (e.g. the key name, the id, or whether this is a
section or a value etc...).
If the config node from lvm.conf/--config tree is recognized and valid,
it's always coupled with the config node definition ID from
config_settings.h:
struct dm_config_node {
int id;
const char *key;
struct dm_config_node *parent, *sib, *child;
struct dm_config_value *v;
}
For example if the dm_config_node *cn holds "devices/dev" configuration,
then the cn->id holds "devices_dev_CFG" ID from config_settings.h, -1 if
not found in config_settings.h and 0 if matching has not yet been done.
To support the enhanced config node output, a new structure has been
defined in libdevmapper to register it:
struct dm_config_node_out_spec {
dm_config_node_out_fn prefix_fn; /* called before processing config node lines */
dm_config_node_out_fn line_fn; /* called for each config node line */
dm_config_node_out_fn suffix_fn; /* called after processing config node lines */
};
Where dm_config_node_out_fn is:
typedef int (*dm_config_node_out_fn)(const struct dm_config_node *cn, const char *line, void *baton);
(so in comparison to existing callbacks for config node output, it has
an extra dm_config_node *cn arg in addition)
This patch also adds these functions to libdevmapper:
- dm_config_write_node_out
- dm_config_write_one_node_out
...which have exactly the same functionality as their counterparts
without the "out" suffix. The "*_out" functions adds the extra hooks
for enhanced config output (prefix_fn and suffix_fn mentioned above).
One can still use the old interface for config node output, this is
just an enhancement for those who'd like to modify the output more
extensively.
2013-03-05 21:02:13 +04:00
if ( ! _write_config ( cn , only_one , & out , 0 ) ) {
dm_pool_destroy ( out . mem ) ;
2011-08-30 18:55:15 +04:00
return_0 ;
}
config: add support for enhanced config node output
There's a possibility to interconnect the dm_config_node with an
ID, which in our case is used to reference the configuration
definition ID from config_settings.h. So simply interconnecting
struct dm_config_node with struct cfg_def_item.
This patch also adds support for enhanced config node output besides
existing "output line by line". This patch adds a possibility to
register a callback that gets called *before* the config node is
processed line by line (for example to include any headers on output)
and *after* the config node is processed line by line (to include any
footers on output). Also, it adds the config node reference itself
as the callback arg in addition to have a possibility to extract more
information from the config node itself if needed when processing the
output callback (e.g. the key name, the id, or whether this is a
section or a value etc...).
If the config node from lvm.conf/--config tree is recognized and valid,
it's always coupled with the config node definition ID from
config_settings.h:
struct dm_config_node {
int id;
const char *key;
struct dm_config_node *parent, *sib, *child;
struct dm_config_value *v;
}
For example if the dm_config_node *cn holds "devices/dev" configuration,
then the cn->id holds "devices_dev_CFG" ID from config_settings.h, -1 if
not found in config_settings.h and 0 if matching has not yet been done.
To support the enhanced config node output, a new structure has been
defined in libdevmapper to register it:
struct dm_config_node_out_spec {
dm_config_node_out_fn prefix_fn; /* called before processing config node lines */
dm_config_node_out_fn line_fn; /* called for each config node line */
dm_config_node_out_fn suffix_fn; /* called after processing config node lines */
};
Where dm_config_node_out_fn is:
typedef int (*dm_config_node_out_fn)(const struct dm_config_node *cn, const char *line, void *baton);
(so in comparison to existing callbacks for config node output, it has
an extra dm_config_node *cn arg in addition)
This patch also adds these functions to libdevmapper:
- dm_config_write_node_out
- dm_config_write_one_node_out
...which have exactly the same functionality as their counterparts
without the "out" suffix. The "*_out" functions adds the extra hooks
for enhanced config output (prefix_fn and suffix_fn mentioned above).
One can still use the old interface for config node output, this is
just an enhancement for those who'd like to modify the output more
extensively.
2013-03-05 21:02:13 +04:00
dm_pool_destroy ( out . mem ) ;
2011-08-30 18:55:15 +04:00
return 1 ;
}
2012-07-20 17:53:04 +04:00
int dm_config_write_one_node ( const struct dm_config_node * cn , dm_putline_fn putline , void * baton )
{
config: add support for enhanced config node output
There's a possibility to interconnect the dm_config_node with an
ID, which in our case is used to reference the configuration
definition ID from config_settings.h. So simply interconnecting
struct dm_config_node with struct cfg_def_item.
This patch also adds support for enhanced config node output besides
existing "output line by line". This patch adds a possibility to
register a callback that gets called *before* the config node is
processed line by line (for example to include any headers on output)
and *after* the config node is processed line by line (to include any
footers on output). Also, it adds the config node reference itself
as the callback arg in addition to have a possibility to extract more
information from the config node itself if needed when processing the
output callback (e.g. the key name, the id, or whether this is a
section or a value etc...).
If the config node from lvm.conf/--config tree is recognized and valid,
it's always coupled with the config node definition ID from
config_settings.h:
struct dm_config_node {
int id;
const char *key;
struct dm_config_node *parent, *sib, *child;
struct dm_config_value *v;
}
For example if the dm_config_node *cn holds "devices/dev" configuration,
then the cn->id holds "devices_dev_CFG" ID from config_settings.h, -1 if
not found in config_settings.h and 0 if matching has not yet been done.
To support the enhanced config node output, a new structure has been
defined in libdevmapper to register it:
struct dm_config_node_out_spec {
dm_config_node_out_fn prefix_fn; /* called before processing config node lines */
dm_config_node_out_fn line_fn; /* called for each config node line */
dm_config_node_out_fn suffix_fn; /* called after processing config node lines */
};
Where dm_config_node_out_fn is:
typedef int (*dm_config_node_out_fn)(const struct dm_config_node *cn, const char *line, void *baton);
(so in comparison to existing callbacks for config node output, it has
an extra dm_config_node *cn arg in addition)
This patch also adds these functions to libdevmapper:
- dm_config_write_node_out
- dm_config_write_one_node_out
...which have exactly the same functionality as their counterparts
without the "out" suffix. The "*_out" functions adds the extra hooks
for enhanced config output (prefix_fn and suffix_fn mentioned above).
One can still use the old interface for config node output, this is
just an enhancement for those who'd like to modify the output more
extensively.
2013-03-05 21:02:13 +04:00
return _write_node ( cn , 1 , putline , NULL , baton ) ;
2012-07-20 17:53:04 +04:00
}
int dm_config_write_node ( const struct dm_config_node * cn , dm_putline_fn putline , void * baton )
{
config: add support for enhanced config node output
There's a possibility to interconnect the dm_config_node with an
ID, which in our case is used to reference the configuration
definition ID from config_settings.h. So simply interconnecting
struct dm_config_node with struct cfg_def_item.
This patch also adds support for enhanced config node output besides
existing "output line by line". This patch adds a possibility to
register a callback that gets called *before* the config node is
processed line by line (for example to include any headers on output)
and *after* the config node is processed line by line (to include any
footers on output). Also, it adds the config node reference itself
as the callback arg in addition to have a possibility to extract more
information from the config node itself if needed when processing the
output callback (e.g. the key name, the id, or whether this is a
section or a value etc...).
If the config node from lvm.conf/--config tree is recognized and valid,
it's always coupled with the config node definition ID from
config_settings.h:
struct dm_config_node {
int id;
const char *key;
struct dm_config_node *parent, *sib, *child;
struct dm_config_value *v;
}
For example if the dm_config_node *cn holds "devices/dev" configuration,
then the cn->id holds "devices_dev_CFG" ID from config_settings.h, -1 if
not found in config_settings.h and 0 if matching has not yet been done.
To support the enhanced config node output, a new structure has been
defined in libdevmapper to register it:
struct dm_config_node_out_spec {
dm_config_node_out_fn prefix_fn; /* called before processing config node lines */
dm_config_node_out_fn line_fn; /* called for each config node line */
dm_config_node_out_fn suffix_fn; /* called after processing config node lines */
};
Where dm_config_node_out_fn is:
typedef int (*dm_config_node_out_fn)(const struct dm_config_node *cn, const char *line, void *baton);
(so in comparison to existing callbacks for config node output, it has
an extra dm_config_node *cn arg in addition)
This patch also adds these functions to libdevmapper:
- dm_config_write_node_out
- dm_config_write_one_node_out
...which have exactly the same functionality as their counterparts
without the "out" suffix. The "*_out" functions adds the extra hooks
for enhanced config output (prefix_fn and suffix_fn mentioned above).
One can still use the old interface for config node output, this is
just an enhancement for those who'd like to modify the output more
extensively.
2013-03-05 21:02:13 +04:00
return _write_node ( cn , 0 , putline , NULL , baton ) ;
}
int dm_config_write_one_node_out ( const struct dm_config_node * cn ,
const struct dm_config_node_out_spec * out_spec ,
void * baton )
{
return _write_node ( cn , 1 , NULL , out_spec , baton ) ;
}
int dm_config_write_node_out ( const struct dm_config_node * cn ,
const struct dm_config_node_out_spec * out_spec ,
void * baton )
{
return _write_node ( cn , 0 , NULL , out_spec , baton ) ;
2012-07-20 17:53:04 +04:00
}
2011-08-30 18:55:15 +04:00
/*
* parser
*/
2013-02-01 14:07:44 +04:00
static char * _dup_string_tok ( struct parser * p )
{
char * str ;
p - > tb + + , p - > te - - ; /* strip "'s */
if ( p - > te < p - > tb ) {
log_error ( " Parse error at byte % " PRIptrdiff_t " (line %d): "
" expected a string token. " ,
p - > tb - p - > fb + 1 , p - > line ) ;
return NULL ;
}
if ( ! ( str = _dup_tok ( p ) ) )
return_NULL ;
p - > te + + ;
return str ;
}
2011-08-30 18:55:15 +04:00
static struct dm_config_node * _file ( struct parser * p )
{
struct dm_config_node * root = NULL , * n , * l = NULL ;
while ( p - > t ! = TOK_EOF ) {
if ( ! ( n = _section ( p ) ) )
2011-09-25 23:38:59 +04:00
return_NULL ;
2011-08-30 18:55:15 +04:00
if ( ! root )
root = n ;
else
l - > sib = n ;
n - > parent = root ;
l = n ;
}
return root ;
}
static struct dm_config_node * _section ( struct parser * p )
{
/* IDENTIFIER SECTION_B_CHAR VALUE* SECTION_E_CHAR */
2013-12-05 05:09:03 +04:00
2011-08-30 18:55:15 +04:00
struct dm_config_node * root , * n , * l = NULL ;
2013-12-05 05:09:03 +04:00
char * str ;
2011-09-25 23:43:43 +04:00
if ( ! ( root = _create_node ( p - > mem ) ) ) {
log_error ( " Failed to allocate section node " ) ;
return NULL ;
}
2011-08-30 18:55:15 +04:00
2013-12-01 23:02:28 +04:00
if ( p - > t = = TOK_STRING_ESCAPED ) {
2013-12-05 05:09:03 +04:00
if ( ! ( str = _dup_string_tok ( p ) ) )
return_NULL ;
dm_unescape_double_quotes ( str ) ;
root - > key = str ;
2013-12-01 23:02:28 +04:00
match ( TOK_STRING_ESCAPED ) ;
2013-12-05 05:09:03 +04:00
} else if ( p - > t = = TOK_STRING ) {
if ( ! ( str = _dup_string_tok ( p ) ) )
return_NULL ;
root - > key = str ;
match ( TOK_STRING ) ;
} else {
if ( ! ( root - > key = _dup_tok ( p ) ) )
return_NULL ;
2013-12-01 23:02:28 +04:00
match ( TOK_IDENTIFIER ) ;
2013-12-05 05:09:03 +04:00
}
if ( ! strlen ( root - > key ) ) {
log_error ( " Parse error at byte % " PRIptrdiff_t " (line %d): empty section identifier " ,
p - > tb - p - > fb + 1 , p - > line ) ;
return NULL ;
}
2011-08-30 18:55:15 +04:00
if ( p - > t = = TOK_SECTION_B ) {
match ( TOK_SECTION_B ) ;
while ( p - > t ! = TOK_SECTION_E ) {
if ( ! ( n = _section ( p ) ) )
2011-09-25 23:38:59 +04:00
return_NULL ;
2011-08-30 18:55:15 +04:00
2011-09-25 23:41:27 +04:00
if ( ! l )
2011-08-30 18:55:15 +04:00
root - > child = n ;
else
l - > sib = n ;
n - > parent = root ;
l = n ;
}
match ( TOK_SECTION_E ) ;
} else {
match ( TOK_EQ ) ;
if ( ! ( root - > v = _value ( p ) ) )
2011-09-25 23:38:59 +04:00
return_NULL ;
2011-08-30 18:55:15 +04:00
}
return root ;
}
static struct dm_config_value * _value ( struct parser * p )
{
/* '[' TYPE* ']' | TYPE */
struct dm_config_value * h = NULL , * l , * ll = NULL ;
if ( p - > t = = TOK_ARRAY_B ) {
match ( TOK_ARRAY_B ) ;
while ( p - > t ! = TOK_ARRAY_E ) {
if ( ! ( l = _type ( p ) ) )
2011-09-25 23:38:59 +04:00
return_NULL ;
2011-08-30 18:55:15 +04:00
if ( ! h )
h = l ;
else
ll - > next = l ;
ll = l ;
if ( p - > t = = TOK_COMMA )
match ( TOK_COMMA ) ;
}
match ( TOK_ARRAY_E ) ;
/*
* Special case for an empty array .
*/
if ( ! h ) {
2011-09-25 23:43:43 +04:00
if ( ! ( h = _create_value ( p - > mem ) ) ) {
log_error ( " Failed to allocate value " ) ;
return NULL ;
}
2011-08-30 18:55:15 +04:00
h - > type = DM_CFG_EMPTY_ARRAY ;
}
} else
2011-09-25 23:42:45 +04:00
if ( ! ( h = _type ( p ) ) )
return_NULL ;
2011-08-30 18:55:15 +04:00
return h ;
}
static struct dm_config_value * _type ( struct parser * p )
{
/* [+-]{0,1}[0-9]+ | [0-9]*\.[0-9]* | ".*" */
struct dm_config_value * v = _create_value ( p - > mem ) ;
char * str ;
2011-09-25 23:43:43 +04:00
if ( ! v ) {
log_error ( " Failed to allocate type value " ) ;
2011-08-30 18:55:15 +04:00
return NULL ;
2011-09-25 23:43:43 +04:00
}
2011-08-30 18:55:15 +04:00
switch ( p - > t ) {
case TOK_INT :
v - > type = DM_CFG_INT ;
v - > v . i = strtoll ( p - > tb , NULL , 0 ) ; /* FIXME: check error */
match ( TOK_INT ) ;
break ;
case TOK_FLOAT :
v - > type = DM_CFG_FLOAT ;
2011-09-02 01:04:14 +04:00
v - > v . f = strtod ( p - > tb , NULL ) ; /* FIXME: check error */
2011-08-30 18:55:15 +04:00
match ( TOK_FLOAT ) ;
break ;
case TOK_STRING :
v - > type = DM_CFG_STRING ;
2013-02-01 14:07:44 +04:00
if ( ! ( v - > v . str = _dup_string_tok ( p ) ) )
2011-09-25 23:38:59 +04:00
return_NULL ;
2013-02-01 14:07:44 +04:00
2011-08-30 18:55:15 +04:00
match ( TOK_STRING ) ;
break ;
case TOK_STRING_ESCAPED :
v - > type = DM_CFG_STRING ;
2013-02-01 14:07:44 +04:00
if ( ! ( str = _dup_string_tok ( p ) ) )
2011-09-25 23:38:59 +04:00
return_NULL ;
2011-08-30 18:55:15 +04:00
dm_unescape_double_quotes ( str ) ;
v - > v . str = str ;
match ( TOK_STRING_ESCAPED ) ;
break ;
default :
log_error ( " Parse error at byte % " PRIptrdiff_t " (line %d): expected a value " ,
p - > tb - p - > fb + 1 , p - > line ) ;
2011-09-25 23:38:59 +04:00
return NULL ;
2011-08-30 18:55:15 +04:00
}
return v ;
}
static int _match_aux ( struct parser * p , int t )
{
if ( p - > t ! = t )
return 0 ;
_get_token ( p , t ) ;
return 1 ;
}
/*
* tokeniser
*/
static void _get_token ( struct parser * p , int tok_prev )
{
int values_allowed = 0 ;
const char * te ;
p - > tb = p - > te ;
_eat_space ( p ) ;
if ( p - > tb = = p - > fe | | ! * p - > tb ) {
p - > t = TOK_EOF ;
return ;
}
/* 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 ;
p - > t = TOK_INT ; /* fudge so the fall through for
floats works */
te = p - > te ;
switch ( * te ) {
case SECTION_B_CHAR :
p - > t = TOK_SECTION_B ;
te + + ;
break ;
case SECTION_E_CHAR :
p - > t = TOK_SECTION_E ;
te + + ;
break ;
case ' [ ' :
p - > t = TOK_ARRAY_B ;
te + + ;
break ;
case ' ] ' :
p - > t = TOK_ARRAY_E ;
te + + ;
break ;
case ' , ' :
p - > t = TOK_COMMA ;
te + + ;
break ;
case ' = ' :
p - > t = TOK_EQ ;
te + + ;
break ;
case ' " ' :
p - > t = TOK_STRING_ESCAPED ;
te + + ;
while ( ( te ! = p - > fe ) & & ( * te ) & & ( * te ! = ' " ' ) ) {
if ( ( * te = = ' \\ ' ) & & ( te + 1 ! = p - > fe ) & &
* ( te + 1 ) )
te + + ;
te + + ;
}
if ( ( te ! = p - > fe ) & & ( * te ) )
te + + ;
break ;
case ' \' ' :
p - > t = TOK_STRING ;
te + + ;
while ( ( te ! = p - > fe ) & & ( * te ) & & ( * te ! = ' \' ' ) )
te + + ;
if ( ( te ! = p - > fe ) & & ( * te ) )
te + + ;
break ;
case ' . ' :
p - > t = TOK_FLOAT ;
/* Fall through */
case ' 0 ' :
case ' 1 ' :
case ' 2 ' :
case ' 3 ' :
case ' 4 ' :
case ' 5 ' :
case ' 6 ' :
case ' 7 ' :
case ' 8 ' :
case ' 9 ' :
case ' + ' :
case ' - ' :
if ( values_allowed ) {
while ( + + te ! = p - > fe ) {
if ( ! isdigit ( ( int ) * te ) ) {
if ( * te = = ' . ' ) {
if ( p - > t ! = TOK_FLOAT ) {
p - > t = TOK_FLOAT ;
continue ;
}
}
break ;
}
}
break ;
}
/* fall through */
default :
p - > t = TOK_IDENTIFIER ;
while ( ( te ! = p - > fe ) & & ( * te ) & & ! isspace ( * te ) & &
( * te ! = ' # ' ) & & ( * te ! = ' = ' ) & &
( * te ! = SECTION_B_CHAR ) & &
( * te ! = SECTION_E_CHAR ) )
te + + ;
break ;
}
p - > te = te ;
}
static void _eat_space ( struct parser * p )
{
while ( p - > tb ! = p - > fe ) {
if ( * p - > te = = ' # ' )
while ( ( p - > te ! = p - > fe ) & & ( * p - > te ! = ' \n ' ) & & ( * p - > te ) )
+ + p - > te ;
else if ( ! isspace ( * p - > te ) )
break ;
while ( ( p - > te ! = p - > fe ) & & isspace ( * p - > te ) ) {
if ( * p - > te = = ' \n ' )
+ + p - > line ;
+ + p - > te ;
}
p - > tb = p - > te ;
}
}
/*
* memory management
*/
static struct dm_config_value * _create_value ( struct dm_pool * mem )
{
return dm_pool_zalloc ( mem , sizeof ( struct dm_config_value ) ) ;
}
static struct dm_config_node * _create_node ( struct dm_pool * mem )
{
return dm_pool_zalloc ( mem , sizeof ( struct dm_config_node ) ) ;
}
static char * _dup_tok ( struct parser * p )
{
size_t len = p - > te - p - > tb ;
char * str = dm_pool_alloc ( p - > mem , len + 1 ) ;
if ( ! str ) {
log_error ( " Failed to duplicate token. " ) ;
return 0 ;
}
memcpy ( str , p - > tb , len ) ;
str [ len ] = ' \0 ' ;
return str ;
}
/*
2011-09-02 01:04:14 +04:00
* Utility functions
*/
/*
* node_lookup_fn is either :
* _find_config_node to perform a lookup starting from a given config_node
* in a config_tree ;
* or
* _find_first_config_node to find the first config_node in a set of
* cascaded trees .
2011-08-30 18:55:15 +04:00
*/
2011-09-02 01:04:14 +04:00
typedef const struct dm_config_node * node_lookup_fn ( const void * start , const char * path ) ;
2011-09-01 18:02:05 +04:00
static const struct dm_config_node * _find_config_node ( const void * start ,
const char * path )
2011-08-30 18:55:15 +04:00
{
const char * e ;
const struct dm_config_node * cn = start ;
const struct dm_config_node * cn_found = NULL ;
while ( cn ) {
/* trim any leading slashes */
while ( * path & & ( * path = = sep ) )
path + + ;
/* find the end of this segment */
for ( e = path ; * e & & ( * e ! = sep ) ; e + + ) ;
/* hunt for the node */
cn_found = NULL ;
while ( cn ) {
if ( _tok_match ( cn - > key , path , e ) ) {
/* Inefficient */
if ( ! cn_found )
cn_found = cn ;
else
log_warn ( " WARNING: Ignoring duplicate "
" config node: %s ( "
" seeking %s) " , cn - > key , path ) ;
}
cn = cn - > sib ;
}
if ( cn_found & & * e )
cn = cn_found - > child ;
else
2013-02-27 16:47:57 +04:00
return cn_found ;
2011-08-30 18:55:15 +04:00
path = e ;
}
2013-02-27 16:47:57 +04:00
return NULL ;
2011-08-30 18:55:15 +04:00
}
2011-09-01 18:02:05 +04:00
static const struct dm_config_node * _find_first_config_node ( const void * start , const char * path )
2011-08-30 18:55:15 +04:00
{
const struct dm_config_tree * cft = start ;
2011-09-01 18:02:05 +04:00
const struct dm_config_node * cn = NULL ;
2011-08-30 18:55:15 +04:00
while ( cft ) {
if ( ( cn = _find_config_node ( cft - > root , path ) ) )
return cn ;
cft = cft - > cascade ;
}
return NULL ;
}
2011-09-02 01:04:14 +04:00
static const char * _find_config_str ( const void * start , node_lookup_fn find_fn ,
2011-10-29 00:06:49 +04:00
const char * path , const char * fail , int allow_empty )
2011-08-30 18:55:15 +04:00
{
2011-09-02 01:04:14 +04:00
const struct dm_config_node * n = find_fn ( start , path ) ;
2011-08-30 18:55:15 +04:00
2012-02-28 21:46:47 +04:00
/* Empty strings are ignored if allow_empty is set */
if ( n & & n - > v ) {
if ( ( n - > v - > type = = DM_CFG_STRING ) & &
( allow_empty | | ( * n - > v - > v . str ) ) ) {
log_very_verbose ( " Setting %s to %s " , path , n - > v - > v . str ) ;
return n - > v - > v . str ;
}
if ( ( n - > v - > type ! = DM_CFG_STRING ) | | ( ! allow_empty & & fail ) )
log_warn ( " WARNING: Ignoring unsupported value for %s. " , path ) ;
}
2011-08-30 18:55:15 +04:00
if ( fail )
log_very_verbose ( " %s not found in config: defaulting to %s " ,
path , fail ) ;
return fail ;
}
const char * dm_config_find_str ( const struct dm_config_node * cn ,
const char * path , const char * fail )
{
2011-10-29 00:06:49 +04:00
return _find_config_str ( cn , _find_config_node , path , fail , 0 ) ;
2011-08-30 18:55:15 +04:00
}
2011-12-21 16:47:44 +04:00
const char * dm_config_find_str_allow_empty ( const struct dm_config_node * cn ,
const char * path , const char * fail )
{
return _find_config_str ( cn , _find_config_node , path , fail , 1 ) ;
}
2011-09-02 01:04:14 +04:00
static int64_t _find_config_int64 ( const void * start , node_lookup_fn find ,
2011-08-30 18:55:15 +04:00
const char * path , int64_t fail )
{
const struct dm_config_node * n = find ( start , path ) ;
if ( n & & n - > v & & n - > v - > type = = DM_CFG_INT ) {
log_very_verbose ( " Setting %s to % " PRId64 , path , n - > v - > v . i ) ;
return n - > v - > v . i ;
}
log_very_verbose ( " %s not found in config: defaulting to % " PRId64 ,
path , fail ) ;
return fail ;
}
2011-09-02 01:04:14 +04:00
static float _find_config_float ( const void * start , node_lookup_fn find ,
2011-08-30 18:55:15 +04:00
const char * path , float fail )
{
const struct dm_config_node * n = find ( start , path ) ;
if ( n & & n - > v & & n - > v - > type = = DM_CFG_FLOAT ) {
2011-09-02 01:04:14 +04:00
log_very_verbose ( " Setting %s to %f " , path , n - > v - > v . f ) ;
return n - > v - > v . f ;
2011-08-30 18:55:15 +04:00
}
log_very_verbose ( " %s not found in config: defaulting to %f " ,
path , fail ) ;
return fail ;
}
static int _str_in_array ( const char * str , const char * const values [ ] )
{
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 )
{
const char * const _true_values [ ] = { " y " , " yes " , " on " , " true " , NULL } ;
const char * const _false_values [ ] = { " n " , " no " , " off " , " false " , NULL } ;
if ( _str_in_array ( str , _true_values ) )
return 1 ;
if ( _str_in_array ( str , _false_values ) )
return 0 ;
return fail ;
}
2011-09-02 01:04:14 +04:00
static int _find_config_bool ( const void * start , node_lookup_fn find ,
2011-08-30 18:55:15 +04:00
const char * path , int fail )
{
const struct dm_config_node * n = find ( start , path ) ;
const struct dm_config_value * v ;
2012-05-08 18:31:44 +04:00
int b ;
if ( n ) {
v = n - > v ;
switch ( v - > type ) {
case DM_CFG_INT :
b = v - > v . i ? 1 : 0 ;
log_very_verbose ( " Setting %s to %d " , path , b ) ;
return b ;
case DM_CFG_STRING :
b = _str_to_bool ( v - > v . str , fail ) ;
log_very_verbose ( " Setting %s to %d " , path , b ) ;
return b ;
default :
;
}
2011-08-30 18:55:15 +04:00
}
2012-05-08 18:31:44 +04:00
log_very_verbose ( " %s not found in config: defaulting to %d " ,
path , fail ) ;
2011-08-30 18:55:15 +04:00
return fail ;
}
/***********************************
* node - based lookup
* */
2012-01-23 21:47:36 +04:00
struct dm_config_node * dm_config_find_node ( const struct dm_config_node * cn ,
2011-08-31 16:39:58 +04:00
const char * path )
2011-08-30 18:55:15 +04:00
{
2011-09-01 18:02:05 +04:00
return ( struct dm_config_node * ) _find_config_node ( cn , path ) ;
2011-08-30 18:55:15 +04:00
}
int dm_config_find_int ( const struct dm_config_node * cn , const char * path , int fail )
{
/* FIXME Add log_error message on overflow */
return ( int ) _find_config_int64 ( cn , _find_config_node , path , ( int64_t ) fail ) ;
}
2012-03-01 23:54:53 +04:00
int64_t dm_config_find_int64 ( const struct dm_config_node * cn , const char * path , int64_t fail )
{
return _find_config_int64 ( cn , _find_config_node , path , fail ) ;
}
2011-08-30 18:55:15 +04:00
float dm_config_find_float ( const struct dm_config_node * cn , const char * path ,
float fail )
{
return _find_config_float ( cn , _find_config_node , path , fail ) ;
}
int dm_config_find_bool ( const struct dm_config_node * cn , const char * path , int fail )
{
return _find_config_bool ( cn , _find_config_node , path , fail ) ;
}
2013-03-05 20:10:30 +04:00
int dm_config_value_is_bool ( const struct dm_config_value * v ) {
if ( ! v )
return 0 ;
switch ( v - > type ) {
case DM_CFG_INT :
return 1 ;
case DM_CFG_STRING :
return _str_to_bool ( v - > v . str , - 1 ) ! = - 1 ;
default :
return 0 ;
}
}
2011-08-30 18:55:15 +04:00
/***********************************
* tree - based lookup
* */
const struct dm_config_node * dm_config_tree_find_node ( const struct dm_config_tree * cft ,
const char * path )
{
return _find_first_config_node ( cft , path ) ;
}
const char * dm_config_tree_find_str ( const struct dm_config_tree * cft , const char * path ,
const char * fail )
{
2011-10-29 00:06:49 +04:00
return _find_config_str ( cft , _find_first_config_node , path , fail , 0 ) ;
}
const char * dm_config_tree_find_str_allow_empty ( const struct dm_config_tree * cft , const char * path ,
const char * fail )
{
return _find_config_str ( cft , _find_first_config_node , path , fail , 1 ) ;
2011-08-30 18:55:15 +04:00
}
int dm_config_tree_find_int ( const struct dm_config_tree * cft , const char * path , int fail )
{
/* FIXME Add log_error message on overflow */
return ( int ) _find_config_int64 ( cft , _find_first_config_node , path , ( int64_t ) fail ) ;
}
int64_t dm_config_tree_find_int64 ( const struct dm_config_tree * cft , const char * path , int64_t fail )
{
return _find_config_int64 ( cft , _find_first_config_node , path , fail ) ;
}
float dm_config_tree_find_float ( const struct dm_config_tree * cft , const char * path ,
float fail )
{
return _find_config_float ( cft , _find_first_config_node , path , fail ) ;
}
int dm_config_tree_find_bool ( const struct dm_config_tree * cft , const char * path , int fail )
{
return _find_config_bool ( cft , _find_first_config_node , path , fail ) ;
}
/************************************/
int dm_config_get_uint32 ( const struct dm_config_node * cn , const char * path ,
2011-08-31 19:19:19 +04:00
uint32_t * result )
2011-08-30 18:55:15 +04:00
{
const struct dm_config_node * n ;
2011-08-31 19:19:19 +04:00
n = _find_config_node ( cn , path ) ;
2011-08-30 18:55:15 +04:00
if ( ! n | | ! n - > v | | n - > v - > type ! = DM_CFG_INT )
return 0 ;
2011-12-11 19:18:32 +04:00
if ( result )
* result = n - > v - > v . i ;
2011-08-30 18:55:15 +04:00
return 1 ;
}
int dm_config_get_uint64 ( const struct dm_config_node * cn , const char * path ,
uint64_t * result )
{
const struct dm_config_node * n ;
2011-08-31 19:19:19 +04:00
n = _find_config_node ( cn , path ) ;
2011-08-30 18:55:15 +04:00
if ( ! n | | ! n - > v | | n - > v - > type ! = DM_CFG_INT )
return 0 ;
2011-12-11 19:18:32 +04:00
if ( result )
* result = ( uint64_t ) n - > v - > v . i ;
2011-08-30 18:55:15 +04:00
return 1 ;
}
int dm_config_get_str ( const struct dm_config_node * cn , const char * path ,
const char * * result )
{
const struct dm_config_node * n ;
2011-08-31 19:19:19 +04:00
n = _find_config_node ( cn , path ) ;
2011-08-30 18:55:15 +04:00
if ( ! n | | ! n - > v | | n - > v - > type ! = DM_CFG_STRING )
return 0 ;
2011-12-11 19:18:32 +04:00
if ( result )
* result = n - > v - > v . str ;
2011-08-30 18:55:15 +04:00
return 1 ;
}
2011-08-31 19:19:19 +04:00
int dm_config_get_list ( const struct dm_config_node * cn , const char * path ,
const struct dm_config_value * * result )
{
const struct dm_config_node * n ;
n = _find_config_node ( cn , path ) ;
/* TODO when we represent single-item lists consistently, add a check
* for n - > v - > next ! = NULL */
if ( ! n | | ! n - > v )
return 0 ;
2011-12-11 19:18:32 +04:00
if ( result )
* result = n - > v ;
2011-08-31 19:19:19 +04:00
return 1 ;
}
int dm_config_get_section ( const struct dm_config_node * cn , const char * path ,
const struct dm_config_node * * result )
{
const struct dm_config_node * n ;
n = _find_config_node ( cn , path ) ;
if ( ! n | | n - > v )
return 0 ;
2011-12-11 19:18:32 +04:00
if ( result )
* result = n ;
2011-08-31 19:19:19 +04:00
return 1 ;
}
int dm_config_has_node ( const struct dm_config_node * cn , const char * path )
{
return _find_config_node ( cn , path ) ? 1 : 0 ;
}
2011-08-30 18:55:15 +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 ' .
*/
static unsigned _count_tokens ( const char * str , unsigned len , int type )
{
char c ;
c = _token_type_to_char ( type ) ;
return dm_count_chars ( str , len , c ) ;
}
const char * dm_config_parent_name ( const struct dm_config_node * n )
{
return ( n - > parent ? n - > parent - > key : " (root) " ) ;
}
/*
* 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 dm_config_maybe_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 ) ;
if ( begin_count & & end_count & & ( begin_count = = end_count ) )
return 1 ;
else
return 0 ;
}
2011-09-25 23:45:40 +04:00
__attribute__ ( ( nonnull ( 1 , 2 ) ) )
2011-08-30 18:55:15 +04:00
static struct dm_config_value * _clone_config_value ( struct dm_pool * mem ,
const struct dm_config_value * v )
{
struct dm_config_value * new_cv ;
if ( ! ( new_cv = _create_value ( mem ) ) ) {
log_error ( " Failed to clone config value. " ) ;
return NULL ;
}
new_cv - > type = v - > type ;
if ( v - > type = = DM_CFG_STRING ) {
if ( ! ( new_cv - > v . str = dm_pool_strdup ( mem , v - > v . str ) ) ) {
log_error ( " Failed to clone config string value. " ) ;
return NULL ;
}
} else
new_cv - > v = v - > v ;
if ( v - > next & & ! ( new_cv - > next = _clone_config_value ( mem , v - > next ) ) )
return_NULL ;
return new_cv ;
}
struct dm_config_node * dm_config_clone_node_with_mem ( struct dm_pool * mem , const struct dm_config_node * cn , int siblings )
{
struct dm_config_node * new_cn ;
2011-09-25 23:43:43 +04:00
if ( ! cn ) {
log_error ( " Cannot clone NULL config node. " ) ;
2011-08-30 18:55:15 +04:00
return NULL ;
2011-09-25 23:43:43 +04:00
}
2011-08-30 18:55:15 +04:00
if ( ! ( new_cn = _create_node ( mem ) ) ) {
log_error ( " Failed to clone config node. " ) ;
return NULL ;
}
if ( ( cn - > key & & ! ( new_cn - > key = dm_pool_strdup ( mem , cn - > key ) ) ) ) {
log_error ( " Failed to clone config node key. " ) ;
return NULL ;
}
if ( ( cn - > v & & ! ( new_cn - > v = _clone_config_value ( mem , cn - > v ) ) ) | |
( cn - > child & & ! ( new_cn - > child = dm_config_clone_node_with_mem ( mem , cn - > child , 1 ) ) ) | |
( siblings & & cn - > sib & & ! ( new_cn - > sib = dm_config_clone_node_with_mem ( mem , cn - > sib , siblings ) ) ) )
return_NULL ; /* 'new_cn' released with mem pool */
return new_cn ;
}
struct dm_config_node * dm_config_clone_node ( struct dm_config_tree * cft , const struct dm_config_node * node , int sib )
{
2011-12-19 01:56:03 +04:00
return dm_config_clone_node_with_mem ( cft - > mem , node , sib ) ;
2011-08-30 18:55:15 +04:00
}
struct dm_config_node * dm_config_create_node ( struct dm_config_tree * cft , const char * key )
{
struct dm_config_node * cn ;
2011-12-19 01:56:03 +04:00
if ( ! ( cn = _create_node ( cft - > mem ) ) ) {
2011-08-30 18:55:15 +04:00
log_error ( " Failed to create config node. " ) ;
return NULL ;
}
2011-12-19 01:56:03 +04:00
if ( ! ( cn - > key = dm_pool_strdup ( cft - > mem , key ) ) ) {
2011-08-30 18:55:15 +04:00
log_error ( " Failed to create config node's key. " ) ;
return NULL ;
}
cn - > parent = NULL ;
2012-08-27 16:19:30 +04:00
cn - > v = NULL ;
2011-08-30 18:55:15 +04:00
return cn ;
}
struct dm_config_value * dm_config_create_value ( struct dm_config_tree * cft )
{
2011-12-19 01:56:03 +04:00
return _create_value ( cft - > mem ) ;
2011-08-30 18:55:15 +04:00
}
struct dm_pool * dm_config_memory ( struct dm_config_tree * cft )
{
2011-12-19 01:56:03 +04:00
return cft - > mem ;
2011-08-30 18:55:15 +04:00
}