591 lines
12 KiB
C
591 lines
12 KiB
C
/*
|
|
* configfile.c
|
|
* This file is part of LCDd, the lcdproc server.
|
|
*
|
|
* This file is released under the GNU General Public License. Refer to the
|
|
* COPYING file distributed with this package.
|
|
*
|
|
* Copyright (c) 2001, Joris Robijn
|
|
*
|
|
*
|
|
* Defines routines to read ini-file-like files.
|
|
*/
|
|
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "shared/report.h"
|
|
|
|
|
|
typedef struct key {
|
|
char * name;
|
|
char * value;
|
|
struct key * next_key;
|
|
} key;
|
|
|
|
typedef struct section {
|
|
char * name;
|
|
key * first_key;
|
|
struct section * next_section;
|
|
} section;
|
|
|
|
|
|
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 );
|
|
int process_config( section ** current_section, char (*get_next_char)(), char modify_section_allowed, char * source_descr );
|
|
|
|
|
|
/**** EXTERNAL FUNCTIONS ****/
|
|
|
|
#define FILECHUNKSIZE 10
|
|
|
|
int config_read_file( char *filename )
|
|
{
|
|
FILE * f;
|
|
char buf[FILECHUNKSIZE];
|
|
int bytesread=0;
|
|
int pos=0;
|
|
section * curr_section = NULL;
|
|
|
|
/* We use a nested fuction to transfer the characters from buffer to parser*/
|
|
char get_next_char() {
|
|
if( pos>=bytesread ) {
|
|
if( !( bytesread = fread( buf, 1, FILECHUNKSIZE, f ))) {
|
|
/* We're at the end*/
|
|
return 0;
|
|
}
|
|
pos = 0;
|
|
}
|
|
return buf[pos++];
|
|
}
|
|
|
|
f = fopen( filename, "r" );
|
|
if( f==NULL ) {
|
|
return -1;
|
|
}
|
|
|
|
process_config( &curr_section, get_next_char, 1, filename );
|
|
|
|
fclose( f );
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
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;
|
|
|
|
/* 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 );
|
|
}
|
|
|
|
process_config( &s, get_next_char, 0, "command line" );
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
char *config_get_string( char * sectionname, char * keyname,
|
|
int skip, char * default_value )
|
|
{
|
|
section * s;
|
|
key * k;
|
|
|
|
s = find_section( sectionname );
|
|
if( !s ) return default_value;
|
|
k = find_key( s, keyname, skip );
|
|
if( !k ) return default_value;
|
|
|
|
return k->value;
|
|
|
|
/* This is the safer way:*/
|
|
|
|
/* Reallocate memory space for the return 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 )
|
|
{
|
|
section * s;
|
|
key * k;
|
|
|
|
s = find_section( sectionname );
|
|
if( !s ) return default_value;
|
|
k = find_key( s, keyname, skip );
|
|
if( !k ) return default_value;
|
|
|
|
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 ) {
|
|
return 1;
|
|
}
|
|
return 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;
|
|
|
|
s = find_section( sectionname );
|
|
if( !s ) return default_value;
|
|
k = find_key( s, keyname, skip );
|
|
if( !k ) return default_value;
|
|
|
|
v = strtol( k->value, &v_end, 0 );
|
|
if( v_end-(k->value) != strlen(k->value) ) {
|
|
/* Conversion not succesful*/
|
|
return default_value;
|
|
}
|
|
return v;
|
|
}
|
|
|
|
|
|
double config_get_float( char *sectionname, char *keyname,
|
|
int skip, double default_value )
|
|
{
|
|
section * s;
|
|
key * k;
|
|
double v;
|
|
char * v_end;
|
|
|
|
s = find_section( sectionname );
|
|
if( !s ) return default_value;
|
|
k = find_key( s, keyname, skip );
|
|
if( !k ) return default_value;
|
|
|
|
v = strtod( k->value, &v_end );
|
|
if( v_end-(k->value) != strlen(k->value) ) {
|
|
/* Conversion not succesful*/
|
|
return default_value;
|
|
}
|
|
return v;
|
|
}
|
|
|
|
|
|
int config_has_section( char *sectionname )
|
|
{
|
|
section * s;
|
|
|
|
s = find_section( sectionname );
|
|
if( s ) return 1; else return 0;
|
|
}
|
|
|
|
|
|
int config_has_key( char *sectionname, char *keyname )
|
|
{
|
|
section * s;
|
|
key * k;
|
|
|
|
int count = 0;
|
|
|
|
s = find_section( sectionname );
|
|
if( !s ) return 0;
|
|
|
|
for( k=s->first_key; k; k=k->next_key ) {
|
|
|
|
/* Did we find the right key ?*/
|
|
if( strcasecmp( k->name, keyname ) == 0 ) {
|
|
count ++;
|
|
}
|
|
}
|
|
return count;
|
|
}
|
|
|
|
|
|
void config_clear()
|
|
{
|
|
section * s;
|
|
section * next_s;
|
|
key * k;
|
|
key * next_k;
|
|
|
|
for( s = first_section; s; ) {
|
|
for( k=s->first_key; k; ) {
|
|
/* Advance before we destroy the current key */
|
|
next_k = k->next_key;
|
|
|
|
free( k->name );
|
|
free( k->value );
|
|
free( k );
|
|
|
|
k = next_k;
|
|
}
|
|
/* Advance before we destroy the current section */
|
|
next_s = s->next_section;
|
|
|
|
/* And destroy it */
|
|
free( s->name );
|
|
free( s );
|
|
|
|
s = next_s;
|
|
}
|
|
/* And make everything inaccessable */
|
|
first_section = NULL;
|
|
}
|
|
|
|
|
|
/**** INTERNAL FUNCTIONS ****/
|
|
|
|
section * find_section( char * sectionname )
|
|
{
|
|
section * s;
|
|
|
|
for( s=first_section; s; s=s->next_section ) {
|
|
if( strcasecmp( s->name, sectionname ) == 0 ) {
|
|
return s;
|
|
}
|
|
}
|
|
return NULL; /* not found*/
|
|
}
|
|
|
|
section * add_section( char * sectionname )
|
|
{
|
|
section *s;
|
|
section ** place = &first_section;
|
|
|
|
for( s=first_section; s; 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;
|
|
|
|
return (*place);
|
|
}
|
|
|
|
key * find_key( section * s, char * keyname, int skip )
|
|
{
|
|
key * k;
|
|
int count = 0;
|
|
key * last_key = NULL;
|
|
|
|
/* Check for NULL section*/
|
|
if(!s) return NULL;
|
|
|
|
for( k=s->first_key; k; k=k->next_key ) {
|
|
|
|
/* Did we find the right key ?*/
|
|
if( strcasecmp( k->name, keyname ) == 0 ) {
|
|
if( count == skip ) {
|
|
return k;
|
|
} else {
|
|
count ++;
|
|
last_key = k;
|
|
}
|
|
}
|
|
}
|
|
if( skip == -1 ) {
|
|
return last_key;
|
|
}
|
|
return NULL; /* not found*/
|
|
}
|
|
|
|
key * add_key( section * s, char * keyname, char * value )
|
|
{
|
|
key * k;
|
|
|
|
key ** place = &( s->first_key );
|
|
|
|
for( k=s->first_key; k; k=k->next_key )
|
|
place = &(k->next_key);
|
|
|
|
*place = (key*) malloc( sizeof( key ));
|
|
(*place)->name = strdup( keyname );
|
|
(*place)->value = strdup( value );
|
|
(*place)->next_key = NULL;
|
|
|
|
return (*place);
|
|
}
|
|
|
|
|
|
/* Parser states*/
|
|
#define ST_INITIAL 0
|
|
#define ST_IGNORE 1
|
|
#define ST_SECTIONNAME 2
|
|
#define ST_KEYNAME 3
|
|
#define ST_VALUE 10
|
|
#define ST_QUOTEDVALUE 11
|
|
#define ST_QUOTEDVALUE_ESCCHAR 12
|
|
#define ST_INVALID_SECTIONNAME 23
|
|
#define ST_INVALID_KEYNAME 24
|
|
#define ST_INVALID_VALUE 30
|
|
#define ST_INVALID_QUOTEDVALUE 31
|
|
#define ST_END 99
|
|
|
|
/* Limits*/
|
|
#define MAXSECTIONNAMELENGTH 40
|
|
#define MAXKEYNAMELENGTH 40
|
|
#define MAXVALUELENGTH 200
|
|
|
|
|
|
|
|
int process_config( section ** current_section, char (*get_next_char)(), char modify_section_allowed, char * source_descr )
|
|
{
|
|
char state = ST_INITIAL;
|
|
char ch;
|
|
char sectionname[MAXSECTIONNAMELENGTH+1];
|
|
int sectionname_pos = 0;
|
|
char keyname[MAXKEYNAMELENGTH+1];
|
|
int keyname_pos = 0;
|
|
char value[MAXVALUELENGTH+1];
|
|
int value_pos = 0;
|
|
int quote = 0;
|
|
key * k;
|
|
int line_nr = 1;
|
|
|
|
while( state != ST_END ) {
|
|
|
|
ch = get_next_char();
|
|
|
|
/* Secretly keep count of the line numbers*/
|
|
if( ch == '\n' ) {
|
|
line_nr ++;
|
|
}
|
|
|
|
switch( state ) {
|
|
case ST_INITIAL:
|
|
switch( ch ) {
|
|
case '\n':
|
|
case '\r':
|
|
case '\t':
|
|
case ' ':
|
|
break;
|
|
case '#':
|
|
case ';':
|
|
case '=':
|
|
case ']':
|
|
/* It's a comment or an error*/
|
|
state = ST_IGNORE;
|
|
break;
|
|
case '[':
|
|
/* It's a section name*/
|
|
state = ST_SECTIONNAME;
|
|
sectionname[0] = 0;
|
|
sectionname_pos = 0;
|
|
break;
|
|
case 0:
|
|
break;
|
|
default:
|
|
/* It's a keyname*/
|
|
state = ST_KEYNAME;
|
|
keyname[0] = ch;
|
|
keyname[1] = 0;
|
|
keyname_pos = 1;
|
|
}
|
|
break;
|
|
case ST_IGNORE:
|
|
switch( ch ) {
|
|
case '\n':
|
|
state = ST_INITIAL;
|
|
break;
|
|
}
|
|
break;
|
|
case ST_SECTIONNAME:
|
|
switch( ch ) {
|
|
case '\n':
|
|
report( RPT_WARNING, "Section name incorrectly closed on line %d of %s: %s", line_nr, source_descr, sectionname );
|
|
state = ST_INITIAL;
|
|
break;
|
|
case '\r':
|
|
case '\t':
|
|
case ' ':
|
|
case '"':
|
|
case '[':
|
|
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 );
|
|
}
|
|
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 ) {
|
|
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 );
|
|
state = ST_INVALID_SECTIONNAME;
|
|
}
|
|
}
|
|
break;
|
|
case ST_INVALID_SECTIONNAME:
|
|
switch( ch ) {
|
|
case '\n':
|
|
case ']':
|
|
state = ST_INITIAL;
|
|
break;
|
|
}
|
|
break;
|
|
case ST_KEYNAME:
|
|
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 );
|
|
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 );
|
|
state = ST_INVALID_KEYNAME;
|
|
break;
|
|
case '=':
|
|
state = ST_VALUE;
|
|
value[0] = 0;
|
|
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 );
|
|
state = ST_INVALID_KEYNAME;
|
|
} else {
|
|
keyname[keyname_pos++] = ch;
|
|
keyname[keyname_pos] = 0;
|
|
}
|
|
}
|
|
break;
|
|
case ST_INVALID_KEYNAME:
|
|
switch( ch ) {
|
|
case '\n':
|
|
state = ST_INITIAL;
|
|
/*case ' ':*/
|
|
}
|
|
break;
|
|
case ST_VALUE:
|
|
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 );
|
|
state = ST_INVALID_VALUE;
|
|
break;
|
|
case '"':
|
|
state = ST_QUOTEDVALUE;
|
|
break;
|
|
case 0:
|
|
case '\n':
|
|
case '\r':
|
|
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 );
|
|
}
|
|
else {
|
|
/* Store the value*/
|
|
k = add_key( *current_section, keyname, value );
|
|
}
|
|
/* And be ready for next thing...*/
|
|
state = ST_INITIAL;
|
|
break;
|
|
default:
|
|
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 );
|
|
state = ST_INVALID_KEYNAME;
|
|
}
|
|
}
|
|
break;
|
|
case ST_INVALID_VALUE:
|
|
switch( ch ) {
|
|
case '\n':
|
|
state = ST_INITIAL;
|
|
break;
|
|
case '"':
|
|
state = ST_INVALID_QUOTEDVALUE;
|
|
}
|
|
break;
|
|
case ST_QUOTEDVALUE:
|
|
switch( ch ) {
|
|
case 0:
|
|
case '\n':
|
|
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 ) {
|
|
quote = 1;
|
|
break;
|
|
}
|
|
case '"':
|
|
if( !quote ) {
|
|
state = ST_VALUE;
|
|
break;
|
|
}
|
|
default:
|
|
if( quote ) {
|
|
switch( ch ) {
|
|
case 'n': ch = '\n'; break;
|
|
case 'r': ch = '\r'; break;
|
|
case 't': ch = '\t'; break;
|
|
/* default: litteral*/
|
|
}
|
|
quote = 0;
|
|
}
|
|
value[value_pos++] = ch;
|
|
value[value_pos] = 0;
|
|
}
|
|
break;
|
|
case ST_INVALID_QUOTEDVALUE:
|
|
switch( ch ) {
|
|
case '\n':
|
|
state = ST_INITIAL;
|
|
break;
|
|
case '"':
|
|
state = ST_INVALID_VALUE;
|
|
}
|
|
break;
|
|
}
|
|
if( ch == 0 ) {
|
|
state = ST_END;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|