#!/bin/bash
#
# Copyright (C) 2018-2026 Ycarus (Yannick Chabanois) <ycarus@zugaina.org> for OpenMPTCProuter
#
# This is free software, licensed under the GNU General Public License v2.
# See /LICENSE for more information.
#
# This script save settings for status page usage

{ [ "$OMR_TRACKER_STATUS" = "ERROR" ] || [ -z "$OMR_TRACKER_INTERFACE" ] || [ "$OMR_TRACKER_INTERFACE" = "omrvpn" ]; } && exit 0
interface_up=$(ubus call network.interface."$OMR_TRACKER_INTERFACE" status 2>/dev/null | jsonfilter -q -e '@["up"]')
[ "$interface_up" != "true" ] && exit 0

. "${OMR_LIB_DIR:-/usr/share/omr/lib}/omr-state.sh"

# Cache frequently reused values
_now=$(date +"%s")
_debug=$(uci -q get openmptcprouter.settings.debug)
_external_check=$(uci -q get openmptcprouter.settings.external_check)
_tracebox=$(uci -q get openmptcprouter.settings.tracebox)
_lc=$(uci -q get openmptcprouter.$OMR_TRACKER_INTERFACE.lc)

# IPv4 and IPv6 share the device, so they share its MTU. Each family used to
# write the link on its own: on a dual stack WAN the two results fought over
# it and every disagreement cost a carrier reset (issue #4374). Collect both
# results here, then apply the narrower one once, and only when it really
# differs from the live value.
_mtu_cfg=""
_mtu_cfg_done=""
_mtu4=""
_mtu6=""
# Set when the server list held nothing but a placeholder address: only then
# is the public resolver used, exactly as before this was a single "else"
_mtu4_nosrv=""
_mtu6_nosrv=""

# The MTU a user configured, from the interface section or from the device
# section carrying this device. The IPv6 branch used to ask
# find_network_device() for the latter, but 020-status never sources the
# library defining it, so a configured device MTU was simply ignored here.
_config_device_mtu() {
	local _out _sec
	[ -z "$OMR_TRACKER_DEVICE" ] && return 0
	_out=$(uci -q show network)
	# Fixed strings all the way: a device name can carry a dot (eth0.835)
	_sec=$(printf '%s\n' "$_out" | grep -F ".name='${OMR_TRACKER_DEVICE}'" | head -1 | cut -d. -f1-2)
	[ -z "$_sec" ] && return 0
	printf '%s\n' "$_out" | grep -qF "${_sec}='device'" || return 0
	printf '%s\n' "$_out" | grep -F "${_sec}.mtu='" | head -1 | cut -d"'" -f2
}

# True when an explicit MTU is configured: detection must not fight it
_mtu_config() {
	if [ -z "$_mtu_cfg_done" ]; then
		_mtu_cfg_done=1
		_mtu_cfg="$(uci -q get network.${OMR_TRACKER_INTERFACE}.mtu)"
		[ -z "$_mtu_cfg" ] && _mtu_cfg="$(_config_device_mtu)"
	fi
	[ -n "$_mtu_cfg" ]
}

# Keep only a plain number: a probe that failed must not reach the link
_mtu_valid() {
	case "$1" in
		''|*[!0-9]*) return 1 ;;
	esac
	[ "$1" -ge 552 ] && [ "$1" -le 9216 ]
}

# One probe per family and per interface: the callbacks below run once per
# configured server address, and the target must match the family or the
# probe pings nothing. The public resolvers are only a last resort, used
# after the server list turned out to hold no usable address.
_probe_mtu4() {
	{ [ -n "$_mtu4" ] || [ -z "$1" ] || [ -z "$OMR_TRACKER_DEVICE_IP" ] || \
	  [ -z "$OMR_TRACKER_DEVICE" ] || [ "$OMR_TRACKER_INTERFACE" = "omrvpn" ]; } && return 0
	_mtu_config && return 0
	_mtu4=$(omr-mtu "$OMR_TRACKER_DEVICE_IP" "$1")
	_mtu_valid "$_mtu4" || _mtu4=""
}

