/*

 * Soft:        Keepalived is a failover program for the LVS project

 *              <www.linuxvirtualserver.org>. It monitor & manipulate

 *              a loadbalanced server pool using multi-layer checks.

 *

 * Part:        Configuration file parser/reader. Place into the dynamic

 *              data structure representation the conf file representing

 *              the loadbalanced server pool.

 *

 * Author:      Alexandre Cassen, <acassen@linux-vs.org>

 *

 *              This program 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.

 *

 *              This program 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

 *              2 of the License, or (at your option) any later version.

 *

 * Copyright (C) 2001-2017 Alexandre Cassen, <acassen@gmail.com>

 */

#include "config.h"

#include <stdlib.h>

#include <stdint.h>

#include <stdbool.h>

#include <unistd.h>

#include <pwd.h>

#include <grp.h>

#include <ctype.h>

#include <sched.h>

#include <strings.h>

#include <sys/types.h>

#include <sys/stat.h>

#ifdef _WITH_SNMP_

#include "snmp.h"

#endif

#include "global_parser.h"

#include "global_data.h"

#include "main.h"

#include "parser.h"

#include "smtp.h"

#include "utils.h"

#include "logger.h"

#ifdef _WITH_FIREWALL_

#include "vrrp_firewall.h"

#endif

#include "memory.h"

#if HAVE_DECL_CLONE_NEWNET

#include "namespaces.h"

#endif

/* Defined in kernel source file include/linux/sched.h but

 * not currently exposed to userspace */

#ifndef TASK_COMM_LEN

#define TASK_COMM_LEN	16

#endif

/* data handlers */

/* Global def handlers */

#ifdef _WITH_LINKBEAT_

static void

use_polling_handler(const vector_t *strvec)

{

	if (!strvec)

		return;

	global_data->linkbeat_use_polling = true;

}

#endif

static void

save_process_name(char const **dest, const char *src)

{

	size_t len;

	if (!src) {

		report_config_error(CONFIG_GENERAL_ERROR, "Process name missing");

		return;

	}

	if (*dest)

		FREE_CONST_PTR(*dest);

	if ((len = strlen(src)) >= TASK_COMM_LEN) {

		report_config_error(CONFIG_GENERAL_ERROR, "Process name %s more than %d characters, truncating", src, TASK_COMM_LEN - 1);

		len = TASK_COMM_LEN - 1;

	}

	*dest = STRNDUP(src, len);

}

static void

process_names_handler(__attribute__((unused)) const vector_t *strvec)

{

#ifdef _WITH_VRRP_

	save_process_name(&global_data->vrrp_process_name, "keepalived_vrrp");

#endif

#ifdef _WITH_LVS_

	save_process_name(&global_data->lvs_process_name, "keepalived_lvs");

#endif

#ifdef _WITH_BFD_

	save_process_name(&global_data->bfd_process_name, "keepalived_bfd");

#endif

}

static void

process_name_handler(const vector_t *strvec)

{

	save_process_name(&global_data->process_name, strvec_slot(strvec, 1));

}

#ifdef _WITH_VRRP_

static void

vrrp_process_name_handler(const vector_t *strvec)

{

	save_process_name(&global_data->vrrp_process_name, strvec_slot(strvec, 1));

}

#endif

#ifdef _WITH_LVS_

static void

lvs_process_name_handler(const vector_t *strvec)

{

	save_process_name(&global_data->lvs_process_name, strvec_slot(strvec, 1));

}

#endif

#ifdef _WITH_BFD_

static void

bfd_process_name_handler(const vector_t *strvec)

{

	save_process_name(&global_data->bfd_process_name, strvec_slot(strvec, 1));

}

#endif

static void

routerid_handler(const vector_t *strvec)

{

	if (vector_size(strvec) < 2) {

		report_config_error(CONFIG_GENERAL_ERROR, "routerid name missing - ignoring");

		return;

	}

	FREE_CONST_PTR(global_data->router_id);

	global_data->router_id = set_value(strvec);

}

static void

emailfrom_handler(const vector_t *strvec)

