parseconf.c

/* parseconf.c
 * Copyright (C) 2007 Tillmann Werner <tillmann.werner@gmx.de>
 *
 * This file is free software; as a special exception the author gives
 * unlimited permission to copy and/or distribute it, with or without
 * modifications, as long as this notice is preserved.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY, to the extent permitted by law; without even the
 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 * The config file parser is based on lcfg from Paul Baecher.
 */

#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>

#include "parseconf.h"
#include "readconf.h"
#include "logging.h"


struct lcfg_scanner *    lcfg_scanner_new(struct lcfg *, int fd);
enum lcfg_status         lcfg_scanner_init(struct lcfg_scanner *);
enum lcfg_status         lcfg_scanner_next_token(struct lcfg_scanner *, struct lcfg_token *);
int                      lcfg_scanner_has_next(struct lcfg_scanner *);
void                     lcfg_scanner_delete(struct lcfg_scanner *);

struct lcfg_parser *  lcfg_parser_new(struct lcfg *, const char *);
enum lcfg_status      lcfg_parser_run(struct lcfg_parser *);
enum lcfg_status      lcfg_parser_accept(struct lcfg_parser *, lcfg_visitor_function, void *);
void                  lcfg_parser_delete(struct lcfg_parser *);


int lcfg_string_set(struct lcfg_string *s, const char *cstr) {
	lcfg_string_trunc(s, 0);
	return lcfg_string_cat_cstr(s, cstr);
}


/* make sure new_size bytes fit into the string */
inline static void lcfg_string_grow(struct lcfg_string *s, unsigned int new_size) {
	/* always allocate one byte more than needed
	 * to make _cstr() working in any case without realloc. */
	while( (new_size + 1) > s->capacity ) {
		s->capacity *= 2;
		s->str = realloc(s->str, s->capacity);
	}
}

struct lcfg_string *lcfg_string_new() {
	struct lcfg_string *s = malloc(sizeof(struct lcfg_string));
	
	s->capacity = 8;
	s->size = 0;
	s->str = malloc(s->capacity);
	
	return s;
}

struct lcfg_string *lcfg_string_new_copy(struct lcfg_string *s) {
	struct lcfg_string *s_new = malloc(sizeof(struct lcfg_string));
	
	s_new->capacity = s->capacity;
	s_new->size = s->size;
	s_new->str = malloc(s_new->capacity);
	
	memcpy(s_new->str, s->str, s_new->size);
	
	return s_new;
}

int lcfg_string_cat_uint(struct lcfg_string *s, unsigned int i) {
	unsigned int size_needed = 1;
	unsigned int ii = i;
	char c;
	
	while( ii > 10 ) {
		size_needed++;
		ii /= 10;
	}
	
	lcfg_string_grow(s, s->size + size_needed);
	
	ii = size_needed - 1;
	do {
		c = '0' + i % 10;
		s->str[s->size + ii--] = c;
		i /= 10;
	} while( i != 0 );
	
	s->size += size_needed;
	
	return s->size;
}

int lcfg_string_find(struct lcfg_string *s, char c) {
	int i;
	
	for( i = 0; i < s->size; i++ ) if( s->str[i] == c ) return i;
	
	return -1;
}

int lcfg_string_rfind(struct lcfg_string *s, char c) {
	int i;
	
	for( i = s->size - 1; i >= 0; i-- ) if( s->str[i] == c ) return i;
	
	return -1;
}

void lcfg_string_trunc(struct lcfg_string *s, unsigned int max_size) {
	if( max_size < s->size ) s->size = max_size;
}

int lcfg_string_cat_cstr(struct lcfg_string *s, const char *cstr) {
	size_t len = strlen(cstr);
	
	lcfg_string_grow(s, s->size + len);
	
	memcpy(s->str + s->size, cstr, len);
	
	s->size += len;
	
	return s->size;
}

int lcfg_string_cat_char(struct lcfg_string *s, char c) {
	lcfg_string_grow(s, s->size + 1);
	
	s->str[s->size++] = c;
	
	return s->size;
}

inline const char *lcfg_string_cstr(struct lcfg_string *s) {
	s->str[s->size] = '\0';
	return s->str;
}

inline unsigned int lcfg_string_len(struct lcfg_string *s) {
	return s->size;
}

void lcfg_string_delete(struct lcfg_string *s) {
	free(s->str);
	free(s);
}

const char *lcfg_token_map[] = {
	"null_token",
	"T_IDENTIFIER",
	"`='",
	"T_STRING",
	"`['",
	"`]'",
	"`,'",
	"`{'",
	"`}'"
};

struct lcfg_scanner {
	struct lcfg *lcfg;
	