_probe_mtu6() {
	{ [ -n "$_mtu6" ] || [ -z "$1" ] || [ -z "$OMR_TRACKER_DEVICE_IP6" ] || \
	  [ -z "$OMR_TRACKER_DEVICE" ] || [ "$OMR_TRACKER_INTERFACE" = "omrvpn" ]; } && return 0
	_mtu_config && return 0
	_mtu6=$(omr-mtu6 "$OMR_TRACKER_DEVICE_IP6" "$1")
	_mtu_valid "$_mtu6" || _mtu6=""
}

_set_device_mtu() {
	local _mtu="$1" _cur
	{ [ -z "$_mtu" ] || [ -z "$OMR_TRACKER_DEVICE" ] || [ -z "$OMR_TRACKER_INTERFACE" ]; } && return 0
	uci -q set openmptcprouter.$OMR_TRACKER_INTERFACE.mtu="$_mtu"
	_cur=$(ip --json link show dev "$OMR_TRACKER_DEVICE" 2>/dev/null | jsonfilter -q -e '@[0].mtu' | tr -d '\n')
	[ "$_cur" = "$_mtu" ] && return 0
	_log "Set MTU of $OMR_TRACKER_INTERFACE ($OMR_TRACKER_DEVICE) to $_mtu (was ${_cur:-unknown})"
	ip link set dev "$OMR_TRACKER_DEVICE" mtu "$_mtu" > /dev/null 2>&1 || \
		_log "Can't set MTU $_mtu on $OMR_TRACKER_DEVICE"
}

_apply_mtu() {
	local _mtu
	# An explicit configuration always wins over detection
	if _mtu_config && _mtu_valid "$_mtu_cfg"; then
		_set_device_mtu "$_mtu_cfg"
		return 0
	fi
	_mtu="$_mtu4"
	if _mtu_valid "$_mtu6" && { ! _mtu_valid "$_mtu" || [ "$_mtu6" -lt "$_mtu" ]; }; then
		_mtu="$_mtu6"
	fi
	_mtu_valid "$_mtu" || return 0
	# IPv6 needs 1280 bytes: leave the link alone instead of breaking it
	[ -n "$ip6addr" ] && [ "$_mtu" -lt 1280 ] && return 0
	_set_device_mtu "$_mtu"
}

# IPv4 and IPv6 shared publicip the same way they shared the MTU: on a dual
# stack WAN each family read the other family's address, called it a change,
# logged one, and wrote its own over it. Two bogus "New public ip detected"
# lines per refresh, and whatever else reads publicip -- the routing loop
# check below, the WAN address list pushed to the VPS, the status page --
# was handed an IPv6 address in a field meant for the IPv4 one (issue
# #4375). IPv6 lives in publicip6 now, which is what the status API already
# reads. Move an address an earlier firmware left in the wrong field instead
# of reporting it as a change.
_publicip_migrate() {
	local _stored
	[ -z "$OMR_TRACKER_INTERFACE" ] && return 0
	_stored="$(uci -q get openmptcprouter.$OMR_TRACKER_INTERFACE.publicip)"
	case "$_stored" in
		*:*)
			[ -z "$(uci -q get openmptcprouter.$OMR_TRACKER_INTERFACE.publicip6)" ] && \
				uci -q set openmptcprouter.$OMR_TRACKER_INTERFACE.publicip6="$_stored"
			uci -q delete openmptcprouter.$OMR_TRACKER_INTERFACE.publicip
			;;
	esac
}