{

	if (vector_size(strvec) < 2) {

		report_config_error(CONFIG_GENERAL_ERROR, "emailfrom missing - ignoring");

		return;

	}

	FREE_CONST_PTR(global_data->email_from);

	global_data->email_from = set_value(strvec);

}

static void

smtpto_handler(const vector_t *strvec)

{

	unsigned timeout;

	/* The min value should be 1, but allow 0 to maintain backward compatibility

	 * with pre v2.0.7 */

	if (!read_unsigned_strvec(strvec, 1, &timeout, 0, UINT_MAX / TIMER_HZ, true)) {

		report_config_error(CONFIG_GENERAL_ERROR, "smtp_connect_timeout '%s' must be in [0, %u] - ignoring", strvec_slot(strvec, 1), UINT_MAX / TIMER_HZ);

		return;

	}

	if (timeout == 0) {

		report_config_error(CONFIG_GENERAL_ERROR, "smtp_conect_timeout must be greater than 0, setting to 1");

		timeout = 1;

	}

	global_data->smtp_connection_to = timeout * TIMER_HZ;

}

#ifdef _WITH_VRRP_

static void

dynamic_interfaces_handler(const vector_t *strvec)

{

	const char *str;

	global_data->dynamic_interfaces = true;

	if (vector_size(strvec) >= 2) {

		str = strvec_slot(strvec, 1);

		if (!strcmp(str, "allow_if_changes"))

			global_data->allow_if_changes = true;

		else

			report_config_error(CONFIG_GENERAL_ERROR, "Unknown dynamic_interfaces option '%s'",str);

	}

}

static void

no_email_faults_handler(__attribute__((unused))const vector_t *strvec)

{

	global_data->no_email_faults = true;

}

#endif

static void

smtpserver_handler(const vector_t *strvec)

{

	bool ret = true;

	const char *port_str = SMTP_PORT_STR;

	/* Has a port number been specified? */

	if (vector_size(strvec) >= 3)

		port_str = strvec_slot(strvec,2);

	/* It can't be an IP address if it contains '-' or '/' */

	if (!strpbrk(strvec_slot(strvec, 1), "-/"))

		ret = inet_stosockaddr(strvec_slot(strvec, 1), port_str, &global_data->smtp_server);

	if (ret)

		domain_stosockaddr(strvec_slot(strvec, 1), port_str, &global_data->smtp_server);

	if (global_data->smtp_server.ss_family == AF_UNSPEC)

		report_config_error(CONFIG_GENERAL_ERROR, "Invalid smtp server %s %s", strvec_slot(strvec, 1), port_str);

}

static void

smtphelo_handler(const vector_t *strvec)

{

	if (vector_size(strvec) < 2)

		return;

	global_data->smtp_helo_name = STRDUP(strvec_slot(strvec, 1));

}

static void

email_handler(const vector_t *strvec)

{

	const vector_t *email_vec = read_value_block(strvec);

	unsigned int i;

	char *str;

	if (!email_vec) {

		report_config_error(CONFIG_GENERAL_ERROR, "Warning - empty notification_email block");

		return;

	}

	for (i = 0; i < vector_size(email_vec); i++) {

		str = vector_slot(email_vec, i);

		alloc_email(str);

	}

	free_strvec(email_vec);

}

static void

smtp_alert_handler(const vector_t *strvec)

{

	int res = true;

	if (vector_size(strvec) >= 2) {

		res = check_true_false(strvec_slot(strvec,1));

		if (res < 0) {

			report_config_error(CONFIG_GENERAL_ERROR, "Invalid value '%s' for global smtp_alert specified", strvec_slot(strvec, 1));

			return;

		}

	}

	global_data->smtp_alert = res;

}

static void

startup_shutdown_script(const vector_t *strvec, notify_script_t **script, bool startup)

{

	const char *type = startup ? "startup" : "shutdown";

	if (*script) {

		report_config_error(CONFIG_GENERAL_ERROR, "%s script already specified", type);

		return;

	}

	if (vector_size(strvec) < 2) {

		report_config_error(CONFIG_GENERAL_ERROR, "%s script missing", type);

		return;

	}

	if (!(*script = notify_script_init(0, type))) {

		report_config_error(CONFIG_GENERAL_ERROR, "Invalid %s script", type);

		return;

	}

	if (startup) {

		if (!global_data->startup_script_timeout)

			global_data->startup_script_timeout = 10;

	} else {

		if (!global_data->shutdown_script_timeout)

			global_data->shutdown_script_timeout = 10;

	}

}

