#!/bin/bash
# vim: set noexpandtab tabstop=4 shiftwidth=4 softtabstop=4 :

basename="${0##*/}"

. /usr/lib/unbound/iptools.sh

export OMR_TRACKER_STATUS
export OMR_TRACKER_STATUS_MSG
export OMR_TRACKER_LATENCY
export OMR_TRACKER_LOSS
export OMR_TRACKER_SERVER_IP

_log() {
	logger -p daemon.info -t "${basename}" "$@"
}

_post_tracking() {
	[ ! -d /usr/share/omr/server-post-tracking.d/ ] && return
	for tracker_bin in /usr/share/omr/server-post-tracking.d/*; do
		[ -x "$tracker_bin" ] && (
			_log() {
				logger -t "post-tracking-${tracker_bin##*/}" "$*"
			}
			. "$tracker_bin" 2>&1
		)
	done
}

# Parse loss% and avg latency from ping -q output stored in $ret.
# Sets globals: loss (packet loss %), latency (avg ms, empty if no rtt line)
_parse_ping() {
	loss=$(printf '%s\n' "$ret" | awk '/packet loss/{gsub("%","");print $6}')
	latency=$(printf '%s\n' "$ret" | awk -F/ '/rtt/{print int($5)}')
}

_ping_server() {
	local host=$1
	ret=$(ping -w "$OMR_TRACKER_TIMEOUT" -c 1 -q "${host}" 2>&1)
	_parse_ping
	if [ -n "$loss" ] && [ "$loss" != "100" ]; then
		[ -n "$latency" ] && OMR_TRACKER_LATENCY="$latency"
		OMR_TRACKER_LOSS="$loss"
		server_ping=true
	fi
}

_ping_server_intf() {
	local host=$1
	for intf in $mp_default_intfs; do
		local k=0
		while [ "$server_ping" = false ] && [ "$k" -le "$retry" ]; do
			ret=$(ping -w "$OMR_TRACKER_TIMEOUT" -c 1 -q -I "$intf" "${host}" 2>&1)
			_parse_ping
			if [ -n "$loss" ] && [ "$loss" != "100" ]; then
				[ -n "$latency" ] && OMR_TRACKER_LATENCY="$latency"
				OMR_TRACKER_LOSS="$loss"
				server_ping=true
				if [ "$OMR_TRACKER_CHECK_QUALITY" = "1" ]; then
					if [ "$OMR_TRACKER_PREV_STATUS" = "OK" ]; then
						if [ -n "$OMR_TRACKER_LOSS" ] && [ -n "$OMR_TRACKER_RECOVERY_LOSS" ] && [ "$OMR_TRACKER_LOSS" -ge "$OMR_TRACKER_FAILURE_LOSS" ]; then
							OMR_TRACKER_STATUS="ERROR"
							OMR_TRACKER_STATUS_MSG="Packet loss is $OMR_TRACKER_LOSS this is more than failure limit defined at $OMR_TRACKER_FAILURE_LOSS"
							server_ping=false
						elif [ -n "$OMR_TRACKER_LATENCY" ] && [ -n "$OMR_TRACKER_FAILURE_LATENCY" ] && [ "$OMR_TRACKER_LATENCY" -ge "$OMR_TRACKER_FAILURE_LATENCY" ]; then
							OMR_TRACKER_STATUS="ERROR"
							OMR_TRACKER_STATUS_MSG="Latency is $OMR_TRACKER_LATENCY this is more than failure limit defined at $OMR_TRACKER_FAILURE_LATENCY"
							server_ping=false
						fi
					elif [ "$OMR_TRACKER_PREV_STATUS" = "ERROR" ]; then
						if [ -n "$OMR_TRACKER_LOSS" ] && [ -n "$OMR_TRACKER_RECOVERY_LOSS" ] && [ "$OMR_TRACKER_LOSS" -ge "$OMR_TRACKER_RECOVERY_LOSS" ]; then
							OMR_TRACKER_STATUS="ERROR"
							OMR_TRACKER_STATUS_MSG="Packet loss is $OMR_TRACKER_LOSS this is more than recovery limit defined at $OMR_TRACKER_RECOVERY_LOSS"
							server_ping=false
						elif [ -n "$OMR_TRACKER_LATENCY" ] && [ -n "$OMR_TRACKER_RECOVERY_LATENCY" ] && [ "$OMR_TRACKER_LATENCY" -ge "$OMR_TRACKER_RECOVERY_LATENCY" ]; then
							OMR_TRACKER_STATUS="ERROR"
							OMR_TRACKER_STATUS_MSG="Latency is $OMR_TRACKER_LATENCY this is more than recovery limit defined at $OMR_TRACKER_RECOVERY_LATENCY"
							server_ping=false
						fi
					fi
				fi
			fi
			k=$((k+1))
			[ "$server_ping" = false ] && sleep "${intervaltries}"
		done
	done
}

