mangavalk/lcdproc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

more/better error checks, harmonized coding style

Browse Source
This commit is contained in:
marschap
2006-04-26 18:02:25 +00:00
parent 31b9ed6ef1
commit 1aff9c4226
1 changed files with 270 additions and 271 deletions
Download Patch File Download Diff File Expand all files Collapse all files
shared/configfile.c
+270 -271
View File
@@ -5,12 +5,12 @@
* This file is released under the GNU General Public License. Refer to the
* COPYING file distributed with this package.
*
* Copyright (c) 2001, Joris Robijn
* (c) 2003, Rene Wagner
* Copyright(c) 2001, Joris Robijn
* (c) 2003, Rene Wagner
*
*
* Defines routines to read ini-file-like files.
* Optionally retrieves settings from an LDAP directory (OpenLDAP 2.1.x)
* Optionally retrieves settings from an LDAP directory(OpenLDAP 2.1.x)
*/
#include "config.h"
@@ -29,15 +29,15 @@
typedef struct key {
char * name;
char * value;
struct key * next_key;
char *name;
char *value;
struct key *next_key;
} key;
typedef struct section {
char * name;
key * first_key;
struct section * next_section;
char *name;
key *first_key;
struct section *next_section;
} section;
@@ -45,20 +45,21 @@ static section * first_section = NULL;
/* Yes there is a static. It's C after all :)*/
section * find_section( char * sectionname );
section * add_section( char * sectionname );
key * find_key( section * s, char * keyname, int skip );
key * add_key( section * s, char * keyname, char * value );
section * find_section(char * sectionname);
section * add_section(char * sectionname);
key * find_key(section * s, char * keyname, int skip);
key * add_key(section * s, char * keyname, char * value);
char get_next_char_f(buffile * f);
int process_config( section ** current_section, char (*get_next_char)(), char modify_section_allowed, char * source_descr, buffile * f );
int process_config(section ** current_section, char(*get_next_char)(), char modify_section_allowed, char * source_descr, buffile * f);
#ifdef WITH_LDAP_SUPPORT
int connect_to_ldap(void);
static LDAP * ld = NULL;
int use_ldap=0;
int use_ldap = 0;
static char * ldap_host=NULL, * ldap_base_dn=NULL;
static char * ldap_host = NULL, * ldap_base_dn = NULL;
int ldap_port;
/* not supported for now
@@ -67,92 +68,89 @@ int ldap_port;
*/
#endif /* WITH_LDAP_SUPPORT */
/**** EXTERNAL FUNCTIONS ****/
int config_read_file( char *filename )
int config_read_file(char *filename)
{
buffile * f;
section * curr_section = NULL;
buffile *f;
section *curr_section = NULL;
#ifdef WITH_LDAP_SUPPORT
LDAPURLDesc * url = NULL;
LDAPURLDesc *url = NULL;
int retval;
#endif /* WITH_LDAP_SUPPORT */
report( RPT_NOTICE, "Using Configuration File: %s", filename);
report(RPT_NOTICE, "Using Configuration File: %s", filename);
#ifdef WITH_LDAP_SUPPORT
if (ldap_is_ldap_url( filename )) {
use_ldap=1;
if (ldap_is_ldap_url(filename)) {
use_ldap = 1;
if (0 != (retval = ldap_url_parse( filename, &url))) {
report( RPT_ERR, "Errors parsing LDAP URL %s: %s", filename, ldap_err2string(retval));
if (0 != (retval = ldap_url_parse(filename, &url))) {
report(RPT_ERR, "Errors parsing LDAP URL %s: %s", filename, ldap_err2string(retval));
ldap_free_urldesc(url);
return (-1);
return(-1);
}
ldap_host=strdup(url->lud_host);
ldap_port=url->lud_port;
report( RPT_INFO, "Using LDAP server: %s:%d", ldap_host, ldap_port);
ldap_host = strdup(url->lud_host);
ldap_port = url->lud_port;
report(RPT_INFO, "Using LDAP server: %s:%d", ldap_host, ldap_port);
ldap_base_dn=strdup(url->lud_dn);
report( RPT_INFO, "Using LDAP base DN: %s", ldap_base_dn);
ldap_base_dn = strdup(url->lud_dn);
report(RPT_INFO, "Using LDAP base DN: %s", ldap_base_dn);
ldap_free_urldesc(url);
if (connect_to_ldap() < 0 ) {
debug( RPT_DEBUG, "connect_to_ldap returned errors.");
return (-1);
if (connect_to_ldap() < 0) {
debug(RPT_DEBUG, "connect_to_ldap returned errors.");
return(-1);
}
return 0;
}
#endif /* WITH_LDAP_SUPPORT */
f = buffile_open( filename, "r" );
if( f==NULL ) {
f = buffile_open(filename, "r");
if (f == NULL) {
return -1;
}
process_config( &curr_section, get_next_char_f, 1, filename, f );
process_config(&curr_section, get_next_char_f, 1, filename, f);
buffile_close( f );
buffile_close(f);
return 0;
}
int config_read_string( char *sectionname, char *str )
int config_read_string(char *sectionname, char *str)
/* All the config parameters are placed in the given section in memory.*/
{
int pos=0;
section * s;
int pos = 0;
section *s;
/* We use a nested fuction to transfer the characters from buffer to parser*/
char get_next_char() {
return str[pos++];
}
if( !( s=find_section( sectionname ))) {
s=add_section( sectionname );
}
if ((s = find_section(sectionname)) == NULL)
s = add_section(sectionname);
process_config( &s, get_next_char, 0, "command line", NULL );
process_config(&s, get_next_char, 0, "command line", NULL);
return 0;
}
char *config_get_string( char * sectionname, char * keyname,
int skip, char * default_value )
char *config_get_string(char * sectionname, char * keyname,
int skip, char * default_value)
{
section * s;
key * k;
key *k = find_key(find_section(sectionname), keyname, skip);
s = find_section( sectionname );
if( !s ) return default_value;
k = find_key( s, keyname, skip );
if( !k ) return default_value;
if (k == NULL)
return default_value;
return k->value;
@@ -160,106 +158,87 @@ char *config_get_string( char * sectionname, char * keyname,
/* Reallocate memory space for the return value*/
/*
string_storage = realloc( string_storage, ( strlen( k->value ) / 256 + 1) * 256 );
strcpy( string_storage, k->value );
string_storage = realloc(string_storage,(strlen(k->value) / 256 + 1) * 256);
strcpy(string_storage, k->value);
But then you also need a global static string_storage = NULL;
*/
}
short config_get_bool( char *sectionname, char *keyname,
int skip, short default_value )
short config_get_bool(char *sectionname, char *keyname,
int skip, short default_value)
{
section * s;
key * k;
key *k = find_key(find_section(sectionname), keyname, skip);
s = find_section( sectionname );
if( !s ) return default_value;
k = find_key( s, keyname, skip );
if( !k ) return default_value;
if (k == NULL)
return default_value;
if( strcasecmp( k->value, "0" )==0 || strcasecmp( k->value, "false" )==0
|| strcasecmp( k->value, "n" )==0 || strcasecmp( k->value, "no" )==0 ) {
if (strcasecmp(k->value, "0") == 0 || strcasecmp(k->value, "false") == 0
|| strcasecmp(k->value, "n") == 0 || strcasecmp(k->value, "no") == 0) {
return 0;
}
if( strcasecmp( k->value, "1" )==0 || strcasecmp( k->value, "true" )==0
|| strcasecmp( k->value, "y" )==0 || strcasecmp( k->value, "yes" )==0 ) {
if (strcasecmp(k->value, "1") == 0 || strcasecmp(k->value, "true") == 0
|| strcasecmp(k->value, "y") == 0 || strcasecmp(k->value, "yes") == 0) {
return 1;
}
return default_value;
}
long int config_get_int( char *sectionname, char *keyname,
int skip, long int default_value )
long int config_get_int(char *sectionname, char *keyname,
int skip, long int default_value)
{
section * s;
key * k;
long int v;
char * v_end;
key *k = find_key(find_section(sectionname), keyname, skip);
s = find_section( sectionname );
if( !s ) return default_value;
k = find_key( s, keyname, skip );
if( !k ) return default_value;
if (k != NULL) {
char *end;
long int v = strtol(k->value, &end, 0);
v = strtol( k->value, &v_end, 0 );
if( v_end-(k->value) != strlen(k->value) ) {
/* Conversion not succesful*/
return default_value;
if ((end != NULL) && (end != k->value) && (*end == '\0'))
/* Conversion succesful*/
return v;
}
return v;
return default_value;
}
double config_get_float( char *sectionname, char *keyname,
int skip, double default_value )
double config_get_float(char *sectionname, char *keyname,
int skip, double default_value)
{
section * s;
key * k;
double v;
char * v_end;
key *k = find_key(find_section(sectionname), keyname, skip);
s = find_section( sectionname );
if( !s ) return default_value;
k = find_key( s, keyname, skip );
if( !k ) return default_value;
if (k != NULL) {
char *end;
double v = strtod(k->value, &end);
v = strtod( k->value, &v_end );
if( v_end-(k->value) != strlen(k->value) ) {
/* Conversion not succesful*/
return default_value;
if ((end != NULL) && (end != k->value) && (*end == '\0'))
/* Conversion succesful*/
return v;
}
return v;
return default_value;
}
int config_has_section( char *sectionname )
int config_has_section(char *sectionname)
{
section * s;
s = find_section( sectionname );
if( s ) return 1; else return 0;
return (find_section(sectionname) != NULL) ? 1 : 0;
}
int config_has_key( char *sectionname, char *keyname )
int config_has_key(char *sectionname, char *keyname)
{
section * s;
key * k;
section *s = find_section(sectionname);
int count = 0;
s = find_section( sectionname );
if( !s ) return 0;
if (s != NULL) {
key *k;
for( k=s->first_key; k; k=k->next_key ) {
/* Did we find the right key ?*/
if( strcasecmp( k->name, keyname ) == 0 ) {
count ++;
}
for (k = s->first_key; k != NULL; k = k->next_key) {
/* Did we find the right key ?*/
if (strcasecmp(k->name, keyname) == 0)
count++;
}
}
return count;
}
@@ -267,32 +246,29 @@ int config_has_key( char *sectionname, char *keyname )
void config_clear()
{
section * s;
section * next_s;
key * k;
key * next_k;
section *s;
section *next_s;
for( s = first_section; s; ) {
for( k=s->first_key; k; ) {
for (s = first_section; s != NULL; s = next_s) {
key *k;
key *next_k;
for (k = s->first_key; k != NULL; k = next_k) {
/* Advance before we destroy the current key */
next_k = k->next_key;
free( k->name );
free( k->value );
free( k );
k = next_k;
free(k->name);
free(k->value);
free(k);
}
/* Advance before we destroy the current section */
next_s = s->next_section;
/* And destroy it */
free( s->name );
free( s );
s = next_s;
free(s->name);
free(s);
}
/* And make everything inaccessable */
/* Finally make everything inaccessable */
first_section = NULL;
}
@@ -301,156 +277,161 @@ void config_clear()
#ifdef WITH_LDAP_SUPPORT
int
connect_to_ldap (void)
connect_to_ldap(void)
{
int retval;
LDAPMessage * res;
LDAPMessage *res;
debug( RPT_INFO, "Connecting to LDAP server: %s:%d", ldap_host, ldap_port);
debug(RPT_INFO, "Connecting to LDAP server: %s:%d", ldap_host, ldap_port);
if (!(ld = ldap_init(ldap_host, ldap_port))) {
report(RPT_ERR, "LDAP session could not be initialized.");
return (-1);
return(-1);
}
/*****************************************************
* disabled unless you really have a DN/pwd to bind to
* WARNING: LCDd should not have LDAP write access!!
*
* if (LDAP_SUCCESS != (retval = ldap_simple_bind_s (ld, ldap_user, ldap_pwd))) {
* report (RPT_ERR, "LDAP login on %s:%d failed: %s", ldap_host, ldap_port, ldap_err2string (retval));
* ldap_unbind (ld);
* if (LDAP_SUCCESS != (retval = ldap_simple_bind_s(ld, ldap_user, ldap_pwd))) {
* report(RPT_ERR, "LDAP login on %s:%d failed: %s", ldap_host, ldap_port, ldap_err2string(retval));
* ldap_unbind(ld);
* ld = NULL;
*
* return (-1);
* return(-1);
* }
* fprintf(stderr, "LDAP login successful on %s:%d\n", ldap_host, ldap_port);
********************************************************/
/* check for the existence of the config object... */
if (LDAP_SUCCESS != (retval = ldap_search_s (ld, ldap_base_dn, LDAP_SCOPE_BASE, "objectClass=lcdprocConfig", NULL, 0, &res))) {
report( RPT_ERR, "Could not access LDAP server on %s:%d", ldap_host, ldap_port);
return (-1);
if (LDAP_SUCCESS != (retval = ldap_search_s(ld, ldap_base_dn, LDAP_SCOPE_BASE, "objectClass=lcdprocConfig", NULL, 0, &res))) {
report(RPT_ERR, "Could not access LDAP server on %s:%d", ldap_host, ldap_port);
return(-1);
}
if (0 == ldap_count_entries(ld, res)) {
report( RPT_ERR, "No configuration object found in LDAP at: %s", ldap_base_dn);
return (-1);
report(RPT_ERR, "No configuration object found in LDAP at: %s", ldap_base_dn);
return(-1);
}
debug( RPT_DEBUG, "Configuration LDAP object found.");
debug(RPT_DEBUG, "Configuration LDAP object found.");
return 0;
}
#define BUFSIZE 255
#endif /* WITH_LDAP_SUPPORT */
section * find_section( char * sectionname )
section * find_section(char * sectionname)
{
section * s;
section *s;
#ifdef WITH_LDAP_SUPPORT
LDAPMessage * res;
LDAPMessage *res;
int retval;
char *filter=NULL;
char *filter = NULL;
if (use_ldap) {
debug( RPT_DEBUG, "Searching LDAP for section [%s]", sectionname);
debug(RPT_DEBUG, "Searching LDAP for section [%s]", sectionname);
if (NULL == (filter = malloc(BUFSIZE))){
report( RPT_ERR, "Could not allocate memory in find_section()");
report(RPT_ERR, "Could not allocate memory in find_section()");
return NULL;
}
strcpy(filter, "cn=");
strncat(filter, sectionname, BUFSIZE);
if (LDAP_SUCCESS != (retval = ldap_search_s (ld, ldap_base_dn, LDAP_SCOPE_ONELEVEL, filter, NULL, 0, &res))) {
if (LDAP_SUCCESS != (retval = ldap_search_s(ld, ldap_base_dn, LDAP_SCOPE_ONELEVEL, filter, NULL, 0, &res))) {
if (NULL != filter) {
free(filter);
filter=NULL;
filter = NULL;
}
ldap_msgfree(res);
report( RPT_ERR, "Could not access LDAP server on %s:%d", ldap_host, ldap_port);
report(RPT_ERR, "Could not access LDAP server on %s:%d", ldap_host, ldap_port);
return NULL;
}
if (NULL != filter) {
free(filter);
filter=NULL;
filter = NULL;
}
if (0 == ldap_count_entries( ld, res )) {
debug( RPT_DEBUG, "Section [%s] not found in LDAP.", sectionname);
if (0 == ldap_count_entries(ld, res)) {
debug(RPT_DEBUG, "Section [%s] not found in LDAP.", sectionname);
return NULL;
}
ldap_msgfree(res);
debug( RPT_DEBUG, "Found section [%s] in LDAP", sectionname);
s = (section*) malloc( sizeof( section ));
s->name=strdup( sectionname );
s->first_key = NULL;
s->next_section = NULL;
debug(RPT_DEBUG, "Found section [%s] in LDAP", sectionname);
s = (section*) malloc(sizeof(section));
if (s != NULL) {
s->name = strdup(sectionname);
s->first_key = NULL;
s->next_section = NULL;
}
return s;
}
#endif /* WITH_LDAP_SUPPORT */
for( s=first_section; s; s=s->next_section ) {
if( strcasecmp( s->name, sectionname ) == 0 ) {
for (s = first_section; s != NULL; s = s->next_section) {
if (strcasecmp(s->name, sectionname) == 0) {
return s;
}
}
return NULL; /* not found*/
return NULL; /* not found */
}
section * add_section( char * sectionname )
section * add_section(char * sectionname)
{
section *s;
section ** place = &first_section;
section **place = &first_section;
for( s=first_section; s; s=s->next_section )
for (s = first_section; s != NULL; s = s->next_section)
place = &(s->next_section);
*place = (section*) malloc( sizeof( section ));
(*place)->name = strdup( sectionname );
(*place)->first_key = NULL;
(*place)->next_section = NULL;
*place = (section*) malloc(sizeof(section));
if (*place != NULL) {
(*place)->name = strdup(sectionname);
(*place)->first_key = NULL;
(*place)->next_section = NULL;
}
return (*place);
return(*place);
}
key * find_key( section * s, char * keyname, int skip )
key * find_key(section * s, char * keyname, int skip)
{
key * k;
key *k;
int count = 0;
key * last_key = NULL;
key *last_key = NULL;
#ifdef WITH_LDAP_SUPPORT
LDAPMessage * res;
LDAPMessage * entry;
LDAPMessage *res;
LDAPMessage *entry;
int retval;
char *buf=NULL;
char *buf = NULL;
char **vals;
#endif /* WITH_LDAP_SUPPORT */
/* Check for NULL section*/
if(!s) return NULL;
if (s == NULL)
return NULL;
#ifdef WITH_LDAP_SUPPORT
if (use_ldap) {
debug( RPT_DEBUG, "Searching LDAP for key '%s' in section [%s] skipping %d entries.", keyname, s->name, skip);
debug(RPT_DEBUG, "Searching LDAP for key '%s' in section [%s] skipping %d entries.", keyname, s->name, skip);
if (NULL == (buf = malloc(BUFSIZE))){
report (RPT_ERR, "Could not allocate memory in find_key().");
report(RPT_ERR, "Could not allocate memory in find_key().");
}
strcpy(buf, "cn=");
strncat(buf, s->name, BUFSIZE);
if (LDAP_SUCCESS != (retval = ldap_search_s (ld, ldap_base_dn, LDAP_SCOPE_ONELEVEL, buf, NULL, 0, &res))) {
if (LDAP_SUCCESS != (retval = ldap_search_s(ld, ldap_base_dn, LDAP_SCOPE_ONELEVEL, buf, NULL, 0, &res))) {
if (NULL != buf) {
free(buf);
buf=NULL;
}
ldap_msgfree(res);
report( RPT_ERR, "Could not access LDAP server on %s:%d", ldap_host, ldap_port);
report(RPT_ERR, "Could not access LDAP server on %s:%d", ldap_host, ldap_port);
return NULL;
}
if (NULL == (entry = ldap_first_entry( ld, res ))) {
debug( RPT_DEBUG, "Section [%s] not found in LDAP.", s->name);
if (NULL == (entry = ldap_first_entry(ld, res))) {
debug(RPT_DEBUG, "Section [%s] not found in LDAP.", s->name);
if (NULL != buf) {
free(buf);
buf=NULL;
buf = NULL;
}
/* DON'T enable the following
* ldap_msgfree(entry);
@@ -463,14 +444,14 @@ key * find_key( section * s, char * keyname, int skip )
strcpy(buf, "lcdproc");
strncat(buf, keyname, BUFSIZE);
/* debug( RPT_DEBUG, "Key name translated to attribute name: %s", buf); */
vals = ldap_get_values (ld, entry, buf);
/* debug(RPT_DEBUG, "Key name translated to attribute name: %s", buf); */
vals = ldap_get_values(ld, entry, buf);
if (skip+1 > ldap_count_values (vals)) {
debug( RPT_DEBUG, "No such entry found.");
if (skip+1 > ldap_count_values(vals)) {
debug(RPT_DEBUG, "No such entry found.");
if (NULL != buf) {
free(buf);
buf=NULL;
buf = NULL;
}
ldap_value_free(vals);
/* DON'T enable the following
@@ -488,71 +469,78 @@ key * find_key( section * s, char * keyname, int skip )
if (vals && vals[skip]) {
if (NULL != buf) {
free(buf);
buf=NULL;
buf = NULL;
}
buf=strdup(vals[skip]);
debug( RPT_DEBUG, "Entry found. Value is: %s", buf);
ldap_value_free (vals);
debug(RPT_DEBUG, "Entry found. Value is: %s", buf);
ldap_value_free(vals);
k=(key*) malloc( sizeof( key ));
k->name = strdup( keyname );
k->value = strdup( buf );
k->next_key = NULL;
k = (key *) malloc(sizeof(key));
if ( k != NULL) {
k->name = strdup(keyname);
k->value = strdup(buf);
k->next_key = NULL;
}
if (NULL != buf) {
free(buf);
buf=NULL;
buf = NULL;
}
return k;
}
report( RPT_ERR, "LDAP server encountered errors.");
ldap_value_free (vals);
report(RPT_ERR, "LDAP server encountered errors.");
ldap_value_free(vals);
if (NULL != buf) {
free(buf);
buf=NULL;
buf = NULL;
}
return NULL;
}
#endif /* WITH_LDAP_SUPPORT */
for( k=s->first_key; k; k=k->next_key ) {
for (k = s->first_key; k != NULL; k = k->next_key) {
/* Did we find the right key ?*/
if( strcasecmp( k->name, keyname ) == 0 ) {
if( count == skip ) {
if (strcasecmp(k->name, keyname) == 0) {
if (count == skip)
return k;
} else {
count ++;
last_key = k;
}
count++;
last_key = k;
}
}
if( skip == -1 ) {
if (skip == -1)
return last_key;
}
return NULL; /* not found*/
}
key * add_key( section * s, char * keyname, char * value )
key * add_key(section * s, char * keyname, char * value)
{
key * k;
if (s != NULL) {
key *k;
key **place = &(s->first_key);
key ** place = &( s->first_key );
for (k = s->first_key; k != NULL; k = k->next_key)
place = &(k->next_key);
for( k=s->first_key; k; k=k->next_key )
place = &(k->next_key);
*place = (key *) malloc(sizeof(key));
if (*place != NULL) {
(*place)->name = strdup(keyname);
(*place)->value = strdup(value);
(*place)->next_key = NULL;
}
*place = (key*) malloc( sizeof( key ));
(*place)->name = strdup( keyname );
(*place)->value = strdup( value );
(*place)->next_key = NULL;
return (*place);
return(*place);
}
return NULL;
}
char get_next_char_f(buffile * f) {
char get_next_char_f(buffile * f)
{
char * buf = buffile_read(f, 1);
char c = buf[0];
free(buf);
return c;
}
@@ -579,7 +567,7 @@ char get_next_char_f(buffile * f) {
int process_config( section ** current_section, char (*get_next_char)(), char modify_section_allowed, char * source_descr, buffile * f)
int process_config(section ** current_section, char(*get_next_char)(), char modify_section_allowed, char * source_descr, buffile * f)
{
char state = ST_INITIAL;
char ch;
@@ -590,26 +578,22 @@ int process_config( section ** current_section, char (*get_next_char)(), char mo
char value[MAXVALUELENGTH+1];
int value_pos = 0;
int quote = 0;
key * k;
key *k;
int line_nr = 1;
while( state != ST_END ) {
while (state != ST_END) {
if (NULL != f) {
ch = get_next_char(f);
}
else {
ch = get_next_char();
}
ch = (f != NULL)
? get_next_char(f)
: get_next_char();
/* Secretly keep count of the line numbers*/
if( ch == '\n' ) {
line_nr ++;
}
if (ch == '\n')
line_nr++;
switch( state ) {
switch (state) {
case ST_INITIAL:
switch( ch ) {
switch (ch) {
case '\n':
case '\r':
case '\t':
@@ -639,16 +623,17 @@ int process_config( section ** current_section, char (*get_next_char)(), char mo
}
break;
case ST_IGNORE:
switch( ch ) {
switch (ch) {
case '\n':
state = ST_INITIAL;
break;
}
break;
case ST_SECTIONNAME:
switch( ch ) {
switch (ch) {
case '\0':
case '\n':
report( RPT_WARNING, "Section name incorrectly closed on line %d of %s: %s", line_nr, source_descr, sectionname );
report(RPT_WARNING, "Section name incorrectly closed on line %d of %s: %s", line_nr, source_descr, sectionname);
state = ST_INITIAL;
break;
case '\r':
@@ -656,30 +641,27 @@ int process_config( section ** current_section, char (*get_next_char)(), char mo
case ' ':
case '"':
case '[':
report( RPT_WARNING, "Section name contains invalid chars on line %d of %s: %s", line_nr, source_descr, sectionname );
report(RPT_WARNING, "Section name contains invalid chars on line %d of %s: %s", line_nr, source_descr, sectionname);
state = ST_INVALID_SECTIONNAME;
break;
case ']':
if( !( *current_section=find_section( sectionname ))) {
*current_section=add_section( sectionname );
if (!(*current_section=find_section(sectionname))) {
*current_section=add_section(sectionname);
}
state = ST_INITIAL;
break;
case '\0':
report( RPT_WARNING, "Section name incorrectly closed on line %d of %s: %s", line_nr, source_descr, sectionname );
break;
default:
if( sectionname_pos < MAXSECTIONNAMELENGTH ) {
if (sectionname_pos < MAXSECTIONNAMELENGTH) {
sectionname[sectionname_pos++] = ch;
sectionname[sectionname_pos] = '\0';
} else {
report( RPT_WARNING, "Section name too long on line %d of %s: %s", line_nr, source_descr, sectionname );
report(RPT_WARNING, "Section name too long on line %d of %s: %s", line_nr, source_descr, sectionname);
state = ST_INVALID_SECTIONNAME;
}
}
break;
case ST_INVALID_SECTIONNAME:
switch( ch ) {
switch (ch) {
case '\n':
case ']':
state = ST_INITIAL;
@@ -687,19 +669,19 @@ int process_config( section ** current_section, char (*get_next_char)(), char mo
}
break;
case ST_KEYNAME:
switch( ch ) {
switch (ch) {
case '\0':
case '\n':
case '\r':
case '\t':
case ' ':
report( RPT_WARNING, "Loose word found on line %d of %s: %s", line_nr, source_descr, keyname );
report(RPT_WARNING, "Loose word found on line %d of %s: %s", line_nr, source_descr, keyname);
state = ST_INITIAL;
break;
case '"':
case '[':
case ']':
report( RPT_WARNING, "Key name contains invalid characters on line %d of %s: %s", line_nr, source_descr, keyname );
report(RPT_WARNING, "Key name contains invalid characters on line %d of %s: %s", line_nr, source_descr, keyname);
state = ST_INVALID_KEYNAME;
break;
case '=':
@@ -708,8 +690,8 @@ int process_config( section ** current_section, char (*get_next_char)(), char mo
value_pos = 0;
break;
default:
if( keyname_pos>=MAXKEYNAMELENGTH ) {
report( RPT_WARNING, "Key name too long on line %d of %s: %s", line_nr, source_descr, keyname );
if (keyname_pos>=MAXKEYNAMELENGTH) {
report(RPT_WARNING, "Key name too long on line %d of %s: %s", line_nr, source_descr, keyname);
state = ST_INVALID_KEYNAME;
} else {
keyname[keyname_pos++] = ch;
@@ -718,20 +700,20 @@ int process_config( section ** current_section, char (*get_next_char)(), char mo
}
break;
case ST_INVALID_KEYNAME:
switch( ch ) {
switch (ch) {
case '\n':
state = ST_INITIAL;
/*case ' ':*/
}
break;
case ST_VALUE:
switch( ch ) {
switch (ch) {
case '[':
case ']':
case '#':
case ';':
case '=':
report( RPT_WARNING, "Value contains invalid characters on line %d of %s, at key: %s", line_nr, source_descr, keyname );
report(RPT_WARNING, "Value contains invalid characters on line %d of %s, at key: %s", line_nr, source_descr, keyname);
state = ST_INVALID_VALUE;
break;
case '"':
@@ -743,28 +725,28 @@ int process_config( section ** current_section, char (*get_next_char)(), char mo
case '\t':
case ' ':
/* Value complete !*/
if( ! *current_section ) {
report( RPT_WARNING, "Data before any section on line %d of %s with key: %s", line_nr, source_descr, keyname );
if (! *current_section) {
report(RPT_WARNING, "Data before any section on line %d of %s with key: %s", line_nr, source_descr, keyname);
}
else {
/* Store the value*/
k = add_key( *current_section, keyname, value );
k = add_key(*current_section, keyname, value);
}
/* And be ready for next thing...*/
state = ST_INITIAL;
break;
default:
if( value_pos<MAXVALUELENGTH ) {
if (value_pos<MAXVALUELENGTH) {
value[value_pos++] = ch;
value[value_pos] = '\0';
} else {
report( RPT_WARNING, "Value key is too long on line %d of %s, at key: %s", line_nr, source_descr, keyname );
report(RPT_WARNING, "Value key is too long on line %d of %s, at key: %s", line_nr, source_descr, keyname);
state = ST_INVALID_KEYNAME;
}
}
break;
case ST_INVALID_VALUE:
switch( ch ) {
switch (ch) {
case '\n':
state = ST_INITIAL;
break;
@@ -773,25 +755,25 @@ int process_config( section ** current_section, char (*get_next_char)(), char mo
}
break;
case ST_QUOTEDVALUE:
switch( ch ) {
switch (ch) {
case '\0':
case '\n':
report( RPT_WARNING, "String is incorrectly terminated on line %d of %s: %s", line_nr, source_descr, keyname );
report(RPT_WARNING, "String is incorrectly terminated on line %d of %s: %s", line_nr, source_descr, keyname);
state = ST_INITIAL;
break;
case '\\':
if( !quote ) {
if (!quote) {
quote = 1;
break;
}
case '"':
if( !quote ) {
if (!quote) {
state = ST_VALUE;
break;
}
default:
if( quote ) {
switch( ch ) {
if (quote) {
switch (ch) {
case 'n': ch = '\n'; break;
case 'r': ch = '\r'; break;
case 't': ch = '\t'; break;
@@ -804,7 +786,7 @@ int process_config( section ** current_section, char (*get_next_char)(), char mo
}
break;
case ST_INVALID_QUOTEDVALUE:
switch( ch ) {
switch (ch) {
case '\n':
state = ST_INITIAL;
break;
@@ -813,10 +795,27 @@ int process_config( section ** current_section, char (*get_next_char)(), char mo
}
break;
}
if( ch == '\0' ) {
if (ch == '\0') {
state = ST_END;
}
}
return 0;
}
#if 0
void config_dump(void)
{
section *s;
for (s = first_section; s != NULL; s = s->next_section) {
key *k;
fprintf(stderr, "[%s]\n", s->name);
for (k = s->first_key; k != NULL; k = k->next_key)
fprintf(stderr, "%s = '%s'\n", k->name, k->value);
fprintf(stderr, "\n");
}
}
#endif