	int fd;
	char buffer[LCFG_BUFSIZ];
	int offset;
	int size;
	int eof;
	
	short line;
	short col;
	
	struct lcfg_token prepared_token;
	int token_eof;
};


static enum lcfg_status lcfg_scanner_buffer_fill(struct lcfg_scanner *s) {
	if( (s->size = read(s->fd, s->buffer, LCFG_BUFSIZ)) < 0 ) {
		lcfg_error_set(s->lcfg, "read(): %m");
		return lcfg_status_error;
	} else if( s->size == 0 ) s->eof = !0;
	else s->offset = 0;
	
	return lcfg_status_ok;
}

static inline int lcfg_scanner_char_eof(struct lcfg_scanner *s) {
	if( s->eof ) return !0;

	if( s->size == 0 || s->offset == LCFG_BUFSIZ) lcfg_scanner_buffer_fill(s);
	if( s->size < LCFG_BUFSIZ && s->offset == s->size ) s->eof = !0;

	return s->eof;
}

static enum lcfg_status lcfg_scanner_char_read(struct lcfg_scanner *s, char *c) {
	if( lcfg_scanner_char_eof(s) ) {
		lcfg_error_set(s->lcfg, "%s", "cannot read beyond eof");
		return lcfg_status_error;
	}
	
	*c = s->buffer[s->offset++];

	return lcfg_status_ok;
}

static enum lcfg_status lcfg_scanner_char_peek(struct lcfg_scanner *s, char *c) {
	if( lcfg_scanner_char_eof(s) ) {
		lcfg_error_set(s->lcfg, "%s", "cannot peek beyond eof");
		return lcfg_status_error;
	}
	
	*c = s->buffer[s->offset];

	return lcfg_status_ok;
}

/* the beautiful lowlevel fsm */
static enum lcfg_status lcfg_scanner_token_read(struct lcfg_scanner *s) {
	enum scanner_state {
		start = 0,
		comm_start,
		in_oneline,
		in_multiline,
		multiline_end,
		in_identifier,
		in_str,
		in_esc,
		esc_hex_exp_first,
		esc_hex_exp_second,
		invalid
	};
	enum scanner_state state = start;
	char c = '\0';
	char hex[3];
	
	s->prepared_token.type = lcfg_null_token;
	
	while( !lcfg_scanner_char_eof(s) ) {
		int consume = !0;
		lcfg_scanner_char_peek(s, &c);
		
		switch( state ) {
		case start:
			switch( c ) {
			case ' ':
			case '\t':
			case '\r':
			case '\n':
				break;
			case '=':
				s->prepared_token.type = lcfg_equals;
				break;
			case '[':
				s->prepared_token.type = lcfg_sbracket_open;
				break;
			case ']':
				s->prepared_token.type = lcfg_sbracket_close;
				break;
			case '{':
				s->prepared_token.type = lcfg_brace_open;
				break;
			case '}':
				s->prepared_token.type = lcfg_brace_close;
				break;
			case ',':
				s->prepared_token.type = lcfg_comma;
				break;
			case '/':
				state = comm_start;
				break;
			case '"':
				state = in_str;
				lcfg_string_trunc(s->prepared_token.string, 0);
				break;
			default:
				if( isalpha(c) ) {
					lcfg_string_trunc(s->prepared_token.string, 0);
					lcfg_string_cat_char(s->prepared_token.string, c);
					state = in_identifier;
				} else {
					lcfg_error_set(s->lcfg, "parse error: invalid input character `%c' (0x%02x) near line %d, col %d",
						isprint(c) ? c : '.', c, s->line, s->col);
					state = invalid;
				}
			}
			break;
		case comm_start:
			if( c == '/' ) state = in_oneline;
			else if( c == '*' ) state = in_multiline;
			else {
				lcfg_error_set(s->lcfg, "parse error: invalid input character `%c' (0x%02x) near line %d, col %d",
					isprint(c) ? c : '.', c, s->line, s->col);
				state = invalid;
			}
			break;
		case in_oneline:
			if( c == '\n' ) state = start;
			break;
		case in_multiline:
			if( c == '*' ) state = multiline_end;
			break;
		case multiline_end:
			if( c == '/' ) state = start;
			else if( c != '*' ) state = in_multiline;
			break;
		case in_identifier:
			if( isalnum(c) || c == '-' || c == '_' ) lcfg_string_cat_char(s->prepared_token.string, c);
			else {
				s->prepared_token.type = lcfg_identifier;
				consume = 0;
				state = start;
			}
			break;
		case in_str:
			if( c == '"' ) {
				s->prepared_token.type = lcfg_string;
				state = start;
			} else if( c == '\\' ) {
				state = in_esc;
			} else {
				lcfg_string_cat_char(s->prepared_token.string, c);
			}
			break;
		case in_esc:
			state = in_str;
			switch( c ) {
			case '"':
				lcfg_string_cat_char(s->prepared_token.string, '"');
				break;
			case '\\':
				lcfg_string_cat_char(s->prepared_token.string, '\\');
				break;
			case 'n':
				lcfg_string_cat_char(s->prepared_token.string, '\n');
				break;
			case 't':
				lcfg_string_cat_char(s->prepared_token.string, '\t');
				break;
			case 'r':
				lcfg_string_cat_char(s->prepared_token.string, '\r');
				break;
			case '0':
				lcfg_string_cat_char(s->prepared_token.string, '\0');
				break;
			case 'x':
				state = esc_hex_exp_first;
				break;
			default:
				lcfg_error_set(s->lcfg, "invalid string escape sequence `%c' near line %d, col %d", c, s->line, s->col);
				state = invalid;
			}
			break;
		case esc_hex_exp_first:
			if( !isxdigit(c) ) {
				lcfg_error_set(s->lcfg, "invalid hex escape sequence `%c' on line %d column %d", c, s->line, s->col);
				state = invalid;
			}
			hex[0] = c;
			state = esc_hex_exp_second;
			break;
		case esc_hex_exp_second:
			if( !isxdigit(c) ) {
				lcfg_error_set(s->lcfg, "invalid hex escape sequence `%c' on line %d column %d", c, s->line, s->col);
				state = invalid;
			}
			hex[1] = c;
			hex[2] = '\0';
			lcfg_string_cat_char(s->prepared_token.string, strtoul(hex, NULL, 16));
			state = in_str;
			break;
		case invalid:
			break;
		}
		
		/* this is technically not optimal (token position identified by last char), but it will suffice for now */
		s->prepared_token.line = s->line;
		s->prepared_token.col = s->col;
	
		if( consume ) {
			lcfg_scanner_char_read(s, &c);
			if( c == '\n' ) {
				s->line++;
				s->col = 1;
			} else s->col++;
		}
		
		if( s->prepared_token.type != lcfg_null_token || state == invalid ) break;
	}
	