_check_server() {
	local host=$1 port=$2 k=0 url
	if [ "$(valid_subnet6 "$host")" = "ok" ]; then
		url="https://[${host}]:${port}/"
	else
		url="https://${host}:${port}/"
	fi
	while [ "$server_ping" = false ] && [ "$k" -le "$retry" ]; do
		ret=$(curl --max-time "$OMR_TRACKER_TIMEOUT" -s -k "$url")
		[ -n "$ret" ] && server_ping=true
		k=$((k+1))
		[ "$server_ping" = false ] && sleep "${intervaltries}"
	done
}

_check_server_intf() {
	local host=$1 port=$2 valid_ip6 intf k url
	valid_ip6=$(valid_subnet6 "$host")
	for intf in $mp_default_intfs; do
		if [ "$valid_ip6" = "ok" ]; then
			url="https://[${host}%${intf}]:${port}/"
		else
			url="https://${host}:${port}/"
		fi
		k=0
		while [ "$server_ping" = false ] && [ "$k" -le "$retry" ]; do
			if [ "$valid_ip6" = "ok" ]; then
				ret=$(curl --max-time "$OMR_TRACKER_TIMEOUT" -s -k "$url")
			else
				ret=$(curl --max-time "$OMR_TRACKER_TIMEOUT" -s -k --interface "$intf" "$url")
			fi
			[ -n "$ret" ] && server_ping=true
			k=$((k+1))
			[ "$server_ping" = false ] && sleep "${intervaltries}"
		done
	done
}

_get_server_name() {
	local serverid=$1
	local serverip=$2
	config_get serveripc "$serverid" server
	if [ "$serveripc" = "$serverip" ]; then
		servername=$serverid
	fi
}

_disable_current() {
	local serv=$1
	uci -q set openmptcprouter."${serv}".current=0
}

_disable_redir() {
	local redir="$1"
	local serverdisable="$2"
	local shadowsocks="$3"
	config_get serverss "$redir" server
	if [ "$serverss" = "$serverdisable" ]; then
		uci -q set "${shadowsocks}"."${redir}".disabled=1
	fi
}

_enable_redir() {
	local redir="$1"
	local shadowsocks="$2"
	config_get serverss "$redir" server
	if [ "$serverss" = "sss${count}" ]; then
		uci -q set "${shadowsocks}"."${redir}".disabled=0
	fi
}