# Save wan settings for status page
if [ -n "$OMR_TRACKER_INTERFACE" ] && { [ -z "$_lc" ] || [ "$(uci -q get openmptcprouter.$OMR_TRACKER_INTERFACE.state)" = "down" ] || [ $((_now + $((30 + RANDOM % 10)) - _lc)) -gt 3600 ]; }; then
	[ "$_debug" = "true" ] && _log "Get status and settings for $OMR_TRACKER_INTERFACE..."
	_publicip_migrate
	ipaddr=""
	ip6addr=""
	# One per family too: the IPv6 branch used to write the IPv4 netname
	# into asn whenever its own whois found nothing
	asn=""
	asn6=""
	if [ "$_external_check" != "0" ] && [ "$(uci -q get openmptcprouter.$OMR_TRACKER_INTERFACE.vpn)" != "1" ]; then
		[ -n "$OMR_TRACKER_DEVICE_IP" ] && ipaddr="$(omr-ip-intf $OMR_TRACKER_DEVICE)"
		[ -n "$OMR_TRACKER_DEVICE_IP6" ] && ip6addr="$(omr-ip6-intf $OMR_TRACKER_DEVICE)"
	else
		uci -q set openmptcprouter.$OMR_TRACKER_INTERFACE.lc="$_now"
		uci -q set openmptcprouter.$OMR_TRACKER_INTERFACE.state="up"
	fi
	[ -n "$ipaddr" ] && {
		# Check if we can get a IPv6 address, if yes enable RA else disable
		#check_ipv6_website="$(uci -q get openmptcprouter.settings.check_ipv6_website)"
		#[ -z "$check_ipv6_website" ] && check_ipv6_website="http://ipv6.openmptcprouter.com/"
		#ip6addr="$(curl -s -6 -m 2 $check_ipv6_website)"
		#[ -z "$ip6addr" ] && {
		#	ip6addr="$(curl -s -6 -m 2 http://ifconfig.me/)"
		#}
		#if [ "$(uci -q get openmptcprouter.settings.ipv6_disable)" = "0" ]; then
		#	if [ -n "$ip6addr" ] && [ "$(uci -q get dhcp.lan.ra_default)" != 1 ]; then
		#		_log "Enable IPv6 RA"
		#		uci -q set dhcp.lan.ra=server
		#		uci -q set dhcp.lan.ra_default=1
		#		uci -q set dhcp.lan.dhcpv6=server
		#		/etc/init.d/odhcpd start > /dev/null 2>&1
		#		/etc/init.d/odhcpd enable > /dev/null 2>&1
		#	elif [ -z "$ip6addr" ] && [ "$(uci -q set dhcp.lan.ra_default)" = 1 ]; then
		#		_log "Disable IPv6 RA"
		#		uci -q delete dhcp.lan.ra
		#		uci -q delete dhcp.lan.dhcpv6
		#		/etc/init.d/odhcpd start > /dev/null 2>&1
		#		/etc/init.d/odhcpd enable > /dev/null 2>&1
		#	fi
		#fi
		if [ "$_external_check" != "0" ]; then
			#asn="$(wget -4 -qO- -T 4 http://api.iptoasn.com/v1/as/ip/$ipaddr | jsonfilter -q -e '@.as_description')"
			#[ -z "$asn" ] && {
			whoistimeout=$(uci -q get openmptcprouter.settings.status_whois_timeout)
			[ -z "$whoistimeout" ] && whoistimeout=2
			asn="$(timeout $whoistimeout whois $ipaddr 2>/dev/null | grep -m 1 -i 'netname' | awk '{print $2}')"
			#}
		fi
		[ -z "$(uci -q get openmptcprouter.$OMR_TRACKER_INTERFACE)" ] && {
			uci -q set openmptcprouter.$OMR_TRACKER_INTERFACE=interface
		}
		#if local _lvlc; _lvlc=$(uci -q get openmptcprouter.latest_versions.lc); [ -z "$_lvlc" ] || [ $((_now - _lvlc)) -gt 3600 ]; then
		#	latestversions="$(curl -4 -s -m 3 https://www.openmptcprouter.com/version/version.json)"
		#	[ -n "$latestversions" ] && {
		#		uci -q set openmptcprouter.latest_versions=latest_versions
		#		uci -q set openmptcprouter.latest_versions.omr=$(echo $latestversions | jsonfilter -q -e '@.omr')-$(ubus call system board | jsonfilter -e '@.kernel' | cut -d'.' -f1,2)
		#		uci -q set openmptcprouter.latest_versions.vps=$(echo $latestversions | jsonfilter -q -e '@.vps')
		#		uci -q set openmptcprouter.latest_versions.lc="$_now"
		#	}
		#fi
		[ -n "$ipaddr" ] && [ "$(uci -q get openmptcprouter.$OMR_TRACKER_INTERFACE.publicip)" != "$ipaddr" ] && {
			previousip="$(uci -q get openmptcprouter.$OMR_TRACKER_INTERFACE.publicip)"
			if [ -n "$previousip" ]; then
				_log "New public ip detected for $OMR_TRACKER_INTERFACE ($OMR_TRACKER_DEVICE): $ipaddr (previous: $previousip)"
			else
				_log "New public ip detected for $OMR_TRACKER_INTERFACE ($OMR_TRACKER_DEVICE): $ipaddr (Refresh IP data)"
			fi
			uci -q set openmptcprouter.$OMR_TRACKER_INTERFACE.publicip="$ipaddr"
			#/etc/init.d/mptcp enabled && ([ "$OMR_TRACKER_DEVICE_IP" = "$previousip" ] || [ "$OMR_TRACKER_DEVICE_IP" = "$ipaddr" ]) && {
			#	_log "Reload MPTCP for $OMR_TRACKER_DEVICE"
			#	/etc/init.d/mptcp reload "$OMR_TRACKER_DEVICE" >/dev/null 2>&1
			#}
		}
		[ -n "$OMR_TRACKER_LATENCY" ] && omr_state_set openmptcprouter "$OMR_TRACKER_INTERFACE" latency "$OMR_TRACKER_LATENCY"
		[ -n "$asn" ] && [ "$(uci -q get openmptcprouter.$OMR_TRACKER_INTERFACE.asn)" != "$asn" ] && {
			uci -q set openmptcprouter.$OMR_TRACKER_INTERFACE.asn="$asn"
		}

		# Routing loop detection
		lanip="$(uci -q get network.lan.ipaddr)"
		masterip=""
		get_master_ip() {
			if [ -n "$1" ] && [ "$(uci -q get openmptcprouter.$1.multipath)" = "master" ]; then
				masterip="$(uci -q get openmptcprouter.$1.publicip)"
			fi
		}
		config_load openmptcprouter
		config_foreach get_master_ip interface
		if [ -n "$lanip" ] && [ -n "$masterip" ] && [ -n "$ipaddr" ] && [ "$ipaddr" = "$masterip" ] && [ "$(uci -q get openmptcprouter.settings.disableloopdetection)" != "1" ]; then
			loop=0
			routingloop() {
				vpsip=""
				[ -n "$1" ] && vpsip="$(uci -q get openmptcprouter.$1.ip)"
				if [ -n "$vpsip" ] && [ "$(omr-routing-loop $vpsip $lanip $OMR_TRACKER_DEVICE)" = "detected" ]; then
					loop=1
				fi
			}
			config_load openmptcprouter
			config_foreach routingloop server
			if [ "$loop" = "1" ]; then
				uci -q set openmptcprouter.$OMR_TRACKER_INTERFACE.loop='1'
			else
				uci -q delete openmptcprouter.$OMR_TRACKER_INTERFACE.loop
			fi
		else
			uci -q delete openmptcprouter.$OMR_TRACKER_INTERFACE.loop
		fi

		omrtracebox=""
		_tracebox_running=$(pgrep -f tracebox)
		traceboxmtutest() {
			omr_tracebox_mtu() {
				serverip=$1
				
				[ -n "$serverip" ] && [ "$serverip" != "127.0.0.1" ] && [ -z "$_tracebox_running" ] && [ "$_tracebox" != "0" ] && {
					omrtracebox="$(omr-tracebox-mptcp $serverip $OMR_TRACKER_DEVICE)"
					case "$omrtracebox" in
					*error*|"") ;;
					*) uci -q set openmptcprouter.$OMR_TRACKER_INTERFACE.mptcp_status="$omrtracebox" ;;
					esac
				}
				case "$serverip" in
					''|127.0.0.1) _mtu4_nosrv=1 ;;
					*:*) ;; # IPv6 address, not this family
					*) _probe_mtu4 "$serverip" ;;
				esac
			}
			config_list_foreach $1 ip omr_tracebox_mtu
		}
		config_load openmptcprouter
		config_foreach traceboxmtutest server
		# Placeholder server address only: the configured ones come first
		[ -n "$_mtu4_nosrv" ] && _probe_mtu4 "1.1.1.1"
