lighttpd2/src/config_parser.rl

#include <lighttpd/base.h>
#include <lighttpd/config_parser.h>

#if 0
	#define _printf(fmt, ...) g_print(fmt, __VA_ARGS__)
#else
	#define _printf(fmt, ...) /* */
#endif

/** config parser state machine **/

%%{
	## ragel stuff
	machine config_parser;

	variable p ctx->p;
	variable pe ctx->pe;
	variable eof ctx->eof;

	access ctx->;

	prepush {
		/* _printf("current stacksize: %d, top: %d\n", ctx->stacksize, ctx->top); */
		/* increase stacksize if necessary */
		if (ctx->stacksize == ctx->top)
		{
			/* increase stacksize by 8 */
			ctx->stack = g_realloc(ctx->stack, sizeof(int) * (ctx->stacksize + 8));
			ctx->stacksize += 8;
		}
	}

	## actions
	action mark { ctx->mark = fpc; }

	# basic types
	action boolean {
		value *o;

		o = value_new_bool(*ctx->mark == 't' ? TRUE : FALSE);
		g_queue_push_head(ctx->option_stack, o);

		_printf("got boolean %s in line %zd\n", *ctx->mark == 't' ? "true" : "false", ctx->line);
	}

	action integer {
		value *o;
		gint64 i = 0;

		for (gchar *c = ctx->mark; c < fpc; c++)
			i = i * 10 + *c - 48;

		o = value_new_number(i);
		/* push value onto stack */
		g_queue_push_head(ctx->option_stack, o);

		_printf("got integer %" G_GINT64_FORMAT " in line %zd\n", i, ctx->line);
	}

	action integer_suffix {
		value *o;
		GString *str;

		o = g_queue_peek_head(ctx->option_stack);

		str = g_string_new_len(ctx->mark, fpc - ctx->mark);

		     if (g_str_equal(str->str, "kbyte")) o->data.number *= 1024;
		else if (g_str_equal(str->str, "mbyte")) o->data.number *= 1024 * 1024;
		else if (g_str_equal(str->str, "gbyte")) o->data.number *= 1024 * 1024 * 1024;
		else if (g_str_equal(str->str, "tbyte")) o->data.number *= 1024 * 1024 * 1024 * G_GINT64_CONSTANT(1024);

		else if (g_str_equal(str->str, "kbit")) o->data.number *= 1000;
		else if (g_str_equal(str->str, "mbit")) o->data.number *= 1000 * 1000;
		else if (g_str_equal(str->str, "gbit")) o->data.number *= 1000 * 1000 * 1000;
		else if (g_str_equal(str->str, "tbit")) o->data.number *= 1000 * 1000 * 1000 * G_GINT64_CONSTANT(1000);

		else if (g_str_equal(str->str, "min")) o->data.number *= 60;
		else if (g_str_equal(str->str, "hours")) o->data.number *= 60 * 60;
		else if (g_str_equal(str->str, "days")) o->data.number *= 60 * 60 * 24;

		g_string_free(str, TRUE);

		_printf("got int with suffix: %" G_GINT64_FORMAT "\n", o->data.number);
	}

	action string {
		value *o;
		GString *str;
		gchar ch;

		str = g_string_sized_new(fpc - ctx->mark - 2);
		for (gchar *c = (ctx->mark+1); c != (fpc-1); c++) {
			if (*c != '\\')
				g_string_append_c(str, *c);
			else {
				guint avail = fpc - 1 - c;
				if (avail == 0) {
					ERROR(srv, "%s", "invalid \\ at end of string");
					g_string_free(str, TRUE);
					return FALSE;
				}

				switch (*(c+1)) {
				case 'n': g_string_append_c(str, '\n'); c++; break;
				case 'r': g_string_append_c(str, '\r'); c++; break;
				case 't': g_string_append_c(str, '\t'); c++; break;
				case 'x':
					if (avail < 3 || !(
						((*(c+2) >= '0' && *(c+2) <= '9') && (*(c+3) >= '0' && *(c+3) <= '9')) ||
						((*(c+2) >= 'A' && *(c+2) <= 'F') && (*(c+3) >= 'A' && *(c+3) <= 'F')) ||
						((*(c+2) >= 'a' && *(c+2) <= 'f') && (*(c+3) >= 'a' && *(c+3) <= 'f')))) {
						ERROR(srv, "%s", "invalid \\xHH in string");
						g_string_free(str, TRUE);
						return FALSE;
					}
					/* append char from hex */
					/* first char */
					if (*(c+2) <= '9')
						ch = 16 * (*(c+2) - '0');
					else if (*(c+2) <= 'F')
						ch = 16 * (10 + *(c+2) - 'A');
					else
						ch = 16 * (10 + *(c+2) - 'a');
					/* second char */
					if (*(c+3) <= '9')
						ch += *(c+3) - '0';
					else if (*(c+3) <= 'F')
						ch += 10 + *(c+3) - 'A';
					else
						ch += 10 + *(c+3) - 'a';
					c += 3;
					g_string_append_c(str, ch);
				}
			}
		}

		o = value_new_string(str);
		g_queue_push_head(ctx->option_stack, o);

		_printf("got string %s", "");
		for (gchar *c = ctx->mark + 1; c < fpc - 1; c++) _printf("%c", *c);
		_printf(" in line %zd\n", ctx->line);
	}

	# advanced types
	action list_start {
		value *o;

		/* create new list value and put it on stack, list entries are put in it by getting the previous value from the stack */
		o = value_new_list();
		g_queue_push_head(ctx->option_stack, o);

		fcall list_scanner;
	}

	action list_push {
		value *o, *l;

		/* pop current value from stack and append it to the new top of the stack value (the list) */
		o = g_queue_pop_head(ctx->option_stack);

		l = g_queue_peek_head(ctx->option_stack);
		assert(l->type == VALUE_LIST);

		g_array_append_val(l->data.list, o);

		_printf("list_push %s\n", value_type_string(o->type));
	}

	action list_end {
		fret;
	}

	action hash_start {
		value *o;

		/* create new hash value and put it on stack, if a key-value pair is encountered, get it by walking 2 steps back the stack */
		o = value_new_hash();
		g_queue_push_head(ctx->option_stack, o);

		fcall hash_scanner;
	}

	action hash_push {
		value *k, *v, *h; /* key value hashtable */
		GString *str;

		v = g_queue_pop_head(ctx->option_stack);
		k = g_queue_pop_head(ctx->option_stack);
		h = g_queue_peek_head(ctx->option_stack);

		/* duplicate key so value can be free'd */
		str = g_string_new_len(k->data.string->str, k->data.string->len);

		g_hash_table_insert(h->data.hash, str, v);

		_printf("hash_push: %s: %s => %s\n", value_type_string(k->type), value_type_string(v->type), value_type_string(h->type));

		value_free(k);
	}

	action hash_end {
		fret;
	}

	action block_start {
		fcall block_scanner;
	}

	action block_end {
		fret;
	}

	action keyvalue_start {
		/* fpc--; */
		_printf("keyvalue start in line %zd\n", ctx->line);
		fcall key_value_scanner;
	}

	action keyvalue_end {
		value *k, *v, *l;
		/* we have a key and a value on the stack; convert them to a list with 2 elements */

		v = g_queue_pop_head(ctx->option_stack);
		k = g_queue_pop_head(ctx->option_stack);

		l = value_new_list();

		g_array_append_val(l->list, k);
		g_array_append_val(l->list, v);

		_printf("key-value pair: %s => %s in line %zd\n", value_type_string(k->type), value_type_string(v->type), ctx->line);

		/* push list on the stack */
		g_queue_push_head(ctx->option_stack, l);

		/* fpc--; */

		fret;
	}

	action value {
		value *o;

		o = g_queue_peek_head(ctx->option_stack);

		/* check if we need to cast the value */
		if (ctx->cast != CFG_PARSER_CAST_NONE) {
			if (ctx->cast == CFG_PARSER_CAST_INT) {
				/* cast string to integer */
				gint x = 0;
				guint i = 0;
				gboolean negative = FALSE;

				if (o->type != VALUE_STRING) {
					ERROR(srv, "can only cast strings to integers, %s given", value_type_string(o->type));
					return FALSE;
				}

				if (o->data.string->str[0] == '-') {
					negative = TRUE;
					i++;
				}

				for (; i < o->data.string->len; i++) {
					gchar c = o->data.string->str[i];
					if (c < '0' || c > '9') {
						ERROR(srv, "%s", "cast(int) parameter doesn't look like a numerical string");
						return FALSE;
					}
					x = x * 10 + c - '0';
				}

				if (negative)
					x *= -1;

				g_string_free(o->data.string, TRUE);
				o->data.number = x;
				o->type = VALUE_NUMBER;
			}
			else if (ctx->cast == CFG_PARSER_CAST_STR) {
				/* cast integer to string */
				GString *str;

				if (o->type != VALUE_NUMBER) {
					ERROR(srv, "can only cast integers to strings, %s given", value_type_string(o->type));
					return FALSE;
				}

				str = g_string_sized_new(0);
				g_string_printf(str, "%" G_GINT64_FORMAT, o->data.number);
				o->data.string = str;
				o->type = VALUE_STRING;
			}

			ctx->cast = CFG_PARSER_CAST_NONE;
		}

		_printf("value (%s) in line %zd\n", value_type_string(o->type), ctx->line);
	}

	action value_statement_start {
		fcall value_statement_scanner;
	}

	action value_statement_end {
		fret;
	}

	action value_statement_op {
		ctx->value_op = *ctx->mark;
	}

	action value_statement {
		/* value (+|-|*|/) value */
		/* compute new value out of the two */
		value *l, *r, *o;
		gboolean free_l, free_r;

		free_l = free_r = TRUE;

		r = g_queue_pop_head(ctx->option_stack);
		l = g_queue_pop_head(ctx->option_stack);
		o = NULL;


		if (ctx->value_op == '=') {
			/* value => value */
			free_l = FALSE;
			free_r = FALSE;
			o = value_new_list();
			g_array_append_val(o->data.list, l);
			g_array_append_val(o->data.list, r);
		}
		else if (l->type == VALUE_NUMBER && r->type == VALUE_NUMBER) {
			switch (ctx->value_op) {
				case '+': o = value_new_number(l->data.number + r->data.number); break;
				case '-': o = value_new_number(l->data.number - r->data.number); break;
				case '*': o = value_new_number(l->data.number * r->data.number); break;
				case '/': o = value_new_number(l->data.number / r->data.number); break;
			}
		}
		else if (l->type == VALUE_STRING) {
			o = l;
			free_l = FALSE;

			if (r->type == VALUE_STRING && ctx->value_op == '+') {
				/* str + str */
				o->data.string = g_string_append_len(o->data.string, GSTR_LEN(r->data.string));
			}
			else if (r->type == VALUE_NUMBER && ctx->value_op == '+') {
				/* str + int */
				g_string_append_printf(o->data.string, "%" G_GINT64_FORMAT, r->data.number);
			}
			else if (r->type == VALUE_NUMBER && ctx->value_op == '*') {
				/* str * int */
				if (r->data.number < 0) {
					ERROR(srv, "string multiplication with negative number (%" G_GINT64_FORMAT ")?", r->data.number);
					return FALSE;
				}
				else if (r->data.number == 0) {
					o->data.string = g_string_truncate(o->data.string, 0);
				}
				else {
					GString *str;
					str = g_string_new_len(l->data.string->str, l->data.string->len);
					for (gint i = 1; i < r->data.number; i++)
						o->data.string = g_string_append_len(o->data.string, str->str, str->len);
					g_string_free(str, TRUE);
				}
			}
			else
				o = NULL;
		}
		else if (l->type == VALUE_LIST) {
			if (ctx->value_op == '+') {
				/* append r to the end of l */
				free_l = FALSE; /* use l as the new o */
				free_r = FALSE; /* r gets appended to o */
				o = l;

				g_array_append_val(l->data.list, r);
			}
			else if (ctx->value_op == '*') {
				/* merge l and r */
				if (r->type == VALUE_LIST) {
					/* merge lists */
					free_l = FALSE;
					g_array_append_vals(l->data.list, r->data.list->data, r->data.list->len);
					g_array_set_size(r->data.list, 0);
					o = l;
				}
			}
		}
		else if (l->type == VALUE_HASH && r->type == VALUE_HASH && ctx->value_op == '+') {
			/* merge hashtables */
			GHashTableIter iter;
			gpointer key, val;
			free_l = FALSE; /* keep l, it's the new o */
			o = l;

			g_hash_table_iter_init(&iter, r->data.hash);
			while (g_hash_table_iter_next(&iter, &key, &val)) {
				g_hash_table_insert(o->data.hash, key, val);
				g_hash_table_iter_steal(&iter); /* steal key->value so it doesn't get deleted when destroying r */
			}
		}

		if (o == NULL) {
			WARNING(srv, "erronous value statement: %s %c %s in line %zd\n",
				value_type_string(l->type), ctx->value_op,
				value_type_string(r->type), ctx->line);
			return FALSE;
		}

		_printf("value statement: %s %c%s %s => %s in line %zd\n",
			value_type_string(l->type),
			ctx->value_op,
			ctx->value_op == '=' ?  ">" : "",
			value_type_string(r->type),
			value_type_string(o->type),
			ctx->line);

		if (free_l)
			value_free(l);
		if (free_r)
			value_free(r);

		g_queue_push_head(ctx->option_stack, o);
	}

	action varname {
		/* varname, push it as string value onto the stack */
		value *o;
		GString *str;

		str = g_string_new_len(ctx->mark, fpc - ctx->mark);
		o = value_new_string(str);
		g_queue_push_head(ctx->option_stack, o);
	}

	action actionref {
		/* varname is on the stack */
		value *o, *r, *t;

		o = g_queue_pop_head(ctx->option_stack);

		_printf("got actionref: %s in line %zd\n", o->data.string->str, ctx->line);

		/* action refs starting with "var." are user defined variables */
		if (g_str_has_prefix(o->data.string->str, "var.")) {
			/* look up var in hashtable, copy and push value onto stack */
			t = g_hash_table_lookup(ctx->uservars, o->data.string);

			if (t == NULL) {
				WARNING(srv, "unknown variable '%s'", o->data.string->str);
				value_free(o);
				return FALSE;
			}

			r = value_copy(t);
		}
		else if (g_str_has_prefix(o->data.string->str, "env.")) {
			/* look up string in environment, push value onto stack */
			gchar *env = getenv(o->data.string->str + 4);
			if (env == NULL) {
				ERROR(srv, "unknown environment variable: %s", o->data.string->str + 4);
				value_free(o);
				return FALSE;
			}

			r = value_new_string(g_string_new(env));
		}
		else {
			/* real action, lookup hashtable and create new action value */
			action *a;
			a = g_hash_table_lookup(ctx->action_blocks, o->data.string);

			if (a == NULL) {
				WARNING(srv,  "unknown action block referenced: %s", o->data.string->str);
				return FALSE;
			}

			action_acquire(a);
			r = value_new_action(srv, a);
		}

		g_queue_push_head(ctx->option_stack, r);
		value_free(o);
	}

	action operator {
		if ((fpc - ctx->mark) == 1) {
			switch (*ctx->mark) {
				case '<': ctx->op = CONFIG_COND_LT; break;
				case '>': ctx->op = CONFIG_COND_GT; break;
			}
		}
		else {
			     if (*ctx->mark == '>' && *(ctx->mark+1) == '=') ctx->op = CONFIG_COND_GE;
			else if (*ctx->mark == '<' && *(ctx->mark+1) == '=') ctx->op = CONFIG_COND_LE;
			else if (*ctx->mark == '=' && *(ctx->mark+1) == '=') ctx->op = CONFIG_COND_EQ;
			else if (*ctx->mark == '!' && *(ctx->mark+1) == '=') ctx->op = CONFIG_COND_NE;
			else if (*ctx->mark == '=' && *(ctx->mark+1) == '^') ctx->op = CONFIG_COND_PREFIX;
			else if (*ctx->mark == '!' && *(ctx->mark+1) == '^') ctx->op = CONFIG_COND_NOPREFIX;
			else if (*ctx->mark == '=' && *(ctx->mark+1) == '$') ctx->op = CONFIG_COND_SUFFIX;
			else if (*ctx->mark == '!' && *(ctx->mark+1) == '$') ctx->op = CONFIG_COND_NOSUFFIX;
			else if (*ctx->mark == '=' && *(ctx->mark+1) == '~') ctx->op = CONFIG_COND_MATCH;
			else if (*ctx->mark == '!' && *(ctx->mark+1) == '~') ctx->op = CONFIG_COND_NOMATCH;
		}
	}

	# statements
	action assignment {
		value *val, *name;
		action *a, *al;

		/* top of the stack is the value, then the varname as string value */
		val = g_queue_pop_head(ctx->option_stack);
		name = g_queue_pop_head(ctx->option_stack);

		assert(name->type == VALUE_STRING);

		_printf("got assignment: %s = %s; in line %zd\n", name->data.string->str, value_type_string(val->type), ctx->line);

		if (g_str_has_prefix(name->data.string->str, "var.")) {
			/* assignment vor user defined variable, insert into hashtable */
			gpointer old_key;
			gpointer old_val;
			GString *str = value_extract(name).string;

			/* free old key and value if we are overwriting it */
			if (g_hash_table_lookup_extended(ctx->uservars, str, &old_key, &old_val)) {
				g_hash_table_remove(ctx->uservars, str);
				g_string_free(old_key, TRUE);
				value_free(old_val);
			}

			g_hash_table_insert(ctx->uservars, str, val);
		}
		else if (ctx->in_setup_block) {
			/* in setup { } block, override default values for options */

			if (!plugin_set_default_option(srv, name->data.string->str, val)) {
				ERROR(srv, "failed overriding default value for option \"%s\"", name->data.string->str);
				value_free(name);
				value_free(val);
				return FALSE;
			}

			value_free(val);
		}
		else {
			/* normal assignment */
			a = option_action(srv, name->data.string->str, val);
			value_free(val);

			if (a == NULL) {
				value_free(name);
				return FALSE;
			}

			al = g_queue_peek_head(ctx->action_list_stack);
			g_array_append_val(al->data.list, a);
		}

		value_free(name);
	}

	action function_noparam {
		value *name;
		action *a, *al;

		name = g_queue_pop_head(ctx->option_stack);

		assert(name->type == VALUE_STRING);

		_printf("got function: %s; in line %zd\n", name->data.string->str, ctx->line);

		if (g_str_equal(name->data.string->str, "break")) {
		}
		else if (g_str_equal(name->data.string->str, "__halt")) {
		}
		else {
			if (ctx->in_setup_block) {
				/* we are in the setup { } block, call setups and don't append to action list */
				if (!call_setup(srv, name->data.string->str, NULL)) {
					value_free(name);
					return FALSE;
				}
			}
			else {
				al = g_queue_peek_head(ctx->action_list_stack);
				a = create_action(srv, name->data.string->str, NULL);

				if (a == NULL) {
					value_free(name);
					return FALSE;
				}

				g_array_append_val(al->data.list, a);
			}
		}

		value_free(name);
	}

	action function_param {
		/* similar to assignment */
		value *val, *name;
		action *a, *al;

		/* top of the stack is the value, then the varname as string value */
		val = g_queue_pop_head(ctx->option_stack);
		name = g_queue_pop_head(ctx->option_stack);

		assert(name->type == VALUE_STRING);

		_printf("got function: %s %s; in line %zd\n", name->data.string->str, value_type_string(val->type), ctx->line);

		if (g_str_equal(name->data.string->str, "include")) {
			if (val->type != VALUE_STRING) {
				WARNING(srv,  "include directive takes a string as parameter, %s given", value_type_string(val->type));
				value_free(name);
				value_free(val);
				return FALSE;
			}

			if (!config_parser_file(srv, ctx_stack, val->data.string->str)) {
				value_free(name);
				value_free(val);
				return FALSE;
			}

			value_free(val);
		}
		else if (g_str_equal(name->data.string->str, "include_shell")) {
			if (val->type != VALUE_STRING) {
				WARNING(srv,  "include_shell directive takes a string as parameter, %s given", value_type_string(val->type));
				value_free(name);
				value_free(val);
				return FALSE;
			}

			if (!config_parser_shell(srv, ctx_stack, val->data.string->str)) {
				value_free(name);
				value_free(val);
				return FALSE;
			}

			value_free(val);
		}
		/* internal functions */
		else if (g_str_has_prefix(name->data.string->str, "__")) {
			if (g_str_equal(name->data.string->str + 2, "print")) {
				GString *tmpstr = value_to_string(val);
				g_printerr("%s:%zd type: %s, value: %s\n", ctx->filename, ctx->line, value_type_string(val->type), tmpstr->str);
				g_string_free(tmpstr, TRUE);
				value_free(val);
			}
		}
		/* normal function action */
		else {
			/* TODO */
			if (ctx->in_setup_block) {
				/* we are in the setup { } block, call setups and don't append to action list */
				if (!call_setup(srv, name->data.string->str, val)) {
					value_free(name);
					value_free(val);
					return FALSE;
				}
				value_free(val);
			}
			else {
				al = g_queue_peek_head(ctx->action_list_stack);
				a = create_action(srv, name->data.string->str, val);
				value_free(val);

				if (a == NULL) {
					value_free(name);
					return FALSE;
				}

				g_array_append_val(al->data.list, a);
			}
		}

		value_free(name);