_send_mail_alert() {
	local type="$1" name="$2" ip="$3"
	local mail_alert mail_to OMR_SYSNAME mail_subject mail_message
	mail_alert="$(uci -q get omr-tracker.server.mail_alert)"
	[ "$mail_alert" != "1" ] && return
	mail_to="$(uci -q get mail.default.to | tr -d '\r\n')"
	case "$mail_to" in
		-*|*[[:space:]]*) mail_to="" ;;
	esac
	[ -z "$mail_to" ] && return
	OMR_SYSNAME="$(uci -q get system.@system[0].hostname)"
	mail_subject="$(uci -q get omr-tracker.defaults.mail_${type}_subject)"
	mail_message="$(uci -q get omr-tracker.defaults.mail_${type}_message)"
	if [ -n "$mail_subject" ] && [ -n "$mail_message" ]; then
		mail_subject=$(echo "$mail_subject" | sed -e "s/%SYSNAME%/$OMR_SYSNAME/g" -e "s/%INTERFACE%/Server ${name}/g" -e "s/%DEVICE%/${ip}/g" -e "s/%MESSAGE%/$OMR_TRACKER_STATUS_MSG/g")
		mail_subject="$(printf '%s' "$mail_subject" | tr -d '\r\n')"
		mail_message=$(echo "$mail_message" | sed -e "s/%SYSNAME%/$OMR_SYSNAME/g" -e "s/%INTERFACE%/Server ${name}/g" -e "s/%DEVICE%/${ip}/g" -e "s/%MESSAGE%/$OMR_TRACKER_STATUS_MSG/g")
		printf 'Subject: %s\n\n%s\n' "$mail_subject" "$mail_message" | sendmail "$mail_to"
	else
		local status_word
		[ "$type" = "up" ] && status_word="UP" || status_word="down"
		mail_subject="$(printf '%s' "$OMR_SYSNAME: Server ${name} (${ip}) is ${status_word}" | tr -d '\r\n')"
		printf 'Subject: %s\n\nThe reason is "%s".\n' "$mail_subject" "$OMR_TRACKER_STATUS_MSG" | sendmail "$mail_to"
	fi
}

_apply_server_config() {
	local ip="$1" name="$2"
	uci -q batch <<-EOF >/dev/null
		set xray.omrout.s_vmess_address="$ip"
		set xray.omrout.s_vless_address="$ip"
		set xray.omrout.s_vless_reality_address="$ip"
		set xray.omrout.s_trojan_address="$ip"
		set xray.omrout.s_socks_address="$ip"
		set xray.omrout.s_shadowsocks_address="$ip"
		set v2ray.omrout.s_vmess_address="$ip"
		set v2ray.omrout.s_vless_address="$ip"
		set v2ray.omrout.s_trojan_address="$ip"
		set v2ray.omrout.s_socks_address="$ip"
		commit v2ray
		commit xray
		set glorytun.vpn.host="$ip"
		commit glorytun
		set glorytun-udp.vpn.host="$ip"
		commit glorytun-udp
		set dsvpn.vpn.host="$ip"
		commit dsvpn
		set mlvpn.general.host="$ip"
		commit mlvpn
		del openvpn.omr.remote
		add_list openvpn.omr.remote="$ip"
		commit openvpn
	EOF
	/etc/init.d/openmptcprouter-vps get_openvpn_key "$name" >/dev/null 2>&1
	/etc/init.d/v2ray restart >/dev/null 2>&1
	/etc/init.d/xray restart >/dev/null 2>&1
	/etc/init.d/glorytun restart >/dev/null 2>&1
	/etc/init.d/glorytun-udp restart >/dev/null 2>&1
	/etc/init.d/mlvpn restart >/dev/null 2>&1
	/etc/init.d/dsvpn restart >/dev/null 2>&1
	/etc/init.d/mptcpovervpn restart >/dev/null 2>&1
}

# Enable SS redirs for both libev and rust (shared by master and backup set_ip)
_enable_ss_redirs() {
	config_load shadowsocks-libev
	config_foreach _enable_redir ss_redir "shadowsocks-libev"
	config_load shadowsocks-rust
	config_foreach _enable_redir ss_redir "shadowsocks-rust"
}

# Disable SS redirs for the server that owns $1 (IP address)
_disable_ss_redirs_by_ip() {
	local ip=$1
	servername=""
	config_load shadowsocks-libev
	config_foreach _get_server_name server "$ip"
	[ -n "$servername" ] && config_foreach _disable_redir ss_redir "$servername" "shadowsocks-libev"
	servername=""
	config_load shadowsocks-rust
	config_foreach _get_server_name server "$ip"
	[ -n "$servername" ] && config_foreach _disable_redir ss_redir "$servername" "shadowsocks-rust"
}