static void

startup_shutdown_script_timeout_handler(const vector_t *strvec, bool startup)

{

	const char *type = startup ? "startup" : "shutdown";

	unsigned delay;

	if (vector_size(strvec) < 2) {

		report_config_error(CONFIG_GENERAL_ERROR, "%s_script_timeout requires value", type);

		return;

	}

	if (!read_unsigned_strvec(strvec, 1, &delay, 1, 1000, true)) {

		report_config_error(CONFIG_GENERAL_ERROR, "%s_script_timeout '%s' must be in [1, 1000] - ignoring", type, strvec_slot(strvec, 1));

		return;

	}

	if (startup)

		global_data->startup_script_timeout = delay;

	else

		global_data->shutdown_script_timeout = delay;

}

static void

startup_script_handler(const vector_t *strvec)

{

	startup_shutdown_script(strvec, &global_data->startup_script, true);

}

static void

startup_script_timeout_handler(const vector_t *strvec)

{

	startup_shutdown_script_timeout_handler(strvec, true);

}

static void

shutdown_script_handler(const vector_t *strvec)

{

	startup_shutdown_script(strvec, &global_data->shutdown_script, false);

}

static void

shutdown_script_timeout_handler(const vector_t *strvec)

{

	startup_shutdown_script_timeout_handler(strvec, false);

}

static void

max_auto_priority_handler(const vector_t *strvec)

{

	int priority;

	int max_priority = sched_get_priority_max(SCHED_RR);

	if (vector_size(strvec) < 2) {

		global_data->max_auto_priority = max_priority;

		return;

	}

	if (!read_int_strvec(strvec, 1, &priority, -1, max_priority, true)) {

		report_config_error(CONFIG_GENERAL_ERROR, "max_auto_priority '%s' must be in [0, %d] (or -1 to disable) - ignoring", strvec_slot(strvec, 1), max_priority);

		return;

	}

	global_data->max_auto_priority = priority;

}

static void

min_auto_priority_delay_handler(const vector_t *strvec)

{

	int delay;

	if (vector_size(strvec) < 2) {

		report_config_error(CONFIG_GENERAL_ERROR, "min_auto_priority_delay requires delay time");

		return;

	}

	if (!read_int_strvec(strvec, 1, &delay, 1, 10000000, true)) {

		report_config_error(CONFIG_GENERAL_ERROR, "min_auto_priority_delay '%s' must be in [1, 10000000] - ignoring", strvec_slot(strvec, 1));

		return;

	}

	global_data->min_auto_priority_delay = delay;

}

#ifdef _WITH_VRRP_

static void

smtp_alert_vrrp_handler(const vector_t *strvec)

{

	int res = true;

	if (vector_size(strvec) >= 2) {

		res = check_true_false(strvec_slot(strvec,1));

		if (res < 0) {

			report_config_error(CONFIG_GENERAL_ERROR, "Invalid value '%s' for global smtp_alert_vrrp specified", strvec_slot(strvec, 1));

			return;

		}

	}

	global_data->smtp_alert_vrrp = res;

}

#endif

#ifdef _WITH_LVS_

static void

smtp_alert_checker_handler(const vector_t *strvec)

{

	int res = true;

	if (vector_size(strvec) >= 2) {

		res = check_true_false(strvec_slot(strvec,1));

		if (res < 0) {

			report_config_error(CONFIG_GENERAL_ERROR, "Invalid value '%s' for global smtp_alert_checker specified", strvec_slot(strvec, 1));

			return;

		}

	}

	global_data->smtp_alert_checker = res;

}

static void

checker_log_all_failures_handler(const vector_t *strvec)

{

	int res = true;

	if (vector_size(strvec) >= 2) {

		res = check_true_false(strvec_slot(strvec,1));

		if (res < 0) {

			report_config_error(CONFIG_GENERAL_ERROR, "Invalid value for checker_log_all_failures specified");

			return;

		}

	}

	global_data->checker_log_all_failures = res;

}

