path: root/src/config.c

/* This file is part of Ping903
   Copyright (C) 2020 Sergey Poznyakoff
  
   Ping903 is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3, or (at your option)
   any later version.
  
   Ping903 is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
  
   You should have received a copy of the GNU General Public License
   along with Ping903.  If not, see <http://www.gnu.org/licenses/>.
*/
#include <config.h>
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include "ping903.h"
#include "json.h"
#include "defs.h"

static int
get_num(char const *str, unsigned long *retval,
	char const *file, unsigned line)
{
	unsigned long n;
	char *p;
	errno = 0;
	n = strtoul(str, &p, 10);
	if (errno || *p) {
		error("%s:%d: invalid numeric value", file, line);
		return -1;
	}
	*retval = n;
	return 0;
}

static int
cf_ip_list(int mode, union cf_callback_arg *arg, void *data)
{
	FILE *fp;
	char buf[1024];
	unsigned ln = 0;
	int skip_to_eol = 0;
	int ret = CF_RET_OK;
	struct addrinfo hints;

	if (mode != CF_PARSE)
		return CF_RET_IGNORE;
	
	fp = fopen(arg->input.val, "r");
	if (!fp) {
		error("%s:%d: can't open file %s: %s",
		      arg->input.file, arg->input.line,
		      arg->input.val, strerror(errno));
		exit(1);
	}
	
	memset(&hints, 0, sizeof(hints));
	hints.ai_family = AF_INET;
	hints.ai_protocol = IPPROTO_TCP;

	while (fgets(buf, sizeof(buf), fp)) {
		int len;
		char *p;
		struct addrinfo *res;
		int rc;
		
		ln++;
		len = strlen(buf);
		if (len == 0)
			continue;

		if (skip_to_eol) {
			skip_to_eol = buf[len-1] != '\n';
			continue;
		}
		
		if (buf[len-1] == '\n')
			buf[--len] = 0;
		else if (!feof(fp)) {
			error("%s:%d: line too long", arg->input.val, ln);
			skip_to_eol = 1;
			ret = CF_RET_FAIL;
			continue;
		}

		while (len > 0 && isspace(buf[len-1]))
			buf[--len] = 0;

		if (len == 0)
			continue;
		for (p = buf; (*p == ' ' || *p == '\t'); p++)
			;
		if (*p == 0 || *p == '#')
			continue;

		rc = getaddrinfo(p, NULL, &hints, &res);
		if (rc) {
			error("%s:%d: invalid IP address", arg->input.val, ln);
			ret = CF_RET_FAIL;
			continue;
		}
		if (hostaddr_count == hostaddr_max) {
			hostaddr = e2nrealloc(hostaddr,
					      &hostaddr_max,
					      sizeof(hostaddr[0]));
		}
		memset(&hostaddr[hostaddr_count], 0, sizeof(hostaddr[0]));
		hostaddr[hostaddr_count].name = estrdup(p);
		hostaddr[hostaddr_count].addr = emalloc(res->ai_addrlen);
		memcpy(hostaddr[hostaddr_count].addr, res->ai_addr, res->ai_addrlen);
		hostaddr[hostaddr_count].addrlen = res->ai_addrlen;
		hostaddr_count++;
		freeaddrinfo(res);
	}
	fclose(fp);
	return ret;
}

struct cf_stmt {
	char const *kw;
	int type;
	void *data;
	CF_CALLBACK callback;
};

struct cf_stmt statements[] = {
	{ "listen",             STMT_T_STRING,    &httpd_addr },
	{ "pidfile",            STMT_T_STRING,    &pidfile },
	{ "trusted-ip",         STMT_T_CALLBACK,  NULL, cf_trusted_ip },
	{ "probe-interval",     STMT_T_ULONG,     &probe_interval },
	{ "ping-interval",      STMT_T_ULONG,     &ping_interval },
	{ "ping-count",         STMT_T_ULONG,     &ping_count },
	{ "tolerance",          STMT_T_ULONG,     &ping_tolerance },
	{ "ip-list",            STMT_T_CALLBACK,  NULL, cf_ip_list },
	{ "data-length",        STMT_T_ULONG,     &data_length },
	{ "syslog-facility",    STMT_T_CALLBACK,  NULL, cf_syslog_facility },
	{ "access-log",         STMT_T_BOOL,      &httpd_access_log },
	{ "access-log-verbose", STMT_T_BOOL,      &httpd_log_verbose },
	{ NULL }
};