# Resolve hostname/IP $1 to a numeric address; sets global $serverip.
# This runs on every check cycle, so a literal IP short-circuits without the
# resolveip fork, and hostname lookups are cached for 300s (a failed lookup
# is not cached, so it retries next cycle).
declare -A _resolve_cache _resolve_cache_ts
_resolve_ip() {
	local ipd=$1 r now
	case "$ipd" in
		*:*) serverip="$ipd"; return ;;      # literal IPv6 (hostnames have no colon)
		*[!0-9.]*) ;;                         # letters present: hostname, resolve below
		*[0-9]*) serverip="$ipd"; return ;;  # digits and dots only: literal IPv4
	esac
	printf -v now '%(%s)T' -1
	if [ -n "${_resolve_cache[$ipd]}" ] && [ $((now - _resolve_cache_ts[$ipd])) -lt 300 ]; then
		serverip="${_resolve_cache[$ipd]}"
		return
	fi
	r=$(resolveip -t 5 -4 "$ipd" | head -n 1)
	if [ -n "$r" ]; then
		serverip="$r"
	else
		r=$(resolveip -t 5 -6 "$ipd" | head -n 1)
		[ -n "$r" ] && serverip="$r"
	fi
	if [ -n "$serverip" ]; then
		_resolve_cache[$ipd]="$serverip"
		_resolve_cache_ts[$ipd]=$now
	fi
}

# Restart proxy/DNS services after a config change
_restart_proxy_services() {
	/etc/init.d/shadowsocks-libev restart >/dev/null 2>&1
	/etc/init.d/shadowsocks-rust restart >/dev/null 2>&1
	/etc/init.d/openvpn restart omr >/dev/null 2>&1
	/etc/init.d/unbound restart >/dev/null 2>&1
	/etc/init.d/dnsmasq restart >/dev/null 2>&1
}

# Common check_ip body used by both _check_master and _check_backup.
# Resolves ipd, runs the configured check type, then calls set_ip (defined
# by the caller before config_list_foreach).
_do_check_ip() {
	local ipd=$1
	server_ping=false
	serverip=""
	_resolve_ip "$ipd"
	[ -z "$serverip" ] && return
	if [ "$OMR_TRACKER_TYPE" = "api" ]; then
		_check_server_intf "$serverip" "$port"
	elif [ "$OMR_TRACKER_TYPE" = "apiping" ]; then
		_check_server_intf "$serverip" "$port"
		[ "$server_ping" = false ] && _ping_server_intf "$serverip"
	elif [ "$OMR_TRACKER_TYPE" = "ping" ]; then
		_ping_server_intf "$serverip"
	elif [ "$OMR_TRACKER_TYPE" = "none" ]; then
		server_ping=true
	fi
	[ "$server_ping" = true ] && oneserverup="1"
	countips=$((countips+1))
	set_ip
}