#		[ "$_tracebox" = "0" ] && [ -n "$OMR_TRACKER_DEVICE" ] && {
#			mptcpsupport="$(omr-mptcp-intf $OMR_TRACKER_DEVICE)"
#			[ -n "$mptcpsupport" ] && uci -q set openmptcprouter.$OMR_TRACKER_INTERFACE.mptcp_status="$mptcpsupport"
#		}
		uci -q set openmptcprouter.$OMR_TRACKER_INTERFACE.state='up'
		uci -q set openmptcprouter.$OMR_TRACKER_INTERFACE.lc="$_now"
	}
	[ -n "$ip6addr" ] && {
		if [ "$_external_check" != "0" ]; then
			whoistimeout=$(uci -q get openmptcprouter.settings.status_whois_timeout)
			[ -z "$whoistimeout" ] && whoistimeout=2
			# Unbounded here, so a slow registry stalled post-tracking
			asn6="$(timeout $whoistimeout whois $ip6addr 2>/dev/null | grep -m 1 -i 'netname' | awk '{print $2}')"
		fi
		[ -z "$(uci -q get openmptcprouter.$OMR_TRACKER_INTERFACE)" ] && {
			uci -q set openmptcprouter.$OMR_TRACKER_INTERFACE=interface
		}
		if [ "$(uci -q get openmptcprouter.latest_versions.lc)" = "" ] || [ $(($(date +"%s") - $(uci -q get openmptcprouter.latest_versions.lc))) -gt 3600 ]; then
			latestversions="$(curl -6 -s -m 3 https://www.openmptcprouter.com/version/version.json)"
			[ -n "$latestversions" ] && {
				uci -q set openmptcprouter.latest_versions=latest_versions
				uci -q set openmptcprouter.latest_versions.omr=$(echo $latestversions | jsonfilter -q -e '@.omr')
				uci -q set openmptcprouter.latest_versions.vps=$(echo $latestversions | jsonfilter -q -e '@.vps')
				uci -q set openmptcprouter.latest_versions.lc="$_now"
			}
		fi
		[ -n "$ip6addr" ] && [ "$(uci -q get openmptcprouter.$OMR_TRACKER_INTERFACE.publicip6)" != "$ip6addr" ] && {
			previousip6=$(uci -q get openmptcprouter.$OMR_TRACKER_INTERFACE.publicip6)
			if [ -n "$previousip6" ]; then
				_log "New public IPv6 detected for $OMR_TRACKER_INTERFACE ($OMR_TRACKER_DEVICE): $ip6addr (previous: $previousip6)"
			else
				_log "New public IPv6 detected for $OMR_TRACKER_INTERFACE ($OMR_TRACKER_DEVICE): $ip6addr (Refresh IP data)"
			fi
			#/etc/init.d/mptcp enabled && ([ "$OMR_TRACKER_DEVICE_IP6" = "$ip6addr" ] || [ "$OMR_TRACKER_DEVICE_IP" = "$previousip6" ]) && {
			#	_log "Reload MPTCP for $OMR_TRACKER_DEVICE"
			#	/etc/init.d/mptcp reload "$OMR_TRACKER_DEVICE" >/dev/null 2>&1
			#}
			uci -q set openmptcprouter.$OMR_TRACKER_INTERFACE.publicip6="$ip6addr"
		}
		[ -n "$OMR_TRACKER_LATENCY" ] && omr_state_set openmptcprouter "$OMR_TRACKER_INTERFACE" latency "$OMR_TRACKER_LATENCY"
		[ -n "$asn6" ] && [ "$(uci -q get openmptcprouter.$OMR_TRACKER_INTERFACE.asn6)" != "$asn6" ] && {
			uci -q set openmptcprouter.$OMR_TRACKER_INTERFACE.asn6="$asn6"
		}
		omrtracebox=""
		_tracebox_running=$(pgrep -f tracebox)
		traceboxmtutest() {
			omr_tracebox_mtu() {
				local serverip=$1
				
				[ -n "$serverip" ] && [ "$serverip" != "127.0.0.1" ] && [ -z "$_tracebox_running" ] && [ "$_tracebox" != "0" ] && {
					omrtracebox="$(omr-tracebox-mptcp $serverip $OMR_TRACKER_DEVICE)"
					case "$omrtracebox" in
					*error*|"") ;;
					*) uci -q set openmptcprouter.$OMR_TRACKER_INTERFACE.mptcp_status="$omrtracebox" ;;
					esac
				}
				# This probe used to be gated on the IPv4 device address,
				# so an IPv6 only WAN was never measured at all
				case "$serverip" in
					''|127.0.0.1|::1) _mtu6_nosrv=1 ;;
					*:*) _probe_mtu6 "$serverip" ;;
					*) ;; # IPv4 address, not this family
				esac
			}
			config_list_foreach $1 ip omr_tracebox_mtu
		}
		config_load openmptcprouter
		config_foreach traceboxmtutest server
		[ -n "$_mtu6_nosrv" ] && _probe_mtu6 "2606:4700:4700::1111"
		uci -q set openmptcprouter.$OMR_TRACKER_INTERFACE.state='up'
		uci -q set openmptcprouter.$OMR_TRACKER_INTERFACE.lc="$_now"
	}
	# One link, one MTU: whatever each family measured above is applied here,
	# once, and only if it differs from what the device already carries
	{ [ -n "$ipaddr" ] || [ -n "$ip6addr" ]; } && _apply_mtu
	# No shadowsocks ping here: when external_check=0 the branch above already
	# set lc=$_now unconditionally, so a per-WAN ping to the proxy server could
	# only ever rewrite the value it just wrote.
	proto="$(uci -q get network.$OMR_TRACKER_INTERFACE.proto)"
	#if [ "$proto" = "qmi" ]; then
	#	intfdata="$(omr-qmi $OMR_TRACKER_DEVICE all | tr -d '\n')"
	#	uci -q set openmptcprouter.$OMR_TRACKER_INTERFACE.operator=$(echo $intfdata | awk -F";" '{print $2}')
	#	uci -q set openmptcprouter.$OMR_TRACKER_INTERFACE.number=$(echo $intfdata | awk -F";" '{print $3}')
	#	uci -q set openmptcprouter.$OMR_TRACKER_INTERFACE.state=$(echo $intfdata | awk -F";" '{print $4}')
	#elif [ "$proto" = "modemmanager" ]; then
	#	intfdata="$(omr-modemmanager $OMR_TRACKER_DEVICE all)"
	#	uci -q set openmptcprouter.$OMR_TRACKER_INTERFACE.operator=$(echo $intfdata | awk -F";" '{print $2}')
	#	uci -q set openmptcprouter.$OMR_TRACKER_INTERFACE.number=$(echo $intfdata | awk -F";" '{print $3}')
	#	uci -q set openmptcprouter.$OMR_TRACKER_INTERFACE.state=$(echo $intfdata | awk -F";" '{print $4}')
	#else
	if [ "$proto" != "qmi" ] && [ "$proto" != "modemmanager" ]; then
		if [ -n "$OMR_TRACKER_DEVICE_GATEWAY" ] && [ -n "$OMR_TRACKER_DEVICE_IP" ] && [ "$(curl --interface $OMR_TRACKER_DEVICE_IP -s -w %{http_code} -m 2 http://$OMR_TRACKER_DEVICE_GATEWAY/api/webserver/SesTokInfo -o /dev/null)" = "200" ]; then
			uci -q set openmptcprouter.$OMR_TRACKER_INTERFACE.manufacturer='huawei'
		else
			uci -q delete openmptcprouter.$OMR_TRACKER_INTERFACE.manufacturer
		fi
	fi
	_lc_after=$(uci -q get openmptcprouter.$OMR_TRACKER_INTERFACE.lc)
	if [ -z "$_lc_after" ] || [ $((_now - _lc_after)) -gt 3600 ]; then
		uci -q set openmptcprouter.$OMR_TRACKER_INTERFACE.lc=$((_now - 3400))
		[ "$_debug" = "true" ] && _log "Get status and settings for $OMR_TRACKER_INTERFACE... Failed"
		uci -q commit openmptcprouter
	else
		[ "$_debug" = "true" ] && _log "Get status and settings for $OMR_TRACKER_INTERFACE... Done"
		[ -n "$(uci -q changes openmptcprouter)" ] && uci -q commit openmptcprouter
		if [ "$(pgrep -f openmptcprouter-vps)" = "" ] && { [ -z "$(uci -q get openmptcprouter.settings.apilc)" ] || [ $((_now - $(uci -q get openmptcprouter.settings.apilc))) -gt 3600 ]; }; then
			[ "$_debug" = "true" ] && _log "Check API configuration..."
			/etc/init.d/openmptcprouter-vps restart >/dev/null 2>&1 &
			uci -q set openmptcprouter.settings.apilc="$_now"
			[ "$_debug" = "true" ] && _log "Check API configuration... Done"
		fi
	fi
	#dns_flush