#endif

#ifdef _WITH_VRRP_

static void

default_interface_handler(const vector_t *strvec)

{

	if (vector_size(strvec) < 2) {

		report_config_error(CONFIG_GENERAL_ERROR, "default_interface requires interface name");

		return;

	}

	FREE_CONST_PTR(global_data->default_ifname);

	global_data->default_ifname = set_value(strvec);

}

#endif

#ifdef _WITH_LVS_

static void

lvs_timeouts(const vector_t *strvec)

{

	unsigned val;

	size_t i;

	if (vector_size(strvec) < 3) {

		report_config_error(CONFIG_GENERAL_ERROR, "lvs_timeouts requires at least one option");

		return;

	}

	for (i = 1; i < vector_size(strvec); i++) {

		if (!strcmp(strvec_slot(strvec, i), "tcp")) {

			if (i == vector_size(strvec) - 1) {

				report_config_error(CONFIG_GENERAL_ERROR, "No value specified for lvs_timeout tcp - ignoring");

				continue;

			}

			if (!read_unsigned_strvec(strvec, i + 1, &val, 0, LVS_MAX_TIMEOUT, false))

				report_config_error(CONFIG_GENERAL_ERROR, "Invalid lvs_timeout tcp (%s) - ignoring", strvec_slot(strvec, i+1));

			else

				global_data->lvs_timeouts.tcp_timeout = val;

			i++;	/* skip over value */

			continue;

		}

		if (!strcmp(strvec_slot(strvec, i), "tcpfin")) {

			if (i == vector_size(strvec) - 1) {

				report_config_error(CONFIG_GENERAL_ERROR, "No value specified for lvs_timeout tcpfin - ignoring");

				continue;

			}

			if (!read_unsigned_strvec(strvec, i + 1, &val, 0, LVS_MAX_TIMEOUT, false))

				report_config_error(CONFIG_GENERAL_ERROR, "Invalid lvs_timeout tcpfin (%s) - ignoring", strvec_slot(strvec, i+1));

			else

				global_data->lvs_timeouts.tcp_fin_timeout = val;

			i++;	/* skip over value */

			continue;

		}

		if (!strcmp(strvec_slot(strvec, i), "udp")) {

			if (i == vector_size(strvec) - 1) {

				report_config_error(CONFIG_GENERAL_ERROR, "No value specified for lvs_timeout udp - ignoring");

				continue;

			}

			if (!read_unsigned_strvec(strvec, i + 1, &val, 0, LVS_MAX_TIMEOUT, false))

				report_config_error(CONFIG_GENERAL_ERROR, "Invalid lvs_timeout udp (%s) - ignoring", strvec_slot(strvec, i+1));

			else

				global_data->lvs_timeouts.udp_timeout = val;

			i++;	/* skip over value */

			continue;

		}

		report_config_error(CONFIG_GENERAL_ERROR, "Unknown option %s specified for lvs_timeouts", strvec_slot(strvec, i));

	}

}

#if defined _WITH_LVS_ && defined _WITH_VRRP_

static void

lvs_syncd_handler(const vector_t *strvec)