_check_master() {
	local name=$1
	local count=0
	local countips=0
	local changes="0"
	config_get master "$1" master
	config_get ip "$1" ip
	config_get port "$1" port "65500"
	config_get disabled "$1" disabled
	serverip=""
	[ "$master" = "1" ] && [ -n "$ip" ] && [ "$disabled" != "1" ] && {
		set_ip() {
			ip="$serverip"
			local ss_libev_server ss_rust_server
			local state_key="m:${name}:${countips}"
			ss_libev_server=$(uci -q get shadowsocks-libev.sss${count}.server)
			ss_rust_server=$(uci -q get shadowsocks-rust.sss${count}.server)
			if [ "$server_ping" = true ]; then
				if { [ -n "$(uci -q get shadowsocks-libev)" ] && [ "$ss_libev_server" != "$ip" ]; } || \
				   { [ -n "$(uci -q get shadowsocks-rust)" ] && [ "$ss_rust_server" != "$ip" ]; } || \
				   { [ -n "$(uci -q get openvpn.omr)" ] && [ -z "$(uci -q get openvpn.omr.remote | grep "$ip")" ]; }; then
					logger -t "OMR-Tracker-Server" "Master server ${name} up ($ip), set it back"
					changes="1"
					uci -q batch <<-EOF >/dev/null
						set shadowsocks-libev.sss${count}.server="$ip"
						set shadowsocks-rust.sss${count}.server="$ip"
						set openmptcprouter.${name}.current='1'
						del openmptcprouter.omr.detected_ss_ipv4
						del openmptcprouter.omr.detected_public_ipv4
						del openmptcprouter.omr.detected_ss_ipv6
						del openmptcprouter.omr.detected_public_ipv6
						commit openmptcprouter
					EOF
					[ -z "$(uci -q get openvpn.omr.remote | grep "$ip")" ] && \
						uci -q add_list openvpn.omr.remote="$ip"
					if [ "$count" -eq "0" ]; then
						config_load openmptcprouter
						config_foreach _disable_current server
						_apply_server_config "$ip" "$name"
					fi
				fi
				OMR_TRACKER_STATUS_MSG="Answer to ping and to API check"
				# Steady state (already up last cycle, config untouched): the
				# redir re-enable walk, ip_down bookkeeping and up-alert only
				# matter on a down->up transition or after a config fix, and
				# their config_load/uci churn was most of this daemon's
				# idle-cycle CPU cost. The mail/script alerts also belong on
				# the transition only: one alert per event, not one per cycle.
				if [ "${_srv_prev_up[$state_key]}" != "1" ] || [ "$changes" = "1" ]; then
					_proxy=$(uci -q get openmptcprouter.settings.proxy)
					_vpn=$(uci -q get openmptcprouter.settings.vpn)
					[ "$_proxy" = "shadowsocks-rust" ] && uci -q set shadowsocks-rust.sss${count}.disabled=0
					[ "$_proxy" = "shadowsocks" ]      && uci -q set shadowsocks-libev.sss${count}.disabled=0
					[ "$_vpn"   = "openvpn" ]          && uci -q set openvpn.omr.enabled=1
					_enable_ss_redirs
					[ -n "$ip" ] && [ -n "$(uci -q get openmptcprouter.${name}.ip_down | grep -w "$ip")" ] && \
						uci -q del_list openmptcprouter.${name}.ip_down="$ip"
					uci -q set openmptcprouter.${name}.current='1'
					_send_mail_alert "up" "$name" "$ip"
				fi
				_srv_prev_up[$state_key]="1"
				OMR_TRACKER_SERVER_IP="$ip"
				OMR_TRACKER_STATUS="OK"
				script_alert_up=$(uci -q get omr-tracker.proxy.script_alert_up)
				[ -n "$script_alert_up" ] && eval "$script_alert_up"
				count=$((count+1))
			else
				OMR_TRACKER_STATUS_MSG="No answer to ping and to API check"
				if [ "${_srv_prev_up[$state_key]}" != "0" ]; then
					[ -n "$ip" ] && \
						[ -z "$(uci -q get openmptcprouter.${name}.ip_down | grep -w "$ip")" ] && \
						uci -q add_list openmptcprouter.${name}.ip_down="$ip" && \
						logger -t "OMR-Tracker-Server" "Master server ${name} down ($ip)"
					_disable_ss_redirs_by_ip "$ip"
					_send_mail_alert "down" "$name" "$ip"
				fi
				_srv_prev_up[$state_key]="0"
				OMR_TRACKER_STATUS="ERROR"
				script_alert_down=$(uci -q get omr-tracker.proxy.script_alert_down)
				[ -n "$script_alert_down" ] && eval "$script_alert_down"
			fi
		}
		config_load openmptcprouter
		config_list_foreach "$1" ip _do_check_ip
		[ "$oneserverup" = "0" ] && uci -q set openmptcprouter.${name}.current='0'
		[ -n "$(uci -q changes openmptcprouter)" ] && uci -q commit openmptcprouter
		# Commit only what actually changed: a no-op `uci commit` still forks
		# and rewrites nothing but costs file locking and IO every cycle
		[ -n "$(uci -q changes shadowsocks-libev)" ] && { changes="1"; uci -q commit shadowsocks-libev; }
		[ -n "$(uci -q changes shadowsocks-rust)" ]  && { changes="1"; uci -q commit shadowsocks-rust; }
		[ -n "$(uci -q changes openvpn)" ]           && { changes="1"; uci -q commit openvpn; }
		[ "$changes" = "1" ] && _restart_proxy_services
		return
	}
}