	if( state != start ) {
		if( state != invalid ) lcfg_error_set(s->lcfg, "parse error: premature end of file near line %d, col %d", s->line, s->col);
		
		return lcfg_status_error;
	}
	
	return lcfg_status_ok;
}

enum lcfg_status lcfg_scanner_init(struct lcfg_scanner *s) {
	/* prepare the first token */
	return lcfg_scanner_token_read(s); 
}

int lcfg_scanner_has_next(struct lcfg_scanner *s) {
	return s->prepared_token.type != lcfg_null_token;
}

enum lcfg_status lcfg_scanner_next_token(struct lcfg_scanner *s, struct lcfg_token *t) {
	if( !lcfg_scanner_has_next(s) ) {
		lcfg_error_set(s->lcfg, "%s", "cannot access tokenstream beyond eof");
		return lcfg_status_error;
	}
	
	memcpy(t, &s->prepared_token, sizeof(struct lcfg_token));
	t->string = lcfg_string_new_copy(s->prepared_token.string);
	
	/* prepare the next token */
	return lcfg_scanner_token_read(s); 
}

struct lcfg_scanner *lcfg_scanner_new(struct lcfg *c, int fd) {
	struct lcfg_scanner *s = malloc(sizeof(struct lcfg_scanner));
	
	memset(s, 0, sizeof(struct lcfg_scanner));
	
	s->lcfg = c;
	s->fd = fd;
	
	s->line = s->col = 1;
	
	s->prepared_token.string = lcfg_string_new();
	
	return s;
}

void lcfg_scanner_delete(struct lcfg_scanner *s) {
	lcfg_string_delete(s->prepared_token.string);
	free(s);
}

struct lcfg_parser_value_pair {
	char *key;
	struct lcfg_string *value;
};


struct lcfg_parser {
	struct lcfg *lcfg;
	char *filename;
	struct lcfg_scanner *scanner;
	
	struct lcfg_parser_value_pair *values;
	unsigned int value_length;
	unsigned int value_capacity;
};

static int lcfg_parser_add_value(struct lcfg_parser *p, const char *key, struct lcfg_string *value) {
	if( p->value_length == p->value_capacity ) {
		p->value_capacity *= 2;
		p->values = realloc(p->values, sizeof(struct lcfg_parser_value_pair) * p->value_capacity);
	}
	
	p->values[p->value_length].key = strdup(key);
	p->values[p->value_length].value = lcfg_string_new_copy(value);
	
	return ++p->value_length;
}