{

	unsigned val;

	size_t i;

	if (global_data->lvs_syncd.ifname) {

		report_config_error(CONFIG_GENERAL_ERROR, "lvs_sync_daemon has already been specified as %s %s - ignoring", global_data->lvs_syncd.ifname, global_data->lvs_syncd.vrrp_name ? global_data->lvs_syncd.vrrp_name : "");

		return;

	}

	if (vector_size(strvec) < 2) {

		report_config_error(CONFIG_GENERAL_ERROR, "lvs_sync_daemon requires interface");

		return;

	}

	if (strlen(strvec_slot(strvec, 1)) >= IP_VS_IFNAME_MAXLEN) {

		report_config_error(CONFIG_GENERAL_ERROR, "lvs_sync_daemon interface name '%s' too long - ignoring", strvec_slot(strvec, 1));

		return;

	}

	global_data->lvs_syncd.ifname = set_value(strvec);

	for (i = 2; i < vector_size(strvec); i++) {

#ifdef _WITH_VRRP_

		if (!strcmp(strvec_slot(strvec, i), "inst")) {

			if (global_data->lvs_syncd.vrrp_name)

				report_config_error(CONFIG_GENERAL_ERROR, "lvs_sync_daemon vrrp instance has already been specified as %s - ignoring", global_data->lvs_syncd.vrrp_name);

			else

				global_data->lvs_syncd.vrrp_name = STRDUP(strvec_slot(strvec, i + 1));

			i++;	/* skip over value */

			continue;

		}

#endif

		if (!strcmp(strvec_slot(strvec, i), "id")) {

			if (i == vector_size(strvec) - 1) {

				report_config_error(CONFIG_GENERAL_ERROR, "No value specified for lvs_sync_daemon id, defaulting to vrid");

				continue;

			}

			if (!read_unsigned_strvec(strvec, i + 1, &val, 0, 255, false))

				report_config_error(CONFIG_GENERAL_ERROR, "Invalid syncid (%s) - defaulting to vrid", strvec_slot(strvec, i+1));

			else

				global_data->lvs_syncd.syncid = val;

			i++;	/* skip over value */

			continue;

		}

#ifdef _HAVE_IPVS_SYNCD_ATTRIBUTES_

		if (!strcmp(strvec_slot(strvec, i), "maxlen")) {

			if (i == vector_size(strvec) - 1) {

				report_config_error(CONFIG_GENERAL_ERROR, "No value specified for lvs_sync_daemon maxlen - ignoring");

				continue;

			}

			if (!read_unsigned_strvec(strvec, i + 1, &val, 1, 65535 - 20 - 8, false))

				report_config_error(CONFIG_GENERAL_ERROR, "Invalid lvs_sync_daemon maxlen (%s) - ignoring", strvec_slot(strvec, i+1));

			else

				global_data->lvs_syncd.sync_maxlen = (uint16_t)val;

			i++;	/* skip over value */

			continue;

		}

		if (!strcmp(strvec_slot(strvec, i), "port")) {

			if (i == vector_size(strvec) - 1) {

				report_config_error(CONFIG_GENERAL_ERROR, "No value specified for lvs_sync_daemon port - ignoring");

				continue;

			}

			if (!read_unsigned_strvec(strvec, i + 1, &val, 1, 65535, false))

				report_config_error(CONFIG_GENERAL_ERROR, "Invalid lvs_sync_daemon port (%s) - ignoring", strvec_slot(strvec, i+1));

			else

				global_data->lvs_syncd.mcast_port = (uint16_t)val;

			i++;	/* skip over value */

			continue;

		}

		if (!strcmp(strvec_slot(strvec, i), "ttl")) {

			if (i == vector_size(strvec) - 1) {

				report_config_error(CONFIG_GENERAL_ERROR, "No value specified for lvs_sync_daemon ttl - ignoring");

				continue;

			}

			if (!read_unsigned_strvec(strvec, i + 1, &val, 1, 255, false))

				report_config_error(CONFIG_GENERAL_ERROR, "Invalid lvs_sync_daemon ttl (%s) - ignoring", strvec_slot(strvec, i+1));

			else

				global_data->lvs_syncd.mcast_ttl = (uint8_t)val;

			i++;	/* skip over value */

			continue;

		}

		if (!strcmp(strvec_slot(strvec, i), "group")) {

			if (i == vector_size(strvec) - 1) {

				report_config_error(CONFIG_GENERAL_ERROR, "No value specified for lvs_sync_daemon group - ignoring");

				continue;

			}

			if (inet_stosockaddr(strvec_slot(strvec, i+1), NULL, &global_data->lvs_syncd.mcast_group))

				report_config_error(CONFIG_GENERAL_ERROR, "Invalid lvs_sync_daemon group (%s) - ignoring", strvec_slot(strvec, i+1));

			if ((global_data->lvs_syncd.mcast_group.ss_family == AF_INET  && !IN_MULTICAST(htonl(((struct sockaddr_in *)&global_data->lvs_syncd.mcast_group)->sin_addr.s_addr))) ||

			    (global_data->lvs_syncd.mcast_group.ss_family == AF_INET6 && !IN6_IS_ADDR_MULTICAST(&((struct sockaddr_in6 *)&global_data->lvs_syncd.mcast_group)->sin6_addr))) {

				report_config_error(CONFIG_GENERAL_ERROR, "lvs_sync_daemon group address %s is not multicast - ignoring", strvec_slot(strvec, i+1));

				global_data->lvs_syncd.mcast_group.ss_family = AF_UNSPEC;

			}

			i++;	/* skip over value */

			continue;

		}

#endif

		/* The following are for backward compatibility when lvs_sync_daemon IF VRRP_INSTANCE [SYNC_ID] could be specified */

		if (i == 2) {

			global_data->lvs_syncd.vrrp_name = STRDUP(strvec_slot(strvec, 2));

			continue;

		}

		if (i == 3) {

			if (!read_unsigned_strvec(strvec, 3, &val, 0, 255, false))

				report_config_error(CONFIG_GENERAL_ERROR, "Invalid syncid (%s) - defaulting to vrid", strvec_slot(strvec, 3));

			else {

				report_config_error(CONFIG_GENERAL_ERROR, "Please use keyword \"id\" before lvs_sync_daemon syncid value");

				global_data->lvs_syncd.syncid = val;

			}

			continue;

		}

		/* We haven't matched anything */

		report_config_error(CONFIG_GENERAL_ERROR, "Unknown option %s specified for lvs_sync_daemon", strvec_slot(strvec, i));

	}

}