_check_backup() {
	local name=$1
	local count=0
	local countips=0
	local changes="0"
	config_get backup "$1" backup
	config_get ip "$1" ip
	config_get port "$1" port
	config_get disabled "$1" disabled
	serverip=""
	[ "$backup" = "1" ] && [ -n "$ip" ] && [ "$disabled" != "1" ] && {
		set_ip() {
			ip="$serverip"
			local ss_libev_server ss_rust_server
			local state_key="b:${name}:${countips}"
			ss_libev_server=$(uci -q get shadowsocks-libev.sss${count}.server)
			ss_rust_server=$(uci -q get shadowsocks-rust.sss${count}.server)
			if [ "$server_ping" = true ]; then
				if { [ -n "$(uci -q get shadowsocks-libev)" ] && [ "$ss_libev_server" != "$ip" ]; } || \
				   { [ -n "$(uci -q get shadowsocks-rust)" ] && [ "$ss_rust_server" != "$ip" ]; } || \
				   { [ -n "$(uci -q get openvpn.omr)" ] && [ -z "$(uci -q get openvpn.omr.remote | grep "$ip")" ]; }; then
					logger -t "OMR-Tracker-Server" "Use backup server $name ($ip)"
					changes="1"
					uci -q batch <<-EOF >/dev/null
						set shadowsocks-libev.sss${count}.server="$ip"
						set shadowsocks-rust.sss${count}.server="$ip"
						set openmptcprouter.${name}.current='1'
						del openmptcprouter.omr.detected_ss_ipv4
						del openmptcprouter.omr.detected_public_ipv4
						del openmptcprouter.omr.detected_ss_ipv6
						del openmptcprouter.omr.detected_public_ipv6
						commit openmptcprouter
					EOF
					if [ "$count" -eq "0" ]; then
						config_load openmptcprouter
						config_foreach _disable_current server
						_apply_server_config "$ip" "$name"
					fi
					sleep "$waittest"
				fi
				OMR_TRACKER_STATUS_MSG="Answer to ping and to API check"
				# Same steady-state gate as _check_master: only a down->up
				# transition or a config fix needs the redir/ip_down/alert work
				if [ "${_srv_prev_up[$state_key]}" != "1" ] || [ "$changes" = "1" ]; then
					_proxy=$(uci -q get openmptcprouter.settings.proxy)
					[ "$_proxy" = "shadowsocks-rust" ] && uci -q set shadowsocks-rust.sss${count}.disabled=0
					[ "$_proxy" = "shadowsocks" ]      && uci -q set shadowsocks-libev.sss${count}.disabled=0
					_enable_ss_redirs
					[ -n "$ip" ] && [ -n "$(uci -q get openmptcprouter.${name}.ip_down | grep -w "$ip")" ] && \
						uci -q del_list openmptcprouter.${name}.ip_down="$ip"
					uci -q set openmptcprouter.${name}.current='1'
					_send_mail_alert "up" "$name" "$ip"
				fi
				_srv_prev_up[$state_key]="1"
				OMR_TRACKER_SERVER_IP="$ip"
				OMR_TRACKER_STATUS="OK"
				script_alert_up=$(uci -q get omr-tracker.proxy.script_alert_up)
				[ -n "$script_alert_up" ] && eval "$script_alert_up"
				count=$((count+1))
			else
				[ -z "$OMR_TRACKER_STATUS_MSG" ] && OMR_TRACKER_STATUS_MSG="No answer to ping and to API check"
				if [ "${_srv_prev_up[$state_key]}" != "0" ]; then
					[ -n "$ip" ] && \
						[ -z "$(uci -q get openmptcprouter.${name}.ip_down | grep -w "$ip")" ] && \
						uci -q add_list openmptcprouter.${name}.ip_down="$ip" && \
						logger -t "OMR-Tracker-Server" "Backup server ${name} down ($ip)"
					uci -q set openmptcprouter.${name}.current='0'
					uci -q commit openmptcprouter
					_disable_ss_redirs_by_ip "$ip"
					_send_mail_alert "down" "$name" "$ip"
				fi
				_srv_prev_up[$state_key]="0"
				OMR_TRACKER_STATUS="ERROR"
				script_alert_down=$(uci -q get omr-tracker.proxy.script_alert_down)
				[ -n "$script_alert_down" ] && eval "$script_alert_down"
			fi
			countips=$((countips+1))
		}
		config_load openmptcprouter
		config_list_foreach "$1" ip _do_check_ip
		[ "$oneserverup" = "0" ] && uci -q set openmptcprouter.${name}.current='0'
		[ -n "$(uci -q changes openmptcprouter)" ] && uci -q commit openmptcprouter
		# Commit only what actually changed (see _check_master)
		[ -n "$(uci -q changes shadowsocks-libev)" ] && { changes="1"; uci -q commit shadowsocks-libev; }
		[ -n "$(uci -q changes shadowsocks-rust)" ]  && { changes="1"; uci -q commit shadowsocks-rust; }
		[ -n "$(uci -q changes openvpn)" ]           && { changes="1"; uci -q commit openvpn; }
		[ "$changes" = "1" ] && _restart_proxy_services
		[ "$server_ping" = true ] && return
	}
}