static struct cf_stmt *
find_stmt(char const *kw)
{
	struct cf_stmt *cf;
	for (cf = statements; cf->kw; cf++) {
		if (strcmp(cf->kw, kw) == 0)
			return cf;
	}
	return NULL;
}

static int
stmt_parse(char const *kw, char const *val, char const *file, unsigned line)
{
	struct cf_stmt *cf = find_stmt(kw);
	union cf_callback_arg arg;
	
	if (!cf) {
		error("%s:%d: unrecognized keyword", file, line);
		return -1;
	}

	switch (cf->type) {
	case STMT_T_STRING:
		*(char**)cf->data = estrdup(val);
		break;
		
	case STMT_T_ULONG:
		return get_num(val, cf->data, file, line);
			
	case STMT_T_BOOL: {
		static char *t_val[] = { "1", "t", "true", "yes", "on", NULL };
		static char *f_val[] = { "0", "f", "nil", "false", "no", "off", NULL };
		int i;
		for (i = 0; t_val[i]; i++) {
			if (strcasecmp(t_val[i], val) == 0) {
				*(int*)cf->data = 1;
				return 0;
			}
		}
		for (i = 0; f_val[i]; i++) {
			if (strcasecmp(f_val[i], val) == 0) {
				*(int*)cf->data = 0;
				return 0;
			}
		}
		error("%s:%d: not a valid boolean value", file, line);
		return -1;
	}
		
	case STMT_T_CALLBACK:
		arg.input.val = val;
		arg.input.file = file;
		arg.input.line = line;
		return cf->callback(CF_PARSE, &arg, cf->data);

	default:
		abort();
	}
	return 0;
}

int
readconfig(char const *file)
{
	FILE *fp;
	char buf[1024];
	unsigned ln = 0;
	int skip_to_eol = 0;
	int ec = 0;
	
	fp = fopen(file, "r");
	if (!fp) {
		error("can't open file %s: %s", file,
		      strerror(errno));
		exit(1);
	}
	
        while (fgets(buf, sizeof(buf), fp)) {
		int len;
		char *kw, *p;
		
		ln++;
		len = strlen(buf);
		if (len == 0)
			continue;

		if (skip_to_eol) {
			skip_to_eol = buf[len-1] != '\n';
			continue;
		}
		
		if (buf[len-1] == '\n')
			buf[--len] = 0;
		else if (!feof(fp)) {
			error("%s:%d: line too long", file, ln);
			skip_to_eol = 1;
			ec = 1;
			continue;
		}

		while (len > 0 && isspace(buf[len-1]))
			buf[--len] = 0;

		if (len == 0)
			continue;

		for (p = buf; (*p == ' ' || *p == '\t'); p++)
			;
		if (*p == 0 || *p == '#')
			continue;
		kw = p;

		while (*p && isascii(*p) && (isalnum(*p) || *p == '_' || *p == '-'))
		     p++;
		if (*p)
			*p++ = 0;
		while (*p == ' ' || *p == '\t')
			p++;
		
		if (!*p) {
			error("%s:%d: malformed statement", file, ln);
			ec = 1;
			continue;
		}

		if (stmt_parse(kw, p, file, ln)) {
			ec = 1;
		}
	}
	fclose(fp);

	if ((double) ping_count * ping_interval >= probe_interval) {
		error("configuration error: ping_count * ping_interval >= probe_interval");
		ec = 1;
	}
	
	return ec;
}

struct json_value *
config_to_json(void)
{
	struct cf_stmt *cf;
	struct json_value *obj = json_new_object();
	struct json_value *vn;
	union cf_callback_arg arg;

	if (!obj)
		goto err;

	for (cf = statements; cf->kw; cf++) {
		switch (cf->type) {
		case STMT_T_STRING:
			if (*(char**)cf->data == NULL)
				vn = json_new_null();
			else
				vn = json_new_string(*(char**)cf->data);
			break;

		case STMT_T_ULONG:
			vn = json_new_number(*(unsigned long*)cf->data);
			break;

		case STMT_T_BOOL:
			vn = json_new_bool(*(int*)cf->data);
			break;
		
		case STMT_T_CALLBACK:
			arg.output = NULL;
			switch (cf->callback(CF_SERIALIZE, &arg, cf->data)) {
			case CF_RET_OK:
				vn = arg.output;
				break;

			case CF_RET_IGNORE:
				continue;
				
			default:
				goto err;
			}
		}
		if (json_object_set(obj, cf->kw, vn)) {
			json_value_free(vn);
			goto err;
		}
	} 
	return obj;
  err:
	json_value_free(obj);
	return NULL;
}