#endif

static void

lvs_flush_handler(__attribute__((unused)) const vector_t *strvec)

{

	global_data->lvs_flush = true;

}

static void

lvs_flush_onstop_handler(const vector_t *strvec)

{

	if (vector_size(strvec) == 1)

		global_data->lvs_flush_onstop = LVS_FLUSH_FULL;

	else if (!strcmp(strvec_slot(strvec, 1), "VS"))

		global_data->lvs_flush_onstop = LVS_FLUSH_VS;

	else

		report_config_error(CONFIG_GENERAL_ERROR, "Unknown lvs_flush_onstop type %s", strvec_slot(strvec, 1));

}

#endif

static int

get_realtime_priority(const vector_t *strvec, const char *process)

{

	int min_priority;

	int max_priority;

	int priority;

	if (vector_size(strvec) < 2) {

		report_config_error(CONFIG_GENERAL_ERROR, "No %s process real-time priority specified", process);

		return -1;

	}

	min_priority = sched_get_priority_min(SCHED_RR);

	max_priority = sched_get_priority_max(SCHED_RR);

	if (!read_int_strvec(strvec, 1, &priority, INT_MIN, INT_MAX, true)) {

		report_config_error(CONFIG_GENERAL_ERROR, "%s process real-time priority '%s' invalid", process, strvec_slot(strvec, 1));

		return -1;

	}

	if (priority < min_priority) {

		report_config_error(CONFIG_GENERAL_ERROR, "%s process real-time priority %d less than minimum %d - setting to minimum", process, priority, min_priority);

		priority = min_priority;

	}

	else if (priority > max_priority) {

		report_config_error(CONFIG_GENERAL_ERROR, "%s process real-time priority %d greater than maximum %d - setting to maximum", process, priority, max_priority);

		priority = max_priority;

	}

	return priority;

}

static int

get_cpu_affinity(const vector_t *strvec, cpu_set_t *set, const char *process)

{

	int cpu_id, num_cpus;

	unsigned i;

	if (!strvec)

		return -1;

	if (vector_size(strvec) < 2) {

		report_config_error(CONFIG_GENERAL_ERROR, "No %s cpu_id set specified", process);

		return -1;

	}

	CPU_ZERO(set);

	/* TODO: instead of sysconf, maybe we could fetch current cpu_set via

	 * sched_getaffinity and use CPU_COUNT */

	num_cpus = sysconf(_SC_NPROCESSORS_ONLN);

	for (i = 1; i < vector_size(strvec); i++) {

		if (!read_int_strvec(strvec, i, &cpu_id, 0, num_cpus-1, true)) {

			report_config_error(CONFIG_GENERAL_ERROR, "Invalid cpu_id:%d specified for %s process"

								, cpu_id, process);

			/* Reset cpu_set at first error */

			CPU_ZERO(set);

			return -1;

		}

		CPU_SET(cpu_id, set);

	}

	return 0;

}