struct lcfg_parser *lcfg_parser_new(struct lcfg *c, const char *filename) {
	struct lcfg_parser *p = malloc(sizeof(struct lcfg_parser));
	
	memset(p, 0, sizeof(struct lcfg_parser));
	
	p->filename = strdup(filename);
	p->lcfg = c;
	
	p->value_length = 0;
	p->value_capacity = 8;
	p->values = malloc(sizeof(struct lcfg_parser_value_pair) * p->value_capacity);
	
	return p;
}

/* this is a basic push down automata */
static enum lcfg_status lcfg_parser_parse(struct lcfg_parser *p) {
	enum state { top_level = 0, exp_equals, exp_value, in_list, in_map, invalid };
	/*const char *state_map[] = { "top_level", "exp_equals", "exp_value", "in_list", "in_map", "invalid" };*/

	struct state_element {
		enum state s;
		int list_counter;
	};

	/* start of ugly preproc stuff */
	#define STATE_STACK_PUSH(t) \
	if( ssi + 1 == state_stack_size ) \
	{ \
		state_stack_size *= 2; \
		state_stack = realloc(state_stack, state_stack_size * sizeof(struct state_element)); \
	} \
	state_stack[++ssi].s = t; \
	state_stack[ssi].list_counter = 0
	#define STATE_STACK_POP() ssi--
	#define PATH_PUSH_STR(s) \
	if( lcfg_string_len(current_path) != 0 ) \
	{ \
		lcfg_string_cat_char(current_path, '.'); \
	} \
	lcfg_string_cat_cstr(current_path, s);
	#define PATH_PUSH_INT(i) \
	if( lcfg_string_len(current_path) != 0 ) \
	{ \
		lcfg_string_cat_char(current_path, '.'); \
	} \
	lcfg_string_cat_uint(current_path, i);
	#define PATH_POP() \
	if( lcfg_string_rfind(current_path, '.') != -1 ) \
	{ \
		lcfg_string_trunc(current_path, lcfg_string_rfind(current_path, '.')); \
	} \
	else \
	{ \
		lcfg_string_trunc(current_path, 0); \
	}
	/* end of ugly preproc stuff */

	if( lcfg_scanner_init(p->scanner) != lcfg_status_ok ) return lcfg_status_error;
	
	int state_stack_size = 8;
	int ssi = 0; /* ssi = state stack index */
	struct state_element *state_stack = malloc(sizeof(struct state_element) * state_stack_size);
	
	state_stack[ssi].s = top_level;
	state_stack[ssi].list_counter = 0;
	
	struct lcfg_token t;
	struct lcfg_string *current_path = lcfg_string_new();
	
	while( lcfg_scanner_has_next(p->scanner) && state_stack[ssi].s != invalid ) {
		if( lcfg_scanner_next_token(p->scanner, &t) != lcfg_status_ok ) {
			free(state_stack);
			lcfg_string_delete(t.string);
			lcfg_string_delete(current_path);
			return lcfg_status_error;
		}
		
		switch( state_stack[ssi].s ) {
		case top_level:
		case in_map:
			if( t.type == lcfg_identifier ) {
				PATH_PUSH_STR(lcfg_string_cstr(t.string));
				STATE_STACK_PUSH(exp_equals);
			} else if( state_stack[ssi].s == in_map && t.type == lcfg_brace_close ) {
				STATE_STACK_POP();
				PATH_POP();
			} else {
				lcfg_error_set(p->lcfg, "invalid token (%s) near line %d column %d: expected identifier%s",
					lcfg_token_map[t.type], t.line, t.col, state_stack[ssi].s == in_map ? " or `}'" : ""); 
				state_stack[ssi].s = invalid;
			}
			break;
		case exp_equals:
			if( t.type == lcfg_equals ) state_stack[ssi].s = exp_value;
			else {
				lcfg_error_set(p->lcfg, "invalid token (%s) near line %d column %d: expected `='",
					lcfg_token_map[t.type], t.line, t.col); 
				state_stack[ssi].s = invalid;
			}
			break;
		case exp_value:
			if( t.type == lcfg_string ) {
				lcfg_parser_add_value(p, lcfg_string_cstr(current_path), t.string);
				STATE_STACK_POP();
				PATH_POP();
			} else if( t.type == lcfg_sbracket_open ) state_stack[ssi].s = in_list;
			else if( t.type == lcfg_brace_open ) state_stack[ssi].s = in_map;
			else {
				lcfg_error_set(p->lcfg, "invalid token (%s) near line %d column %d: expected string, `[' or `{'",
					lcfg_token_map[t.type], t.line, t.col); 
				state_stack[ssi].s = invalid;
			}
			break;
		case in_list:
			if( t.type == lcfg_comma ); /* ignore comma */
			else if( t.type == lcfg_string ) {
				PATH_PUSH_INT(state_stack[ssi].list_counter);
				lcfg_parser_add_value(p, lcfg_string_cstr(current_path), t.string);
				PATH_POP();
				state_stack[ssi].list_counter++;
			} else if( t.type == lcfg_sbracket_open ) {
				PATH_PUSH_INT(state_stack[ssi].list_counter);
				state_stack[ssi].list_counter++;
				STATE_STACK_PUSH(in_list);
			} else if( t.type == lcfg_brace_open ) {
				PATH_PUSH_INT(state_stack[ssi].list_counter);
				state_stack[ssi].list_counter++;
				STATE_STACK_PUSH(in_map);
			} else if( t.type == lcfg_sbracket_close ) {
				PATH_POP();
				STATE_STACK_POP();
			} else {
				lcfg_error_set(p->lcfg, "invalid token (%s) near line %d column %d: expected string, `[', `{', `,' or `]'",
					lcfg_token_map[t.type], t.line, t.col); 
				state_stack[ssi].s = invalid;
			}
			break;
		case invalid: /* unreachable */
			break;
		}
		
		lcfg_string_delete(t.string);
	}

