563 lines
12 KiB
C
563 lines
12 KiB
C
/*
|
|
* Defines routines to read ini-file-like files.
|
|
*
|
|
* This file is released under the GNU General Public License. Refer to the
|
|
* COPYING file distributed with this package
|
|
*
|
|
* (c) 2001 Joris Robijn
|
|
*/
|
|
|
|
|
|
#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;
|
|
*/
|
|
}
|
|
|
|
|
|
unsigned char config_get_bool( char *sectionname, char *keyname,
|
|
unsigned int skip, unsigned 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;
|
|
|
|
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,
|
|
unsigned 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,
|
|
unsigned 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()
|
|
{
|
|
report( RPT_WARNING, "config_clear is unimplemented" );
|
|
}
|
|
|
|
|
|
//// 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 = (char*) malloc( strlen(sectionname)+1 );
|
|
strcpy( (*place)->name, 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 = (char*) malloc( strlen(keyname)+1 );
|
|
strcpy( (*place)->name, keyname );
|
|
(*place)->value = (char*) malloc( strlen(value)+1 );
|
|
strcpy( (*place)->value, 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;
|
|
}
|
|
|