#if HAVE_DECL_RLIMIT_RTTIME == 1

static rlim_t

get_rt_rlimit(const vector_t *strvec, const char *process)

{

	unsigned limit;

	rlim_t rlim;

	size_t keyword_len;

	/* *_rlimit_rtime is deprecated since 02/02/2020. Keyword should be *_rlimit_rttime */

	keyword_len = strlen(strvec_slot(strvec, 0));

	if (strvec_slot(strvec, 0)[keyword_len - 5] == 'r')

		log_message(LOG_INFO, "Keyword '%s' is deprecated - please use '%.*srttime'", strvec_slot(strvec, 0), (int)keyword_len - 5, strvec_slot(strvec, 0));

	if (!read_unsigned_strvec(strvec, 1, &limit, 1, UINT32_MAX, true)) {

		report_config_error(CONFIG_GENERAL_ERROR, "Invalid %s real-time limit - %s", process, strvec_slot(strvec, 1));

		return 0;

	}

	/* The rlim value is divided by 2 elsewhere, and the result must be

	 * non-zero, therefore we need rlim to have a minimum value of 2. */

	if (limit == 1)

		limit = 2;

	rlim = limit;

	return rlim;

}

#endif

static int8_t

get_priority(const vector_t *strvec, const char *process)

{

	int priority;

	if (vector_size(strvec) < 2) {

		report_config_error(CONFIG_GENERAL_ERROR, "No %s process priority specified", process);

		return 0;

	}

	if (!read_int_strvec(strvec, 1, &priority, -20, 19, true)) {

		report_config_error(CONFIG_GENERAL_ERROR, "Invalid %s process priority specified", process);

		return 0;

	}

	return (int8_t)priority;

}

#ifdef _WITH_VRRP_

static void

vrrp_mcast_group4_handler(const vector_t *strvec)

{

	struct sockaddr_in *mcast = &global_data->vrrp_mcast_group4;

	if (inet_stosockaddr(strvec_slot(strvec, 1), 0, (struct sockaddr_storage *)mcast))

		report_config_error(CONFIG_GENERAL_ERROR, "Configuration error: Cant parse vrrp_mcast_group4 [%s]. Skipping"

				   , strvec_slot(strvec, 1));

}

static void

vrrp_mcast_group6_handler(const vector_t *strvec)

{

	struct sockaddr_in6 *mcast = &global_data->vrrp_mcast_group6;

	if (inet_stosockaddr(strvec_slot(strvec, 1), 0, (struct sockaddr_storage *)mcast))

		report_config_error(CONFIG_GENERAL_ERROR, "Configuration error: Cant parse vrrp_mcast_group6 [%s]. Skipping"

				   , strvec_slot(strvec, 1));

}

static void

vrrp_garp_delay_handler(const vector_t *strvec)

{

	unsigned timeout;

	if (!read_unsigned_strvec(strvec, 1, &timeout, 0, UINT_MAX / TIMER_HZ, true)) {

		report_config_error(CONFIG_GENERAL_ERROR, "vrrp_garp_master_delay '%s' invalid - ignoring", strvec_slot(strvec, 1));

		return;

	}

	global_data->vrrp_garp_delay = timeout * TIMER_HZ;

}

static void

vrrp_garp_rep_handler(const vector_t *strvec)

{

	unsigned repeats;

	/* The min value should be 1, but allow 0 to maintain backward compatibility

	 * with pre v2.0.7 */

	if (!read_unsigned_strvec(strvec, 1, &repeats, 0, UINT_MAX, true)) {

		report_config_error(CONFIG_GENERAL_ERROR, "vrrp_garp_master_repeat '%s' invalid - ignoring", strvec_slot(strvec, 1));

		return;

	}

	if (repeats == 0) {

		report_config_error(CONFIG_GENERAL_ERROR, "vrrp_garp_master_repeat must be greater than 0, setting to 1");

		repeats = 1;

	}

	global_data->vrrp_garp_rep = repeats;

}