	lcfg_string_delete(current_path);	
	
	if( state_stack[ssi].s == top_level && ssi == 0 ) {
		free(state_stack);
		return lcfg_status_ok;
	} else {
		free(state_stack);
		return lcfg_status_error;
	}
}

enum lcfg_status lcfg_parser_run(struct lcfg_parser *p) {	
	int fd = open(p->filename, 0);
	enum lcfg_status status;
	
	if( fd < 0 ) {
		lcfg_error_set(p->lcfg, "open(): %m");
		return lcfg_status_error;
	}
	
	p->scanner = lcfg_scanner_new(p->lcfg, fd);
	
	status = lcfg_parser_parse(p);	
	
	close(fd);
	
	return status;
}

enum lcfg_status lcfg_parser_accept(struct lcfg_parser *p, lcfg_visitor_function fn, void *user_data) {
	int i;
	
	for( i = 0; i < p->value_length; i++ ) {
		if( fn(p->values[i].key, (void *)lcfg_string_cstr(p->values[i].value),
			lcfg_string_len(p->values[i].value), user_data) != lcfg_status_ok ) {
			lcfg_error_set(p->lcfg, "%s", "configuration value traversal aborted upon user request");
			return lcfg_status_error;
		}
	}
	
	return lcfg_status_ok;
}

void lcfg_parser_delete(struct lcfg_parser *p) {
	if (p->scanner) lcfg_scanner_delete(p->scanner);
	
	int i;
	
	for( i = 0; i < p->value_length; i++ ) {
		free(p->values[i].key);
		lcfg_string_delete(p->values[i].value);
	}
	free(p->values);
	free(p->filename);
	free(p);
}

struct lcfg *lcfg_new(const char *filename) {
	struct lcfg *c = malloc(sizeof(struct lcfg));
	memset(c, 0, sizeof(struct lcfg));
	
	c->parser = lcfg_parser_new(c, filename);
	
	return c;
}

void lcfg_delete(struct lcfg *c) {
	if (c->parser) lcfg_parser_delete(c->parser);
	free(c);
}

const char *lcfg_error_get(struct lcfg *c) {
	return c->error;
}

enum lcfg_status lcfg_parse(struct lcfg *c) {
	return lcfg_parser_run(c->parser);
}

enum lcfg_status lcfg_accept(struct lcfg *c, lcfg_visitor_function fn, void *user_data) {
	return lcfg_parser_accept(c->parser, fn, user_data);
}

void lcfg_error_set(struct lcfg *c, const char *fmt, ...) {	
	va_list ap;
	va_start(ap, fmt);
	vsnprintf(c->error, sizeof(c->error), fmt, ap);
	va_end(ap);
}

struct lcfg *parse_config_file(const char *filename) {
	struct lcfg *c = NULL;

	if (!filename) {
		fprintf(stderr, "  Error - No configuration file name given.\n");
		return(NULL);
	}

	/* parse file */
	c = lcfg_new(filename);
	if (lcfg_parse(c) != lcfg_status_ok) {
		fprintf(stderr, "  Error -  Unable to parse %s: %s\n", filename, lcfg_error_get(c));
		lcfg_delete(c);	
		return(NULL);
	}
	
	return(c);
}