fi
# mplc (last MPTCP-capability probe) is refreshed every 10 minutes: keep it
# in uci state (tmpfs) so the probe cadence doesn't turn into a flash commit.
# The one-time migrate drops the copy older firmwares committed to config.
_mplc="$(omr_state_get openmptcprouter.$OMR_TRACKER_INTERFACE.mplc)"
[ -z "$_mplc" ] && _mplc="$(uci -q get openmptcprouter.$OMR_TRACKER_INTERFACE.mplc)"
if [ "$_tracebox" = "0" ] && [ -n "$OMR_TRACKER_DEVICE" ] && [ -n "$OMR_TRACKER_INTERFACE" ] && [ "$OMR_TRACKER_INTERFACE" != "omrvpn" ] && { [ -z "$_mplc" ] || [ $((_now - _mplc)) -gt 600 ]; }; then
	#_log "Get MPTCP status for $OMR_TRACKER_INTERFACE ($OMR_TRACKER_DEVICE)"
	mptcpsupport="$(omr-mptcp-intf $OMR_TRACKER_DEVICE)"
	#_log "MPTCP status for $OMR_TRACKER_INTERFACE ($OMR_TRACKER_DEVICE): $mptcpsupport"
	[ -n "$mptcpsupport" ] && [ "$(uci -q get openmptcprouter.$OMR_TRACKER_INTERFACE.mptcp_status)" != "$mptcpsupport" ] && {
		uci -q set openmptcprouter.$OMR_TRACKER_INTERFACE.mptcp_status="$mptcpsupport"
		uci -q commit openmptcprouter
	}
	omr_state_migrate openmptcprouter "$OMR_TRACKER_INTERFACE" mplc
	omr_state_set openmptcprouter "$OMR_TRACKER_INTERFACE" mplc "$_now"
fi

exit 0