. /lib/functions.sh

timeout=${OMR_TRACKER_TIMEOUT:-5}
interval=${OMR_TRACKER_INTERVAL:-10}
intervaltries=${OMR_TRACKER_INTERVAL_TRIES:-2}
retry=${OMR_TRACKER_TRIES:-4}
waittest=${OMR_TRACKER_WAIT_TEST:-0}
# Per-"server:ip" up/down state from the previous cycle, so the check
# functions can tell a transition apart from the steady state
declare -A _srv_prev_up
# `multipath` is itself a shell script whose no-arg listing forks per network
# device, so refresh the default-route interface list at most every 30s
# instead of on every check. Worst case a hotplugged/removed WAN is seen up
# to 30s late here; the per-interface checks tolerate a stale entry (a dead
# interface just fails its probe and the loop moves on).
mp_default_intfs=""
_mp_intfs_ts=0
# Last value written to openmptcprouter.omr.server, so the global up/down
# state is committed only on a transition, not every cycle
_omr_server_state=""
while true; do
	server_ping=false
	oneserverup="0"
	printf -v _mp_now '%(%s)T' -1
	if [ $((_mp_now - _mp_intfs_ts)) -ge 30 ]; then
		mp_default_intfs="$(multipath 2>/dev/null | awk '/default/{print $1}')"
		_mp_intfs_ts=$_mp_now
	fi
	config_load openmptcprouter
	config_foreach _check_master server
	[ "$oneserverup" = "0" ] && {
		config_load openmptcprouter
		config_foreach _check_backup server
	}
	# Global server state for consumers (LuCI, scripts): "up" while at least
	# one master or backup server answers, "down" otherwise
	if [ "$oneserverup" = "1" ]; then
		srv_state="up"
	else
		srv_state="down"
	fi
	if [ "$srv_state" != "$_omr_server_state" ]; then
		uci -q set openmptcprouter.omr=router
		uci -q set openmptcprouter.omr.server="$srv_state"
		uci -q commit openmptcprouter
		_omr_server_state="$srv_state"
	fi
	sleep "${interval}"
done