static void

vrrp_garp_refresh_handler(const vector_t *strvec)

{

	unsigned refresh;

	if (!read_unsigned_strvec(strvec, 1, &refresh, 0, UINT_MAX, true)) {

		report_config_error(CONFIG_GENERAL_ERROR, "Invalid vrrp_garp_master_refresh '%s' - ignoring", strvec_slot(strvec, 1));

		global_data->vrrp_garp_refresh.tv_sec = 0;

	}

	else

		global_data->vrrp_garp_refresh.tv_sec = refresh;

	global_data->vrrp_garp_refresh.tv_usec = 0;

}

static void

vrrp_garp_refresh_rep_handler(const vector_t *strvec)

{

	unsigned repeats;

	/* The min value should be 1, but allow 0 to maintain backward compatibility

	 * with pre v2.0.7 */

	if (!read_unsigned_strvec(strvec, 1, &repeats, 0, UINT_MAX, true)) {

		report_config_error(CONFIG_GENERAL_ERROR, "vrrp_garp_master_refresh_repeat '%s' invalid - ignoring", strvec_slot(strvec, 1));

		return;

	}

	if (repeats == 0) {

		report_config_error(CONFIG_GENERAL_ERROR, "vrrp_garp_master_refresh_repeat must be greater than 0, setting to 1");

		repeats = 1;

	}

	global_data->vrrp_garp_refresh_rep = repeats;

}

static void

vrrp_garp_lower_prio_delay_handler(const vector_t *strvec)

{

	unsigned delay;

	if (!read_unsigned_strvec(strvec, 1, &delay, 0, UINT_MAX / TIMER_HZ, true)) {

		report_config_error(CONFIG_GENERAL_ERROR, "vrrp_garp_lower_prio_delay '%s' invalid - ignoring", strvec_slot(strvec, 1));

		return;

	}

	global_data->vrrp_garp_lower_prio_delay = delay * TIMER_HZ;

}

static void

vrrp_garp_lower_prio_rep_handler(const vector_t *strvec)

{

	unsigned garp_lower_prio_rep;

	if (!read_unsigned_strvec(strvec, 1, &garp_lower_prio_rep, 0, INT_MAX, true)) {

		report_config_error(CONFIG_GENERAL_ERROR, "Invalid vrrp_garp_lower_prio_repeat '%s'", strvec_slot(strvec, 1));

		return;

	}

	global_data->vrrp_garp_lower_prio_rep = garp_lower_prio_rep;

}

static void

vrrp_garp_interval_handler(const vector_t *strvec)

{

	double interval;

	if (!read_double_strvec(strvec, 1, &interval, 1.0F / TIMER_HZ, (unsigned)(UINT_MAX / TIMER_HZ), true))

		report_config_error(CONFIG_GENERAL_ERROR, "vrrp_garp_interval '%s' is invalid", strvec_slot(strvec, 1));

	else

		global_data->vrrp_garp_interval = (unsigned)(interval * TIMER_HZ);

	if (global_data->vrrp_garp_interval >= 1 * TIMER_HZ)

		log_message(LOG_INFO, "The vrrp_garp_interval is very large - %s seconds", strvec_slot(strvec, 1));

}

static void

vrrp_gna_interval_handler(const vector_t *strvec)

{

	double interval;

	if (!read_double_strvec(strvec, 1, &interval, 1.0F / TIMER_HZ, (unsigned)(UINT_MAX / TIMER_HZ), true))

		report_config_error(CONFIG_GENERAL_ERROR, "vrrp_gna_interval '%s' is invalid", strvec_slot(strvec, 1));

	else

		global_data->vrrp_gna_interval = (unsigned)(interval * TIMER_HZ);

	if (global_data->vrrp_gna_interval >= 1 * TIMER_HZ)

		log_message(LOG_INFO, "The vrrp_gna_interval is very large - %s seconds", strvec_slot(strvec, 1));

}

static void

vrrp_min_garp_handler(const vector_t *strvec)

{

	int res = false;

	if (vector_size(strvec) >= 2) {

		res = check_true_false(strvec_slot(strvec,1));

		if (res < 0) {