Fix HTTPS heartbeat retries and WAN IPv4 DNS fallback
This commit is contained in:
1 parent
4a398c96b1
commit
5f65a3d811
13 files changed
+1547
-69
No files matched your search
@@ -103,37 +103,114 @@ wan_dns_server() {
|
||||
printf '%s' "$dns"
|
||||
}
|
||||
|
||||
wan_dns_metric() {
|
||||
[ -n "${OWRT_REMOTE_DNS_METRICS:-}" ] || return 0
|
||||
printf '%s %s\n' "$1" "$2" >"$OWRT_REMOTE_DNS_METRICS"
|
||||
}
|
||||
|
||||
wan_dns_ipv4() {
|
||||
# DNS cache entries must be unambiguous IPv4, never IPv6 or a fake-IP.
|
||||
case "$1" in ''|198.18.*|198.19.*) return 1 ;; esac
|
||||
printf '%s\n' "$1" | awk -F. '
|
||||
NF != 4 { exit 1 }
|
||||
{ for (i=1;i<=4;i++) if ($i !~ /^[0-9]+$/ || $i > 255 || (length($i)>1 && $i ~ /^0/)) exit 1 }
|
||||
'
|
||||
}
|
||||
|
||||
wan_dns_a_reply() {
|
||||
# BusyBox prints the resolver Address before the answer. Only trust an
|
||||
# Address belonging to the queried Name (or its CNAME chain), with rc=0.
|
||||
awk -v host="$1" -v rc="$2" '
|
||||
function name(s) { s=tolower(s); sub(/\.$/, "", s); return s }
|
||||
function ipv4(s, a,n,i) {
|
||||
n=split(s,a,"."); if (n!=4) return 0
|
||||
for(i=1;i<=4;i++) if(a[i]!~/^[0-9]+$/ || a[i]>255 || (length(a[i])>1 && a[i]~/^0/)) return 0
|
||||
return 1
|
||||
}
|
||||
BEGIN { allowed[name(host)]=1 }
|
||||
{
|
||||
text=tolower($0)
|
||||
if(text ~ /timed out|connection timeout/) timed_out=1
|
||||
if(text ~ /: (no answer|nxdomain|nodata)([[:space:]]|$)/) no_a=1
|
||||
if(text ~ /: parse error([[:space:]]|$)/) bad=1
|
||||
if(text ~ /: (servfail|refused|formerr|notimp)([[:space:]]|$)/) dns_error=1
|
||||
}
|
||||
/^[[:space:]]*Server:/ { server=1; owner=""; next }
|
||||
$2 == "canonical" && $3 == "name" && $4 == "=" {
|
||||
aliases[++alias_count]=name($1); targets[alias_count]=name($5); next
|
||||
}
|
||||
/^[[:space:]]*Name:/ {
|
||||
owner=name($2); named=1
|
||||
if(NF!=2 || owner !~ /^[a-z0-9_.-]+$/) { owner=""; bad=1 }
|
||||
next
|
||||
}
|
||||
/^[[:space:]]*Address([[:space:]]+[0-9]+)?:/ {
|
||||
if(owner=="") next
|
||||
field=($1=="Address:" ? 2 : 3)
|
||||
if(ipv4($field)) {
|
||||
owners[++count]=owner; ips[count]=$field
|
||||
} else if(index($field,":")==0) bad=1
|
||||
}
|
||||
END {
|
||||
for(pass=1;pass<=alias_count;pass++)
|
||||
for(i=1;i<=alias_count;i++) if(allowed[aliases[i]]) allowed[targets[i]]=1
|
||||
if(rc==0 && !bad && !dns_error) for(i=1;i<=count;i++) if(allowed[owners[i]]) {
|
||||
if(ips[i] ~ /^198\.(18|19)\./) { rejected=1; continue }
|
||||
print "ok", ips[i]; exit
|
||||
}
|
||||
if(timed_out) print "timeout"
|
||||
else if(bad) print "parse_error"
|
||||
else if(dns_error) print "resolver_error"
|
||||
else if(rejected) print "rejected_address"
|
||||
else if(no_a || (rc==0 && count==0 && (server || named))) print "no_a_record"
|
||||
else if(rc!=0) print "resolver_error"
|
||||
else print "parse_error"
|
||||
}
|
||||
'
|
||||
}
|
||||
|
||||
wan_resolve_host() {
|
||||
local host dns answer cache now saved_ts saved_ip
|
||||
local host dns answer cache now saved_ts saved_ip saved_age started reply rc result reason
|
||||
host="$1"
|
||||
wan_ip_literal "$host" && { printf '%s' "$host"; return; }
|
||||
wan_ip_literal "$host" && { wan_dns_metric 0 literal; printf '%s' "$host"; return; }
|
||||
case "$host" in ''|*[!a-zA-Z0-9_.-]*) return 1 ;; esac
|
||||
dns="$(wan_dns_server)" || return 1
|
||||
cache="$WAN_STATE/resolve-$(safe_id "$host-$dns")"
|
||||
now="$(date +%s)"
|
||||
saved_ts=0; saved_ip=''
|
||||
[ ! -r "$cache" ] || read -r saved_ts saved_ip <"$cache"
|
||||
if [ -n "$saved_ip" ] && [ $((now - saved_ts)) -lt 300 ]; then
|
||||
if [ -r "$cache" ]; then
|
||||
read -r saved_ts saved_ip <"$cache" || { saved_ts=0; saved_ip=''; }
|
||||
fi
|
||||
# Reject corrupted/future timestamps and non-IPv4 cache contents before
|
||||
# arithmetic or fallback; keep the existing 5 minute / 1 hour limits.
|
||||
case "$saved_ts" in ''|0*|*[!0-9]*|???????????*) saved_ts=0; saved_ip='' ;; esac
|
||||
saved_age=$((now - saved_ts))
|
||||
if [ "$saved_age" -lt 0 ] || ! wan_dns_ipv4 "$saved_ip"; then saved_ip=''; fi
|
||||
if [ -n "$saved_ip" ] && [ "$saved_age" -lt 300 ]; then
|
||||
wan_dns_metric 0 cache
|
||||
printf '%s' "$saved_ip"; return
|
||||
fi
|
||||
# Query WAN's resolver explicitly, never the local dnsmasq/sing-box resolver.
|
||||
answer="$(nslookup -timeout=3 -retry=1 "$host" "$dns" 2>/dev/null | awk '
|
||||
/^Name:/ { in_answer=1 }
|
||||
in_answer && /^Address([[:space:]][0-9]+)?:/ {
|
||||
for (i=2;i<=NF;i++) if ($i ~ /^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$/) { print $i; exit }
|
||||
}')"
|
||||
case "$answer" in 198.18.*|198.19.*) answer='' ;; esac
|
||||
if wan_ip_literal "$answer"; then
|
||||
started=''
|
||||
[ -z "${OWRT_REMOTE_DNS_METRICS:-}" ] || started="$(remote_clock_ms)"
|
||||
# Without -type=A BusyBox queries both A and AAAA, so an empty AAAA
|
||||
# answer can be confused with an IPv4 failure. Preserve nslookup status.
|
||||
rc=0
|
||||
reply="$(LC_ALL=C nslookup -type=A -timeout=3 -retry=1 "$host" "$dns" 2>&1)" || rc=$?
|
||||
[ -z "$started" ] || wan_dns_metric "$(( $(remote_clock_ms) - started ))" lookup
|
||||
result="$(printf '%s\n' "$reply" | wan_dns_a_reply "$host" "$rc")"
|
||||
reason="${result%% *}"; answer="${result#* }"
|
||||
if [ "$reason" = ok ] && wan_dns_ipv4 "$answer"; then
|
||||
mkdir -p "$WAN_STATE"
|
||||
printf '%s %s\n' "$now" "$answer" >"$cache.tmp.$$"
|
||||
mv "$cache.tmp.$$" "$cache"
|
||||
printf '%s' "$answer"; return
|
||||
fi
|
||||
if [ -n "$saved_ip" ] && [ $((now - saved_ts)) -lt 3600 ]; then
|
||||
log "WAN DNS unavailable for $host; using last successful WAN address $saved_ip"
|
||||
if [ -n "$saved_ip" ] && [ "$saved_age" -lt 3600 ]; then
|
||||
log "WAN DNS unavailable for $host; reason=$reason; resolver=$dns; rc=$rc; using last successful WAN address $saved_ip"
|
||||
printf '%s' "$saved_ip"; return
|
||||
fi
|
||||
log "WAN DNS failed: host=$host resolver=$dns"
|
||||
log "WAN DNS failed: host=$host resolver=$dns type=A reason=$reason rc=$rc"
|
||||
return 1
|
||||
}
|
||||
|
||||
@@ -143,6 +220,7 @@ wan_endpoint_ip() {
|
||||
pinned="$(uci_get vps_host '')"
|
||||
# Preserve HTTP Host and TLS SNI while connecting to the manually pinned VPS.
|
||||
if ! wan_ip_literal "$host" && [ "$(vps_host_mode)" = manual ] && wan_ip_literal "$pinned"; then
|
||||
wan_dns_metric 0 pinned
|
||||
printf '%s' "$pinned"
|
||||
else
|
||||
wan_resolve_host "$host"
|
||||
@@ -388,9 +466,9 @@ wan_prepare() (
|
||||
wan_prepare_locked
|
||||
)
|
||||
|
||||
wan_post_json() {
|
||||
local url token file host port ip device selected OWRT_REMOTE_ACTIVE_WAN_INTERFACE
|
||||
url="$1"; token="$2"; file="$3"
|
||||
wan_http_target() {
|
||||
local url host port ip device selected OWRT_REMOTE_ACTIVE_WAN_INTERFACE
|
||||
url="$1"
|
||||
selected="$(wan_select_interface)" || return 1
|
||||
if [ "$selected" != "$(cat "$WAN_STATE/active-interface" 2>/dev/null)" ]; then
|
||||
wan_prepare || return 1
|
||||
@@ -398,7 +476,7 @@ wan_post_json() {
|
||||
OWRT_REMOTE_ACTIVE_WAN_INTERFACE="$(cat "$WAN_STATE/active-interface")" || return 1
|
||||
host="$(wan_url_host "$url")"
|
||||
port="$(wan_url_port "$url")" || return 1
|
||||
ip="$(wan_endpoint_ip "$url")" || return 1
|
||||
ip="$(OWRT_REMOTE_DNS_METRICS="${OWRT_REMOTE_DNS_STATS_FILE:-}" wan_endpoint_ip "$url")" || return 1
|
||||
device="$(wan_device)" || return 1
|
||||
# A resolver cache may expire between prepare and this request. Refresh
|
||||
# direct routes before sending to a newly resolved IP.
|
||||
@@ -407,13 +485,12 @@ wan_post_json() {
|
||||
grep -Fqx "$ip $port" "$WAN_STATE/endpoints" || return 1
|
||||
fi
|
||||
case "$ip" in *:*) ip="[$ip]" ;; esac
|
||||
# Follow nginx HTTP-to-HTTPS redirects while preserving this JSON POST.
|
||||
# Host and TLS SNI remain the configured URL's; no certificate bypass is used.
|
||||
curl -fsSL --location --max-redirs 3 --post301 --post302 --post303 \
|
||||
--noproxy '*' --interface "$device" --connect-timeout 4 --max-time 10 \
|
||||
--resolve "$host:$port:$ip" \
|
||||
-H "Authorization: Bearer $token" -H 'Content-Type: application/json' \
|
||||
--data-binary "@$file" "$url"
|
||||
printf '%s|%s:%s:%s' "$device" "$host" "$port" "$ip"
|
||||
}
|
||||
|
||||
wan_post_json() {
|
||||
# Resolve and bind every approved redirect separately, including HTTPS.
|
||||
remote_curl_post "$1" "$2" "$3" wan
|
||||
}
|
||||
|
||||
wan_cleanup() {
|
||||
|
||||
+191
-27
@@ -28,6 +28,7 @@ usage() {
|
||||
owrt-remote run
|
||||
owrt-remote heartbeat
|
||||
owrt-remote heartbeat-loop
|
||||
owrt-remote heartbeat-diagnostics
|
||||
owrt-remote logs-sync
|
||||
owrt-remote network-diagnostics
|
||||
|
||||
@@ -813,6 +814,108 @@ heartbeat_json() {
|
||||
EOF
|
||||
}
|
||||
|
||||
remote_clock_ms() {
|
||||
LC_ALL=C awk '{ printf "%.0f", $1 * 1000; exit }' /proc/uptime 2>/dev/null || date +%s000
|
||||
}
|
||||
|
||||
remote_url_origin() {
|
||||
# Return only a validated origin, never userinfo, path, query or fragment.
|
||||
printf '%s\n' "$1" | LC_ALL=C awk '
|
||||
NR != 1 { bad=1 }
|
||||
NR == 1 {
|
||||
if ($0 ~ /[\001-\040\177]/ || $0 !~ /^https?:\/\//) { bad=1; next }
|
||||
scheme=$0; sub(/:.*/, "", scheme)
|
||||
authority=$0; sub(/^https?:\/\//, "", authority); sub(/[\/?#].*/, "", authority)
|
||||
if (authority ~ /@/) { bad=1; next }
|
||||
port=(scheme == "https" ? 443 : 80)
|
||||
if (authority ~ /^\[[0-9a-fA-F:]+\](:[0-9]+)?$/) {
|
||||
host=authority; sub(/\].*/, "]", host)
|
||||
if (authority ~ /\]:/) { port=authority; sub(/^.*\]:/, "", port) }
|
||||
} else if (authority ~ /^[a-zA-Z0-9_.-]+(:[0-9]+)?$/) {
|
||||
host=authority; sub(/:.*/, "", host)
|
||||
if (authority ~ /:/) { port=authority; sub(/^.*:/, "", port) }
|
||||
} else { bad=1; next }
|
||||
if (port + 0 < 1 || port + 0 > 65535) { bad=1; next }
|
||||
}
|
||||
END { if (bad || !host) exit 1; printf "%s://%s:%d", scheme, tolower(host), port + 0 }
|
||||
'
|
||||
}
|
||||
|
||||
remote_curl_metrics() {
|
||||
[ -n "${OWRT_REMOTE_HTTP_METRICS:-}" ] || return 0
|
||||
# Parse numeric fields only. redirect_url may contain secrets and is excluded.
|
||||
LC_ALL=C awk -v secure="$2" -v resolver="$3" -v hop="$4" -v wan_dns="${5:-}" -v source="${6:-curl}" '
|
||||
NF >= 6 && $1 ~ /^[0-9][0-9][0-9]$/ {
|
||||
for (i=2; i<=6; i++) if ($i !~ /^[0-9]+(\.[0-9]+)?$/) exit
|
||||
dns=sprintf("%.1f", $2*1000); tcp=($3>0 ? sprintf("%.1f", ($3>$2 ? ($3-$2)*1000 : 0)) : "incomplete")
|
||||
if (source != "curl") dns=(wan_dns ~ /^[0-9]+$/ ? sprintf("%.1f", wan_dns+0) : "n/a")
|
||||
if (source !~ /^(curl|lookup|cache|literal|pinned|pre_resolved)$/) source="pre_resolved"
|
||||
tls=(secure == "https" ? ($4>0 ? sprintf("%.1f", ($4>$3 ? ($4-$3)*1000 : 0)) : "incomplete") : "n/a")
|
||||
printf "tool=curl HTTP=%s DNS_ms=%s TCP_ms=%s TLS_ms=%s TTFB_ms=%.1f total_ms=%.1f WAN_resolve_ms=%d hop=%d DNS_source=%s\n", $1, dns, tcp, tls, $5*1000, $6*1000, resolver, hop, source
|
||||
exit
|
||||
}' "$1" >>"$OWRT_REMOTE_HTTP_METRICS"
|
||||
}
|
||||
|
||||
remote_curl_post() (
|
||||
local url token file mode dir rc hop origin next_origin redirect code dns tcp tls first total target device resolve started remaining resolver_started resolver_ms dns_ms dns_source OWRT_REMOTE_DNS_STATS_FILE
|
||||
url="$1"; token="$2"; file="$3"; mode="${4:-normal}"
|
||||
origin="$(remote_url_origin "$url")" || return 3
|
||||
dir="$(mktemp -d "${TMPDIR:-/tmp}/owrt-remote-http.XXXXXX")" || return 1
|
||||
chmod 700 "$dir"
|
||||
trap 'rm -f "$dir/body" "$dir/stats" "$dir/error" "$dir/dns"; rmdir "$dir" 2>/dev/null || true' EXIT
|
||||
trap 'exit 1' INT TERM
|
||||
started="$(remote_clock_ms)"; hop=0
|
||||
while :; do
|
||||
resolver_ms=0; dns_ms=''; dns_source=curl
|
||||
set -- -q -fsS --connect-timeout 4 --noproxy '*' --proto '=http,https'
|
||||
if [ "$mode" = wan ]; then
|
||||
OWRT_REMOTE_DNS_STATS_FILE="$dir/dns"; : >"$dir/dns"
|
||||
dns_source=pre_resolved
|
||||
resolver_started="$(remote_clock_ms)"
|
||||
target="$(wan_http_target "$url")" || return 1
|
||||
resolver_ms=$(( $(remote_clock_ms) - resolver_started ))
|
||||
read -r dns_ms dns_source <"$dir/dns" || true
|
||||
device="${target%%|*}"; resolve="${target#*|}"
|
||||
set -- "$@" --interface "$device" --resolve "$resolve"
|
||||
fi
|
||||
remaining=$((10000 - $(remote_clock_ms) + started))
|
||||
[ "$remaining" -gt 0 ] || return 28
|
||||
remaining="$(LC_ALL=C awk -v value="$remaining" 'BEGIN { printf "%.3f", value/1000 }')"
|
||||
rc=0
|
||||
# Each permitted redirect is a separate authenticated POST. curl -L
|
||||
# drops Bearer auth on an origin change, including HTTP -> HTTPS.
|
||||
curl "$@" --max-time "$remaining" -o "$dir/body" \
|
||||
-w '%{http_code} %{time_namelookup} %{time_connect} %{time_appconnect} %{time_starttransfer} %{time_total} %{redirect_url}\n' \
|
||||
-H "Authorization: Bearer $token" -H 'Content-Type: application/json' \
|
||||
--data-binary "@$file" "$url" >"$dir/stats" 2>"$dir/error" || rc=$?
|
||||
remote_curl_metrics "$dir/stats" "${url%%:*}" "$resolver_ms" "$hop" "$dns_ms" "$dns_source"
|
||||
if [ "$rc" != 0 ]; then cat "$dir/error" >&2; return "$rc"; fi
|
||||
code=''; redirect=''
|
||||
read -r code dns tcp tls first total redirect <"$dir/stats" || true
|
||||
redirect="${redirect%"$(printf '\r')"}"
|
||||
case "$code" in
|
||||
301|302|303|307|308)
|
||||
[ -n "$redirect" ] && [ "$hop" -lt 3 ] || return 47
|
||||
next_origin="$(remote_url_origin "$redirect")" || return 47
|
||||
# Send credentials only within the same origin or to HTTPS on
|
||||
# the very same host. Never trust arbitrary redirect destinations.
|
||||
if [ "$origin" != "$next_origin" ]; then
|
||||
case "$origin|$next_origin" in
|
||||
http://*'|'https://*)
|
||||
# Compare hosts independently of the two ports.
|
||||
target="${next_origin%:*}"
|
||||
[ "${origin%:*}" = "http://${target#https://}" ] || return 47
|
||||
;;
|
||||
*) return 47 ;;
|
||||
esac
|
||||
fi
|
||||
url="$redirect"; origin="$next_origin"; hop=$((hop+1))
|
||||
;;
|
||||
*) [ ! -f "$dir/body" ] || cat "$dir/body"; return 0 ;;
|
||||
esac
|
||||
done
|
||||
)
|
||||
|
||||
post_json() (
|
||||
local url token file
|
||||
url="$1"
|
||||
@@ -827,13 +930,10 @@ post_json() (
|
||||
fi
|
||||
|
||||
if command -v curl >/dev/null 2>&1; then
|
||||
curl -fsSL --location --max-redirs 3 --post301 --post302 --post303 \
|
||||
--connect-timeout 4 --max-time 10 --noproxy '*' \
|
||||
-H "Authorization: Bearer $token" \
|
||||
-H "Content-Type: application/json" \
|
||||
--data-binary "@$file" "$url"
|
||||
remote_curl_post "$url" "$token" "$file"
|
||||
return
|
||||
fi
|
||||
[ -z "${OWRT_REMOTE_HTTP_METRICS:-}" ] || printf 'tool=uclient/wget DNS_ms=n/a TCP_ms=n/a TLS_ms=n/a\n' >>"$OWRT_REMOTE_HTTP_METRICS"
|
||||
if command -v wget >/dev/null 2>&1; then
|
||||
wget -q -T 10 -O - \
|
||||
--header="Authorization: Bearer $token" \
|
||||
@@ -918,6 +1018,7 @@ heartbeat_emit_endpoint() {
|
||||
local base marker
|
||||
base="$(normalize_url_base "$1")"
|
||||
[ -n "$base" ] || return 0
|
||||
case "${HEARTBEAT_REQUIRE_HTTPS:-0}|$base" in 1'|'http://*) return 0 ;; esac
|
||||
marker="|$base|"
|
||||
case "${HEARTBEAT_ENDPOINT_SEEN:-}" in
|
||||
*"$marker"*) return 0 ;;
|
||||
@@ -927,11 +1028,13 @@ heartbeat_emit_endpoint() {
|
||||
}
|
||||
|
||||
heartbeat_candidate_endpoints() {
|
||||
local hub_url public_url vps_host
|
||||
local hub_url public_url vps_host HEARTBEAT_REQUIRE_HTTPS
|
||||
HEARTBEAT_ENDPOINT_SEEN='|'
|
||||
hub_url="$(uci_get hub_url '')"
|
||||
public_url="$(uci_get public_url '')"
|
||||
vps_host="$(uci_get vps_host '')"
|
||||
HEARTBEAT_REQUIRE_HTTPS=0
|
||||
case "$hub_url" in https://*) HEARTBEAT_REQUIRE_HTTPS=1 ;; esac
|
||||
heartbeat_emit_endpoint "$hub_url"
|
||||
heartbeat_emit_endpoint "$public_url"
|
||||
case "$vps_host" in
|
||||
@@ -1010,8 +1113,31 @@ heartbeat_apply_hub_update() {
|
||||
fi
|
||||
}
|
||||
|
||||
send_heartbeat() {
|
||||
local hub_url token endpoint tmp response event used fallback_base errors rc
|
||||
heartbeat_failure_reason() {
|
||||
case "$1|$2" in
|
||||
*'|'401|*'|'403) printf auth_rejected ;;
|
||||
28'|'*) printf timeout ;;
|
||||
5'|'*|6'|'*) printf dns_failed ;;
|
||||
7'|'*) printf connect_failed ;;
|
||||
35'|'*) printf tls_handshake_failed ;;
|
||||
51'|'*|58'|'*|60'|'*|77'|'*) printf tls_verification_failed ;;
|
||||
47'|'*) printf redirect_rejected ;;
|
||||
*'|'408|*'|'429|*'|'500|*'|'502|*'|'503|*'|'504) printf server_temporary ;;
|
||||
18'|'*|52'|'*|55'|'*|56'|'*|92'|'*) printf connection_interrupted ;;
|
||||
0'|'*) printf invalid_heartbeat_response ;;
|
||||
*) printf request_failed ;;
|
||||
esac
|
||||
}
|
||||
|
||||
heartbeat_diagnostics() {
|
||||
local state
|
||||
state="${TMPDIR:-/tmp}/owrt-remote-heartbeat-last"
|
||||
printf 'Последний Heartbeat (только безопасные поля):\n'
|
||||
if [ -r "$state" ]; then cat "$state"; else printf 'Замеров пока нет; выполни owrt-remote heartbeat.\n'; fi
|
||||
}
|
||||
|
||||
send_heartbeat() (
|
||||
local hub_url token endpoint tmp response event used fallback_base errors rc dir metrics http attempt max_attempts reason previous previous_reason safe_endpoint elapsed started diagnostic
|
||||
event="${1:-}"
|
||||
hub_url="$(uci_get hub_url '')"
|
||||
token="$(uci_get hub_token '')"
|
||||
@@ -1023,34 +1149,68 @@ send_heartbeat() {
|
||||
wan_reconcile_xray
|
||||
fi
|
||||
|
||||
endpoint="${hub_url%/}/api/heartbeat"
|
||||
tmp="${TMPDIR:-/tmp}/owrt-remote-heartbeat.$$"
|
||||
response="${TMPDIR:-/tmp}/owrt-remote-heartbeat.response.$$"
|
||||
dir="$(mktemp -d "${TMPDIR:-/tmp}/owrt-remote-heartbeat.XXXXXX")" || return 1
|
||||
chmod 700 "$dir"
|
||||
trap 'rm -f "$dir/payload" "$dir/response" "$dir/response.error" "$dir/metrics" "$dir/last"; rmdir "$dir" 2>/dev/null || true' EXIT
|
||||
trap 'exit 1' INT TERM
|
||||
tmp="$dir/payload"; response="$dir/response"
|
||||
errors="$response.error"
|
||||
metrics="$dir/metrics"
|
||||
export OWRT_REMOTE_HTTP_METRICS="$metrics"
|
||||
heartbeat_json "$event" >"$tmp"
|
||||
used=0
|
||||
previous=''; previous_reason=''
|
||||
for endpoint in $(heartbeat_candidate_endpoints); do
|
||||
used=1
|
||||
rc=0
|
||||
post_json "$endpoint" "$token" "$tmp" >"$response" 2>"$errors" || rc=$?
|
||||
if [ "$rc" = 0 ] && grep -Eq '"ok"[[:space:]]*:[[:space:]]*true' "$response"; then
|
||||
fallback_base="$(heartbeat_base_from_endpoint "$endpoint")"
|
||||
if ! heartbeat_apply_hub_update "$response" "$fallback_base"; then
|
||||
log 'Heartbeat: Hub ответил, но обновление настроек не применилось'
|
||||
rm -f "$tmp" "$response" "$errors"
|
||||
return 1
|
||||
fi
|
||||
cat "$response"
|
||||
log "Heartbeat: OK; Hub=$fallback_base; WAN_direct=$(uci_get wan_direct 0); WAN_active=$(cat "$WAN_STATE/active-interface" 2>/dev/null)"
|
||||
rm -f "$tmp" "$response" "$errors"
|
||||
return 0
|
||||
safe_endpoint="$(remote_url_origin "$endpoint")" || { log 'Heartbeat: ошибка; reason=invalid_endpoint'; continue; }
|
||||
if [ -n "$previous" ]; then
|
||||
log "Heartbeat: fallback; from=$previous; to=$safe_endpoint; reason=$previous_reason; предыдущие попытки исчерпаны"
|
||||
fi
|
||||
log "Heartbeat: ошибка; endpoint=$endpoint; rc=$rc; $(head -c 1024 "$errors"); ответ=$(head -c 1024 "$response")"
|
||||
attempt=1; max_attempts=1
|
||||
case "$endpoint" in https://*) max_attempts=2 ;; esac
|
||||
while [ "$attempt" -le "$max_attempts" ]; do
|
||||
rc=0; : >"$metrics"; started="$(remote_clock_ms)"
|
||||
post_json "$endpoint" "$token" "$tmp" >"$response" 2>"$errors" || rc=$?
|
||||
elapsed=$(( $(remote_clock_ms) - started ))
|
||||
http="$(sed -n 's/.*HTTP=\([0-9][0-9][0-9]\).*/\1/p' "$metrics" | tail -n 1)"
|
||||
reason="$(heartbeat_failure_reason "$rc" "$http")"
|
||||
if grep -Fq 'Failed to allocate uclient context' "$errors"; then reason=http_client_context_failed; fi
|
||||
diagnostic="endpoint=$safe_endpoint; attempt=$attempt/$max_attempts; rc=$rc; reason=$reason; elapsed_ms=$elapsed; $(tail -n 1 "$metrics")"
|
||||
printf '%s\n' "$diagnostic" >"$dir/last"
|
||||
mv -f "$dir/last" "${TMPDIR:-/tmp}/owrt-remote-heartbeat-last"
|
||||
if [ "$rc" = 0 ] && grep -Eq '"ok"[[:space:]]*:[[:space:]]*true' "$response"; then
|
||||
fallback_base="$(heartbeat_base_from_endpoint "$endpoint")"
|
||||
if ! heartbeat_apply_hub_update "$response" "$fallback_base"; then
|
||||
log 'Heartbeat: Hub ответил, но обновление настроек не применилось'
|
||||
return 1
|
||||
fi
|
||||
# Stable OK messages remain deduplicated by the RAM journal;
|
||||
# fresh timings are available separately in network-diagnostics.
|
||||
printf '%s\n' "endpoint=$safe_endpoint; attempt=$attempt/$max_attempts; rc=0; reason=ok; elapsed_ms=$elapsed; $(tail -n 1 "$metrics")" >"$dir/last"
|
||||
mv -f "$dir/last" "${TMPDIR:-/tmp}/owrt-remote-heartbeat-last"
|
||||
cat "$response"
|
||||
log "Heartbeat: OK; Hub=$safe_endpoint; WAN_direct=$(uci_get wan_direct 0); WAN_active=$(cat "$WAN_STATE/active-interface" 2>/dev/null)"
|
||||
return 0
|
||||
fi
|
||||
# Do not log curl stderr or response bodies: either may echo secrets.
|
||||
log "Heartbeat: ошибка; $diagnostic"
|
||||
[ "$reason" != auth_rejected ] || return 1
|
||||
case "$reason" in timeout|dns_failed|connect_failed|tls_handshake_failed|server_temporary|connection_interrupted)
|
||||
if [ "$attempt" -lt "$max_attempts" ]; then
|
||||
attempt=$((attempt+1))
|
||||
log "Heartbeat: retry HTTPS; endpoint=$safe_endpoint; attempt=$attempt/$max_attempts; reason=$reason; delay=1s"
|
||||
sleep 1
|
||||
continue
|
||||
fi ;;
|
||||
esac
|
||||
break
|
||||
done
|
||||
previous="$safe_endpoint"; previous_reason="$reason"
|
||||
done
|
||||
rm -f "$tmp" "$response" "$errors"
|
||||
[ "$used" = "1" ] || die "hub_url/public_url/vps_host пустые"
|
||||
case "$hub_url" in https://*) log 'Heartbeat: fallback остановлен; reason=https_required; автоматический переход на HTTP отключён' ;; esac
|
||||
return 1
|
||||
}
|
||||
)
|
||||
|
||||
wan_reconcile_xray() {
|
||||
local config bound device
|
||||
@@ -1417,6 +1577,7 @@ case "$cmd" in
|
||||
;;
|
||||
network-diagnostics)
|
||||
wan_diagnostics
|
||||
heartbeat_diagnostics
|
||||
;;
|
||||
install-xray-tmp)
|
||||
install_xray_tmp
|
||||
@@ -1440,6 +1601,9 @@ case "$cmd" in
|
||||
heartbeat-loop)
|
||||
heartbeat_loop
|
||||
;;
|
||||
heartbeat-diagnostics)
|
||||
heartbeat_diagnostics
|
||||
;;
|
||||
logs-sync)
|
||||
sync_global_logs
|
||||
;;
|
||||
|
||||
@@ -0,0 +1,120 @@
|
||||
# Heartbeat: HTTPS, авторизация и диагностика (v116)
|
||||
|
||||
## Разбор сбоя 15.10.2026
|
||||
|
||||
В прежнем клиенте после первой ошибки HTTPS сразу проверялся следующий
|
||||
адрес, в том числе автоматически сформированный HTTP. Повторной попытки
|
||||
того же HTTPS до переключения не было. Настроенный Hub URL при этом
|
||||
не обязательно менялся: перебор адресов происходил внутри одного цикла.
|
||||
|
||||
Bearer-заголовок в исходном запросе формировался одинаково для всех адресов.
|
||||
Однако curl с `--location` снимает Authorization при смене origin, включая
|
||||
HTTP → HTTPS. `--post301` сохраняет POST, но не авторизацию. Это объясняет
|
||||
цепочку HTTP 301 → HTTPS 401 при правильном токене. Механизм воспроизведён
|
||||
на локальных HTTP/HTTPS-серверах с настоящим curl и проверкой сертификата.
|
||||
Заголовки реального nginx в момент исходного сбоя не захватывались, поэтому
|
||||
совпадение с конкретным историческим запросом остаётся предположением.
|
||||
|
||||
Один `rc=28` и нулевое тело ответа не определяют, на каком этапе был тайм-аут.
|
||||
Текущие быстрые ответы `/health` не доказывают причину прошедшего сбоя.
|
||||
HTTP 401 на `/api/heartbeat` без авторизации ожидаем. Интервал примерно
|
||||
32 секунды совместим с прежним циклом: время запроса плюс пауза 30 секунд.
|
||||
|
||||
Официальное описание curl: https://curl.se/docs/manpage.html
|
||||
|
||||
## Поведение после исправления
|
||||
|
||||
- При временной ошибке HTTPS выполняется одна повторная попытка того же
|
||||
адреса через секунду: максимум две попытки по 10 секунд на адрес.
|
||||
- Повторяются тайм-ауты, ошибки DNS/TCP, TLS handshake, обрывы соединения
|
||||
и временные ответы сервера 408/429/500/502/503/504. Ошибка проверки
|
||||
сертификата не повторяется автоматически.
|
||||
- После исчерпания попыток можно перейти к следующему HTTPS-кандидату.
|
||||
При настроенном HTTPS HTTP-кандидаты исключены, включая порт 8088.
|
||||
Явно настроенные установки HTTP продолжают работать.
|
||||
- HTTP 401/403 завершает цикл с `reason=auth_rejected`; перебор адресов
|
||||
не используется для обхода отказа авторизации.
|
||||
- curl больше не следует перенаправлениям автоматически. Разрешены
|
||||
максимум три перехода в пределах origin либо HTTP → HTTPS на том же
|
||||
хосте. Каждый разрешённый переход повторяет JSON POST с Bearer.
|
||||
Смена хоста и HTTPS → HTTP отклоняются. Проверка TLS сохранена.
|
||||
- При прямом WAN интерфейс и `--resolve` рассчитываются для каждого
|
||||
разрешённого перехода, включая новый HTTPS-порт. Xray и правила
|
||||
маршрутизации этим исправлением не переписываются.
|
||||
|
||||
## Диагностика и хранение
|
||||
|
||||
`owrt-remote heartbeat-diagnostics` показывает последний результат.
|
||||
Он также добавлен к `owrt-remote network-diagnostics`.
|
||||
Снимок атомарно заменяется в `/tmp/owrt-remote-heartbeat-last` — на OpenWrt
|
||||
это RAM. Временные тела запросов/ответов находятся в приватных каталогах
|
||||
`/tmp` и удаляются после запроса. Настройки UCI не меняются из-за замеров.
|
||||
|
||||
Поля результата: безопасный origin без пути, query и userinfo, номер
|
||||
попытки, rc, HTTP, причина, общее время, DNS, TCP, TLS и время до первого
|
||||
байта. В журнале ошибки содержат эти замеры, переключение — исходный
|
||||
и следующий origin с причиной. Успешные записи остаются стабильными
|
||||
для существующего подавления повторов; свежие замеры находятся в снимке.
|
||||
Сырые stderr curl и тела ответов не записываются в журнал: сервер может
|
||||
отразить туда секрет. Токен и Authorization в диагностике отсутствуют.
|
||||
|
||||
Все времена в миллисекундах:
|
||||
|
||||
- `DNS_ms` — время разрешения имени curl; при прямом WAN измеряется
|
||||
отдельный запрос WAN DNS. `DNS_source=cache/pinned/literal` означает,
|
||||
что DNS-запрос не требовался; `lookup` — запрос выполнялся.
|
||||
- `TCP_ms` — `time_connect - time_namelookup`.
|
||||
- `TLS_ms` — `time_appconnect - time_connect`; `incomplete` означает,
|
||||
что этап не завершился. TCP тоже может быть `incomplete`.
|
||||
- `TTFB_ms` — от начала запроса curl до первого байта, `total_ms` —
|
||||
полное время curl. `elapsed_ms` включает подготовку запроса.
|
||||
- `WAN_resolve_ms` — подготовка WAN-адреса и маршрута; это не чистое
|
||||
время DNS. При `--resolve` системный DNS curl не используется.
|
||||
- Для wget/uclient, у которых нет аналогичного write-out, этапы помечены
|
||||
`n/a`, без выдуманных измерений.
|
||||
|
||||
## Установка и откат из Windows PowerShell
|
||||
|
||||
```powershell
|
||||
powershell.exe -NoProfile -ExecutionPolicy Bypass -File "C:\Users\k.zolotarev95\Documents\openwrt overlay\vps\deploy-heartbeat-transport-fix.ps1" -Router "root@192.168.2.1" -Action Install
|
||||
```
|
||||
|
||||
Обновляются агент и WAN helper. Перезапускается только экземпляр Heartbeat
|
||||
под procd; Xray и удалённый туннель скрипт не перезапускает. Остановленный
|
||||
экземпляр остаётся остановленным. Резервная копия первых файлов сохраняется
|
||||
в `/root/owrt-remote-backup-before-heartbeat-transport-v116`.
|
||||
Маркер `HEARTBEAT_TRANSPORT_ROUTER_Install_OK` подтверждает установку кода,
|
||||
а доступность Hub проверяется отдельно:
|
||||
|
||||
```powershell
|
||||
ssh root@192.168.2.1 'owrt-remote heartbeat >/dev/null; echo HEARTBEAT_RC=$?; owrt-remote heartbeat-diagnostics; logread -e owrt-remote | tail -n 35'
|
||||
```
|
||||
|
||||
`HEARTBEAT_RC=0`, `reason=ok` и `HTTP=200` подтверждают успешный запрос.
|
||||
Для отката:
|
||||
|
||||
```powershell
|
||||
powershell.exe -NoProfile -ExecutionPolicy Bypass -File "C:\Users\k.zolotarev95\Documents\openwrt overlay\vps\deploy-heartbeat-transport-fix.ps1" -Router "root@192.168.2.1" -Action Rollback
|
||||
```
|
||||
|
||||
При неполной/отсутствующей копии откат прекращается до изменения файлов.
|
||||
При ошибке установки восстанавливаются оба файла текущей попытки.
|
||||
|
||||
## Локальные проверки
|
||||
|
||||
`test_heartbeat_transport.py` проверяет повтор HTTPS, запрет HTTP fallback,
|
||||
401/403, безопасные поля и замеры DNS/TCP/TLS. Реальные HTTP/HTTPS-серверы
|
||||
проверяют потерю Bearer в прежнем curl, исправленный переход, запрет чужого
|
||||
хоста/понижения TLS, относительный redirect, предел redirect и прямой WAN.
|
||||
Самоподписанный тестовый CA явно доверен только тестовому curl; `-k` нет.
|
||||
|
||||
`test_heartbeat_transport_deploy.py` проверяет повторную установку, исходную
|
||||
резервную копию, откат, отказы до/после записи и адресный перезапуск только
|
||||
Heartbeat. Дополнительно выполняются host policy, WAN failover, доставка
|
||||
журналов, Xray apply и Xray validation.
|
||||
|
||||
Результат локальной проверки 15.10.2026: 14 тестов транспорта и 91 тест
|
||||
регрессии прошли успешно, без пропусков. В проверках применения настроек
|
||||
использовался настоящий Xray 26.3.27. PowerShell и POSIX-синтаксис проверены,
|
||||
пакет подготовки содержит UTF-8 без BOM и окончания строк LF. На реальный
|
||||
роутер этот локальный фикс автоматически не устанавливался.
|
||||
@@ -0,0 +1,73 @@
|
||||
# WAN IPv4 DNS fallback (local v116 fix)
|
||||
|
||||
`files/usr/lib/owrt-remote/wan.sh` now explicitly queries
|
||||
`nslookup -type=A -timeout=3 -retry=1 "$host" "$dns"`.
|
||||
BusyBox's default lookup sends both A and AAAA queries; explicit `-type=A`
|
||||
and the timeout/retry options are supported by its internal resolver. See
|
||||
[BusyBox 1.36 nslookup source](https://github.com/mirror/busybox/blob/1_36_stable/networking/nslookup.c)
|
||||
and [OpenWrt 24.10 BusyBox options](https://github.com/openwrt/openwrt/blob/openwrt-24.10/package/utils/busybox/config/networking/Config.in).
|
||||
|
||||
The parser preserves the nslookup exit status and accepts only a valid IPv4
|
||||
answer for the queried name or its CNAME chain after a successful query.
|
||||
Resolver headers, unrelated names, malformed IPv4, IPv6 answers and
|
||||
198.18.0.0/15 fake-IP addresses cannot populate the IPv4 cache. Existing
|
||||
explicit IPv6 literals keep their prior behavior.
|
||||
|
||||
The original cache policy is retained: a successful IPv4 is reused for
|
||||
5 minutes; on a failed refresh the last successful address remains usable
|
||||
until its original timestamp is 1 hour old. Failed refreshes do not extend
|
||||
that timestamp. Corrupt timestamps, future timestamps and invalid cached
|
||||
addresses are rejected. The cache remains under `/tmp/owrt-remote-wan`.
|
||||
|
||||
Failure diagnostics distinguish `reason=timeout`, `reason=no_a_record`,
|
||||
`reason=parse_error`, `reason=resolver_error` and `reason=rejected_address`.
|
||||
They include the domain, selected resolver and original exit status, without
|
||||
raw DNS output. A successful A answer emits no `WAN DNS unavailable` warning.
|
||||
WAN/DNS selection, Podkop, Xray and route/policy-rule implementations are
|
||||
unchanged by this fix.
|
||||
|
||||
## Verification
|
||||
|
||||
```powershell
|
||||
$env:PYTHONPATH = 'tests'
|
||||
python -m unittest test_wan_dns test_wan_dns_deploy -v
|
||||
# Optional second run with actual BusyBox ash and built-in awk:
|
||||
$env:OWRT_TEST_BUSYBOX = 'C:\path\to\busybox64.exe'
|
||||
python -m unittest test_wan_dns test_wan_dns_deploy -v
|
||||
```
|
||||
|
||||
22 tests cover A-only arguments for both reported resolvers, BusyBox answer
|
||||
formats, CNAME chains, DNS errors, validation, cache bounds, syntax, repeated
|
||||
installation, exact rollback and recovery after installation failures.
|
||||
The BusyBox ash run uses busybox-w32 1.38.0-FRP-6075 and its built-in applets,
|
||||
with fixture nslookup replies. The executable is obtained from the
|
||||
[maintainer](https://frippery.org/busybox/) and checked against its SHA256SUM.
|
||||
This is not a live OpenWrt DNS/network test; OpenWrt 24.10 option compatibility
|
||||
is additionally checked against the linked BusyBox sources.
|
||||
|
||||
## Local installation and rollback
|
||||
|
||||
`vps/deploy-wan-dns-fix.ps1` extracts only the DNS functions from the local
|
||||
source and replaces the corresponding block in the router's existing
|
||||
`wan.sh`. Everything before and after that block is preserved, including
|
||||
differences between the published agent and the previous local heartbeat
|
||||
transport fix. The agent itself is not replaced.
|
||||
|
||||
```powershell
|
||||
powershell.exe -NoProfile -ExecutionPolicy Bypass -File "C:\Users\k.zolotarev95\Documents\openwrt overlay\vps\deploy-wan-dns-fix.ps1" -Router "root@192.168.2.1" -Action Install
|
||||
```
|
||||
|
||||
The installer saves the first backup at
|
||||
`/root/owrt-remote-backup-before-wan-dns-v116/wan.sh`, checks shell syntax and
|
||||
reloads only the supervised heartbeat instance so it reads the new helper.
|
||||
It does not restart Xray or regenerate configuration/routing. Installation
|
||||
verification/reload failures restore the file from that attempt.
|
||||
|
||||
```powershell
|
||||
powershell.exe -NoProfile -ExecutionPolicy Bypass -File "C:\Users\k.zolotarev95\Documents\openwrt overlay\vps\deploy-wan-dns-fix.ps1" -Router "root@192.168.2.1" -Action Rollback
|
||||
```
|
||||
|
||||
Rollback restores the entire saved `wan.sh`; use it before installing later
|
||||
changes to that file. No service is started if heartbeat was already stopped.
|
||||
All uploads use UTF-8 without BOM and LF. `-PrepareOnly` creates local payloads
|
||||
for inspection without contacting the router.
|
||||
@@ -0,0 +1,288 @@
|
||||
"""HTTPS retry policy, origin-scoped auth, timings and real curl redirects."""
|
||||
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import shutil
|
||||
import ssl
|
||||
import subprocess
|
||||
import threading
|
||||
import unittest
|
||||
|
||||
import test_host_policy as shell_tests
|
||||
|
||||
ROOT, SH = shell_tests.ROOT, shell_tests.SH
|
||||
|
||||
|
||||
@unittest.skipUnless(SH, "POSIX shell required")
|
||||
class HeartbeatTransportTests(unittest.TestCase):
|
||||
setUp = shell_tests.RouterShellTests.setUp
|
||||
config = shell_tests.RouterShellTests.config
|
||||
run_shell = shell_tests.RouterShellTests.run_shell
|
||||
|
||||
def policy(self, commands, **env):
|
||||
self.config(hub_url="https://primary.example", public_url="https://backup.example",
|
||||
vps_host="192.0.2.7", hub_token="never-log-this-token")
|
||||
self.directory.joinpath("calls").write_text("")
|
||||
return self.run_shell(r'''
|
||||
heartbeat_json() { printf '{"id":"test-router"}'; }
|
||||
sleep() { printf 'sleep %s\n' "$*" >>"$TEST_ROOT/calls"; }
|
||||
''' + commands, **env)
|
||||
|
||||
def test_one_timeout_retries_https_without_http_or_setting_changes(self):
|
||||
result = self.policy(r'''
|
||||
post_json() {
|
||||
printf '%s\n' "$1" >>"$TEST_ROOT/calls"
|
||||
if [ ! -f "$TEST_ROOT/tried" ]; then touch "$TEST_ROOT/tried"; return 28; fi
|
||||
printf '{"ok":true}'
|
||||
}
|
||||
send_heartbeat >/dev/null
|
||||
''')
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
self.assertEqual(self.directory.joinpath("calls").read_text().splitlines(),
|
||||
["https://primary.example/api/heartbeat", "sleep 1", "https://primary.example/api/heartbeat"])
|
||||
self.assertIn("retry HTTPS", result.stderr)
|
||||
self.assertNotIn("fallback;", result.stderr)
|
||||
self.assertNotIn("never-log-this-token", result.stderr)
|
||||
self.assertFalse(self.directory.joinpath("commits").exists())
|
||||
self.assertEqual(self.directory.joinpath("owrt-remote-heartbeat-last").read_text().split("reason=")[1].split(";")[0], "ok")
|
||||
|
||||
def test_exhausted_https_uses_secure_backup_and_explains_reason(self):
|
||||
result = self.policy(r'''
|
||||
post_json() {
|
||||
printf '%s\n' "$1" >>"$TEST_ROOT/calls"
|
||||
case "$1" in https://backup.example/*) printf '{"ok":true}' ;; *) return 28 ;; esac
|
||||
}
|
||||
send_heartbeat >/dev/null
|
||||
''')
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
calls = self.directory.joinpath("calls").read_text()
|
||||
self.assertEqual(calls.count("https://primary.example/api/heartbeat"), 2)
|
||||
self.assertIn("https://backup.example/api/heartbeat", calls)
|
||||
self.assertNotIn("http://", calls)
|
||||
self.assertIn("fallback; from=https://primary.example:443; to=https://backup.example:443; reason=timeout", result.stderr)
|
||||
|
||||
def test_https_never_uses_plain_http_even_after_all_retries(self):
|
||||
result = self.policy(r'''
|
||||
post_json() { printf '%s\n' "$1" >>"$TEST_ROOT/calls"; return 28; }
|
||||
send_heartbeat
|
||||
''')
|
||||
self.assertEqual(result.returncode, 1, result.stderr)
|
||||
self.assertNotIn("http://", self.directory.joinpath("calls").read_text())
|
||||
self.assertIn("reason=https_required", result.stderr)
|
||||
|
||||
def test_401_does_not_retry_or_change_endpoint_and_never_logs_echoed_secrets(self):
|
||||
result = self.policy(r'''
|
||||
post_json() {
|
||||
printf '%s\n' "$1" >>"$TEST_ROOT/calls"
|
||||
printf 'tool=curl HTTP=401 DNS_ms=1 TCP_ms=2 TLS_ms=3\n' >"$OWRT_REMOTE_HTTP_METRICS"
|
||||
printf 'Authorization: Bearer never-log-this-token\n' >&2
|
||||
printf '{"hub_token":"never-log-this-token"}'
|
||||
return 22
|
||||
}
|
||||
send_heartbeat
|
||||
''')
|
||||
self.assertEqual(result.returncode, 1, result.stderr)
|
||||
self.assertEqual(self.directory.joinpath("calls").read_text().splitlines(), ["https://primary.example/api/heartbeat"])
|
||||
self.assertIn("reason=auth_rejected", result.stderr)
|
||||
self.assertIn("HTTP=401", result.stderr)
|
||||
self.assertNotIn("never-log-this-token", result.stdout + result.stderr)
|
||||
|
||||
def test_http_only_configuration_still_works_and_origin_removes_secrets(self):
|
||||
self.config(hub_url="http://plain.example:8088", public_url="http://plain.example:8088", hub_token="test-token")
|
||||
result = self.run_shell(r'''
|
||||
heartbeat_json() { printf '{}'; }
|
||||
post_json() { printf '{"ok":true}'; }
|
||||
send_heartbeat >/dev/null
|
||||
remote_url_origin 'https://hub.example/path?token=secret#secret'
|
||||
''')
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
self.assertEqual(result.stdout, "https://hub.example:443")
|
||||
self.assertNotIn("secret", result.stderr)
|
||||
|
||||
def test_certificate_error_is_not_retried_and_never_uses_http(self):
|
||||
result = self.policy(r'''
|
||||
post_json() { printf '%s\n' "$1" >>"$TEST_ROOT/calls"; return 60; }
|
||||
send_heartbeat
|
||||
''')
|
||||
self.assertEqual(result.returncode, 1, result.stderr)
|
||||
calls = self.directory.joinpath("calls").read_text()
|
||||
self.assertEqual(calls.count("https://primary.example/api/heartbeat"), 1)
|
||||
self.assertNotIn("sleep", calls)
|
||||
self.assertNotIn("http://", calls)
|
||||
self.assertIn("reason=tls_verification_failed", result.stderr)
|
||||
|
||||
def test_timing_deltas_and_safe_fields_only(self):
|
||||
self.directory.joinpath("stats").write_text("200 0.010 0.030 0.080 0.100 0.120 https://evil.example/?token=secret\n")
|
||||
result = self.run_shell(r'''
|
||||
OWRT_REMOTE_HTTP_METRICS="$TEST_ROOT/metrics"
|
||||
remote_curl_metrics "$TEST_ROOT/stats" https 15 1
|
||||
cat "$TEST_ROOT/metrics"
|
||||
''')
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
self.assertIn("DNS_ms=10.0 TCP_ms=20.0 TLS_ms=50.0", result.stdout)
|
||||
self.assertIn("WAN_resolve_ms=15 hop=1", result.stdout)
|
||||
self.assertNotIn("secret", result.stdout)
|
||||
self.assertNotIn("evil", result.stdout)
|
||||
|
||||
def test_wan_dns_timing_distinguishes_lookup_cache_and_pinned_host(self):
|
||||
self.config(vps_host="hub.example", vps_host_mode="manual")
|
||||
self.directory.joinpath("stats").write_text("200 0.000 0.030 0.080 0.100 0.120\n")
|
||||
result = self.run_shell(r'''
|
||||
OWRT_REMOTE_HTTP_METRICS="$TEST_ROOT/metrics"
|
||||
OWRT_REMOTE_DNS_METRICS="$TEST_ROOT/dns-time"
|
||||
wan_resolve_host hub.example >/dev/null || exit
|
||||
read -r duration source <"$TEST_ROOT/dns-time"
|
||||
[ "$source" = lookup ] || exit 81
|
||||
wan_resolve_host hub.example >/dev/null || exit
|
||||
read -r duration source <"$TEST_ROOT/dns-time"
|
||||
[ "$duration $source" = '0 cache' ] || exit 82
|
||||
remote_curl_metrics "$TEST_ROOT/stats" https 15 0 "$duration" "$source"
|
||||
uci set owrtremote.main.vps_host=192.0.2.1
|
||||
wan_endpoint_ip https://hub.example/api/heartbeat >/dev/null || exit
|
||||
read -r duration source <"$TEST_ROOT/dns-time"
|
||||
[ "$duration $source" = '0 pinned' ] || exit 83
|
||||
remote_curl_metrics "$TEST_ROOT/stats" https 15 0 "$duration" "$source"
|
||||
cat "$TEST_ROOT/metrics"
|
||||
''')
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
self.assertIn("DNS_ms=0.0", result.stdout)
|
||||
self.assertIn("DNS_source=cache", result.stdout)
|
||||
self.assertIn("DNS_source=pinned", result.stdout)
|
||||
|
||||
|
||||
@unittest.skipUnless(SH, "POSIX shell required")
|
||||
class CurlRedirectTests(unittest.TestCase):
|
||||
setUp = shell_tests.RouterShellTests.setUp
|
||||
config = shell_tests.RouterShellTests.config
|
||||
run_shell = shell_tests.RouterShellTests.run_shell
|
||||
|
||||
def prepare(self, secure_front=False):
|
||||
if os.name == "nt":
|
||||
bindir = Path(os.environ.get("ProgramFiles", "C:/Program Files")) / "Git/mingw64/bin"
|
||||
self.curl = bindir / "curl.exe"
|
||||
openssl = bindir / "openssl.exe"
|
||||
else:
|
||||
self.curl = Path(shutil.which("curl") or "/nonexistent")
|
||||
openssl = Path(shutil.which("openssl") or "/nonexistent")
|
||||
if not self.curl.exists() or not openssl.exists():
|
||||
self.skipTest("real curl and OpenSSL required")
|
||||
cert = self.directory / "cert.pem"
|
||||
key = self.directory / "key.pem"
|
||||
subprocess.run([str(openssl), "req", "-x509", "-newkey", "rsa:2048", "-nodes", "-days", "1",
|
||||
"-subj", "/CN=localhost", "-addext", "subjectAltName=DNS:localhost,IP:127.0.0.1",
|
||||
"-keyout", str(key), "-out", str(cert)], check=True, capture_output=True)
|
||||
self.env.update(TEST_CURL=self.curl.as_posix(), TEST_CA_CERT=cert.as_posix())
|
||||
self.directory.joinpath("payload").write_bytes(b'{"id":"test-router"}')
|
||||
self.config(wan_direct="0")
|
||||
self.records = []
|
||||
|
||||
owner = self
|
||||
|
||||
class Handler(BaseHTTPRequestHandler):
|
||||
def log_message(self, *args):
|
||||
pass
|
||||
|
||||
def do_POST(self):
|
||||
body = self.rfile.read(int(self.headers.get("Content-Length", 0)))
|
||||
owner.records.append((self.server.server_port, self.path, self.headers.get("Authorization"), body))
|
||||
if self.server is owner.front and self.path == "/api/heartbeat":
|
||||
self.send_response(owner.redirect_code)
|
||||
self.send_header("Location", owner.destination)
|
||||
response = b""
|
||||
else:
|
||||
self.send_response(200 if self.headers.get("Authorization") == "Bearer test-token" else 401)
|
||||
response = b'{"ok":true}'
|
||||
self.send_header("Content-Length", str(len(response)))
|
||||
self.end_headers()
|
||||
self.wfile.write(response)
|
||||
|
||||
context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
|
||||
context.load_cert_chain(cert, key)
|
||||
self.back = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
|
||||
self.back.socket = context.wrap_socket(self.back.socket, server_side=True)
|
||||
self.front = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
|
||||
if secure_front:
|
||||
self.front.socket = context.wrap_socket(self.front.socket, server_side=True)
|
||||
for server in (self.front, self.back):
|
||||
thread = threading.Thread(target=server.serve_forever, daemon=True)
|
||||
thread.start()
|
||||
self.addCleanup(server.server_close)
|
||||
self.addCleanup(server.shutdown)
|
||||
self.redirect_code = 301
|
||||
self.destination = f"https://localhost:{self.back.server_port}/api/heartbeat"
|
||||
self.url = f"{'https' if secure_front else 'http'}://localhost:{self.front.server_port}/api/heartbeat"
|
||||
# shell_tests supplies a mock curl; replace only the executable binding.
|
||||
self.real = r'''
|
||||
curl() { "$TEST_CURL" -q --cacert "$TEST_CA_CERT" "$@"; }
|
||||
OWRT_REMOTE_HTTP_METRICS="$TEST_ROOT/metrics"
|
||||
export OWRT_REMOTE_HTTP_METRICS
|
||||
'''
|
||||
|
||||
def test_real_curl_reproduces_401_then_upgrade_keeps_json_and_auth(self):
|
||||
self.prepare()
|
||||
old = subprocess.run([str(self.curl), "-q", "--cacert", self.env["TEST_CA_CERT"], "-fsSL", "--noproxy", "*", "--max-time", "5",
|
||||
"--post301", "-H", "Authorization: Bearer test-token", "-H", "Content-Type: application/json",
|
||||
"--data-binary", "@" + str(self.directory / "payload"), self.url],
|
||||
env=self.env, capture_output=True)
|
||||
self.assertEqual(old.returncode, 22, old.stderr)
|
||||
self.assertEqual(self.records[-1][2], None, "curl drops auth across HTTP -> HTTPS")
|
||||
self.records.clear()
|
||||
result = self.run_shell(self.real + 'post_json "$TEST_URL" test-token "$TEST_ROOT/payload"', TEST_URL=self.url)
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
self.assertTrue(json.loads(result.stdout)["ok"])
|
||||
self.assertEqual([x[2] for x in self.records], ["Bearer test-token"] * 2)
|
||||
self.assertTrue(all(x[3] == b'{"id":"test-router"}' for x in self.records))
|
||||
self.assertEqual(len(self.directory.joinpath("metrics").read_text().splitlines()), 2)
|
||||
self.assertFalse(list(self.directory.glob("owrt-remote-http.*")))
|
||||
|
||||
def test_rejects_cross_host_without_forwarding_token(self):
|
||||
self.prepare()
|
||||
self.destination = f"https://127.0.0.1:{self.back.server_port}/api/heartbeat?token=secret"
|
||||
result = self.run_shell(self.real + 'post_json "$TEST_URL" test-token "$TEST_ROOT/payload"', TEST_URL=self.url)
|
||||
self.assertEqual(result.returncode, 47, result.stderr)
|
||||
self.assertEqual(len(self.records), 1)
|
||||
self.assertNotIn("secret", self.directory.joinpath("metrics").read_text())
|
||||
|
||||
def test_rejects_tls_downgrade_without_forwarding_token(self):
|
||||
self.prepare(secure_front=True)
|
||||
self.destination = self.url.replace("https://", "http://")
|
||||
result = self.run_shell(self.real + 'post_json "$TEST_URL" test-token "$TEST_ROOT/payload"', TEST_URL=self.url)
|
||||
self.assertEqual(result.returncode, 47, result.stderr)
|
||||
self.assertEqual(len(self.records), 1)
|
||||
|
||||
def test_same_origin_relative_redirect_preserves_auth_and_post(self):
|
||||
self.prepare(secure_front=True)
|
||||
self.destination = "/redirected"
|
||||
self.redirect_code = 307
|
||||
result = self.run_shell(self.real + 'post_json "$TEST_URL" test-token "$TEST_ROOT/payload"', TEST_URL=self.url)
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
self.assertTrue(json.loads(result.stdout)["ok"])
|
||||
self.assertEqual([x[1] for x in self.records], ["/api/heartbeat", "/redirected"])
|
||||
self.assertEqual([x[2] for x in self.records], ["Bearer test-token"] * 2)
|
||||
|
||||
def test_repeated_redirects_are_bounded(self):
|
||||
self.prepare()
|
||||
self.destination = self.url
|
||||
result = self.run_shell(self.real + 'post_json "$TEST_URL" test-token "$TEST_ROOT/payload"', TEST_URL=self.url)
|
||||
self.assertEqual(result.returncode, 47, result.stderr)
|
||||
self.assertEqual(len(self.records), 4)
|
||||
|
||||
def test_wan_redirect_resolves_and_binds_both_hops(self):
|
||||
self.prepare()
|
||||
result = self.run_shell(self.real + r'''
|
||||
wan_http_target() {
|
||||
local port
|
||||
printf '%s\n' "$1" >>"$TEST_ROOT/targets"
|
||||
port="${1#*localhost:}"; port="${port%%/*}"
|
||||
printf '127.0.0.1|localhost:%s:127.0.0.1' "$port"
|
||||
}
|
||||
wan_post_json "$TEST_URL" test-token "$TEST_ROOT/payload"
|
||||
''', TEST_URL=self.url)
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
self.assertEqual(self.directory.joinpath("targets").read_text().splitlines(), [self.url, self.destination])
|
||||
self.assertEqual([x[2] for x in self.records], ["Bearer test-token"] * 2)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,122 @@
|
||||
"""Run installation and rollback in a sandbox, without SSH or services."""
|
||||
import os
|
||||
from pathlib import Path
|
||||
import shlex
|
||||
import subprocess
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
from test_xray_mobile_deploy import SH, GIT_BIN, ROOT
|
||||
|
||||
|
||||
@unittest.skipUnless(SH, "POSIX shell required")
|
||||
class HeartbeatTransportDeploymentTests(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.temp = tempfile.TemporaryDirectory(prefix="heartbeat-transport-deploy-")
|
||||
self.addCleanup(self.temp.cleanup)
|
||||
self.root = Path(self.temp.name)
|
||||
self.targets = {"wan.sh": self.root / "wan.sh", "agent": self.root / "agent"}
|
||||
for name, path in self.targets.items():
|
||||
path.write_text("#!/bin/sh\necho previous-" + name + "\n", encoding="utf-8", newline="\n")
|
||||
self.original = {name: path.read_bytes() for name, path in self.targets.items()}
|
||||
self.backup = self.root / "backup"
|
||||
self.env = dict(os.environ)
|
||||
if os.name == "nt":
|
||||
self.env["PATH"] = str(GIT_BIN) + os.pathsep + self.env["PATH"]
|
||||
source = (ROOT / "vps/deploy-heartbeat-transport-fix.ps1").read_text(encoding="utf-8")
|
||||
self.script = source.split("$RemoteScript = @'\n", 1)[1].split("\n'@", 1)[0]
|
||||
self.script = self.script.replace("backup_dir=/root/owrt-remote-backup-before-heartbeat-transport-v116",
|
||||
"backup_dir=" + shlex.quote(self.backup.as_posix()))
|
||||
self.script = self.script.replace("printf /usr/lib/owrt-remote/wan.sh", "printf %s " + shlex.quote(self.targets["wan.sh"].as_posix()))
|
||||
self.script = self.script.replace("printf /usr/sbin/owrt-remote", "printf %s " + shlex.quote(self.targets["agent"].as_posix()))
|
||||
|
||||
def deploy(self, action, bad_item=None, fail_verify=False, fail_signal=False, stopped=False):
|
||||
stage = self.root / "stage"
|
||||
stage.mkdir()
|
||||
for item, source in {"wan.sh": "files/usr/lib/owrt-remote/wan.sh", "agent": "files/usr/sbin/owrt-remote"}.items():
|
||||
text = (ROOT / source).read_text(encoding="utf-8")
|
||||
if bad_item == item:
|
||||
text = "#!/bin/sh\nif true; then\n"
|
||||
stage.joinpath(item).write_text(text, encoding="utf-8", newline="\n")
|
||||
script = self.script.replace("stage=/tmp/__UPLOAD_NAME__", "stage=" + shlex.quote(stage.as_posix()))
|
||||
script = script.replace("__ACTION__", action).replace("__UPLOAD_NAME__", "sandbox")
|
||||
if fail_verify:
|
||||
script = script.replace('cmp "$source_dir/$item" "$path"', "false")
|
||||
mocks = r'''
|
||||
|
||||
ubus() {
|
||||
printf '%s\n' "$*" >>"$TEST_ROOT/ubus-calls"
|
||||
if [ "$3" = signal ]; then
|
||||
[ "${TEST_SIGNAL_FAIL:-0}" = 0 ] || return 1
|
||||
printf 202 >"$TEST_ROOT/pid"
|
||||
fi
|
||||
printf '{}'
|
||||
}
|
||||
jsonfilter() { cat >/dev/null; cat "$TEST_ROOT/pid"; }
|
||||
sleep() { :; }
|
||||
'''
|
||||
self.root.joinpath("pid").write_text("" if stopped else "101")
|
||||
result = subprocess.run([SH], input=mocks + script, encoding="utf-8", capture_output=True,
|
||||
env={**self.env, "TEST_ROOT": self.root.as_posix(), "TEST_SIGNAL_FAIL": "1" if fail_signal else "0"}, timeout=30)
|
||||
self.assertFalse(stage.exists())
|
||||
self.assertFalse(list(self.root.glob("*.new-sandbox")))
|
||||
return result
|
||||
|
||||
def test_install_twice_then_rollback_preserves_first_backup(self):
|
||||
for attempt in range(2):
|
||||
result = self.deploy("Install")
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
self.assertIn("HEARTBEAT_TRANSPORT_ROUTER_Install_OK", result.stdout)
|
||||
for item, path in self.targets.items():
|
||||
self.assertNotEqual(path.read_bytes(), self.original[item])
|
||||
self.assertEqual(self.backup.joinpath(item).read_bytes(), self.original[item])
|
||||
result = self.deploy("Rollback")
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
for item, path in self.targets.items():
|
||||
self.assertEqual(path.read_bytes(), self.original[item])
|
||||
|
||||
def test_bad_candidate_and_missing_backup_leave_paired_files_unchanged(self):
|
||||
for item in ("agent", "wan.sh"):
|
||||
result = self.deploy("Install", bad_item=item)
|
||||
self.assertNotEqual(result.returncode, 0)
|
||||
self.assertFalse(self.backup.exists())
|
||||
for name, path in self.targets.items():
|
||||
self.assertEqual(path.read_bytes(), self.original[name])
|
||||
result = self.deploy("Rollback")
|
||||
self.assertNotEqual(result.returncode, 0)
|
||||
self.assertIn("No complete backup", result.stderr)
|
||||
for name, path in self.targets.items():
|
||||
self.assertEqual(path.read_bytes(), self.original[name])
|
||||
|
||||
def test_reloads_only_heartbeat_without_touching_xray(self):
|
||||
result = self.deploy("Install")
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
calls = self.root.joinpath("ubus-calls").read_text()
|
||||
self.assertIn('service signal {"name":"owrt-remote","instance":"heartbeat","signal":9}', calls)
|
||||
self.assertNotIn('"instance":"xray"', calls)
|
||||
self.assertIn('Heartbeat loop reloaded', result.stdout)
|
||||
|
||||
def test_stopped_loop_stays_stopped(self):
|
||||
result = self.deploy("Install", stopped=True)
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
self.assertNotIn('service signal', self.root.joinpath("ubus-calls").read_text())
|
||||
self.assertIn('Heartbeat loop is stopped', result.stdout)
|
||||
|
||||
def test_failed_loop_reload_restores_paired_files_and_reports_failure(self):
|
||||
result = self.deploy("Install", fail_signal=True)
|
||||
self.assertNotEqual(result.returncode, 0)
|
||||
self.assertIn('Failed during heartbeat-reload', result.stderr)
|
||||
self.assertNotIn('HEARTBEAT_TRANSPORT_ROUTER_Install_OK', result.stdout)
|
||||
for item, path in self.targets.items():
|
||||
self.assertEqual(path.read_bytes(), self.original[item])
|
||||
|
||||
def test_verify_failure_restores_paired_files(self):
|
||||
result = self.deploy("Install", fail_verify=True)
|
||||
self.assertNotEqual(result.returncode, 0)
|
||||
self.assertIn("Restoring the agent and WAN helper", result.stderr)
|
||||
for item, path in self.targets.items():
|
||||
self.assertEqual(path.read_bytes(), self.original[item])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
+11
-10
@@ -310,12 +310,12 @@ printf '%s|%s|%s' "$(uci_get hub_url '')" "$(uci_get public_url '')" "$(uci_get
|
||||
self.assertEqual(log.count("reason=https-downgrade"), 2, "repeated proposals must not flood the log")
|
||||
|
||||
def test_successful_fallback_heartbeat_does_not_replace_configured_hub_url(self):
|
||||
self.config(hub_url="https://hub.example", hub_token="test-token", vps_host="193.233.82.38")
|
||||
self.config(hub_url="https://hub.example", public_url="https://backup.example", hub_token="test-token", vps_host="193.233.82.38")
|
||||
result = self.run_shell('''
|
||||
heartbeat_json() { printf '{"id":"test-router"}'; }
|
||||
post_json() {
|
||||
case "$1" in
|
||||
http://193.233.82.38:8088/api/heartbeat) printf '{"ok":true}' ;;
|
||||
https://backup.example/api/heartbeat) printf '{"ok":true}' ;;
|
||||
*) return 1 ;;
|
||||
esac
|
||||
}
|
||||
@@ -428,11 +428,11 @@ printf '%s' "$(uci_get hub_url '')"
|
||||
self.assertIn("<pppoe-wan>", args)
|
||||
self.assertIn("<https://hub.example/api/heartbeat>", args)
|
||||
self.assertNotIn("<-k>", args)
|
||||
self.assertIn("<--max-time>\n<10>", args)
|
||||
self.assertIn("<--location>", args)
|
||||
self.assertIn("<--post301>", args)
|
||||
self.assertIn("<--post302>", args)
|
||||
self.assertIn("<--post303>", args)
|
||||
self.assertIn("<--max-time>", args)
|
||||
self.assertIn("<--resolve>", args)
|
||||
self.assertIn("<--data-binary>", args)
|
||||
self.assertNotIn("<--location-trusted>", args)
|
||||
self.assertNotIn("<--location>", args)
|
||||
|
||||
def test_busybox_empty_table_is_confirmed_before_wan_start(self):
|
||||
self.config(vps_host="193.233.82.38", hub_url="https://hub.example", wan_direct="1", vless_uuid="11111111-1111-4111-8111-111111111111")
|
||||
@@ -487,7 +487,7 @@ wan_prepare
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
self.assertEqual(self.directory.joinpath("xray-called").read_text().strip(), 'run -config ' + config.as_posix())
|
||||
|
||||
def test_plain_http_heartbeat_accepts_json_after_redirect_follow(self):
|
||||
def test_plain_http_heartbeat_uses_controlled_authenticated_posts(self):
|
||||
self.config(vps_host="193.233.82.38", vps_host_mode="manual")
|
||||
result = self.run_shell('''
|
||||
curl() {
|
||||
@@ -498,8 +498,9 @@ post_json http://hub.example/api/heartbeat test-token "$TEST_ROOT/payload"
|
||||
''')
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
args = (self.directory / "curl").read_text()
|
||||
self.assertIn("<--location>", args)
|
||||
self.assertIn("<--post301>", args)
|
||||
self.assertIn("<Authorization: Bearer test-token>", args)
|
||||
self.assertIn("<--data-binary>", args)
|
||||
self.assertNotIn("<--location>", args)
|
||||
|
||||
def test_literal_ip_fallback_is_not_rewritten_to_a_different_pin(self):
|
||||
self.config(vps_host="193.233.82.38", vps_host_mode="manual")
|
||||
|
||||
@@ -34,14 +34,18 @@ wan_prepare() { echo prepare >>"$TEST_ROOT/requests"; [ "${TEST_WAN_FAIL:-0}" !=
|
||||
xray_running() { [ "${TEST_XRAY_RUNNING:-0}" = 1 ]; }
|
||||
wan_post_json() { echo direct >>"$TEST_ROOT/requests"; fake_post "$1" "$3"; }
|
||||
curl() {
|
||||
local file arg next url
|
||||
next=0; file=''
|
||||
local file arg next url output
|
||||
next=''; file=''; output=''
|
||||
for arg in "$@"; do
|
||||
[ "$next" != 1 ] || { file="${arg#@}"; next=0; }
|
||||
[ "$arg" != --data-binary ] || next=1
|
||||
case "$next" in
|
||||
data) file="${arg#@}"; next=''; continue ;;
|
||||
output) output="$arg"; next=''; continue ;;
|
||||
esac
|
||||
case "$arg" in --data-binary) next=data ;; -o) next=output ;; esac
|
||||
url="$arg"
|
||||
done
|
||||
fake_post "$url" "$file"
|
||||
fake_post "$url" "$file" >"$output" || return $?
|
||||
printf '200 0.001 0.002 0.003 0.004 0.005\n'
|
||||
}
|
||||
fake_post() {
|
||||
echo "$1" >>"$TEST_ROOT/requests"
|
||||
|
||||
@@ -0,0 +1,219 @@
|
||||
"""WAN A-record parsing and bounded fallback; no router/network mutations.
|
||||
|
||||
Set OWRT_TEST_BUSYBOX to a BusyBox executable to run this exact suite in ash
|
||||
with its built-in awk/grep/date applets (busybox-w32 is supported).
|
||||
"""
|
||||
import os
|
||||
from pathlib import Path
|
||||
import shutil
|
||||
import subprocess
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
BUSYBOX = os.environ.get("OWRT_TEST_BUSYBOX")
|
||||
SH = shutil.which("sh")
|
||||
if not SH and os.name == "nt":
|
||||
candidate = Path(os.environ.get("ProgramFiles", "C:/Program Files")) / "Git/usr/bin/sh.exe"
|
||||
SH = str(candidate) if candidate.exists() else None
|
||||
|
||||
HEADER = "Server:\t\t8.8.8.8\nAddress:\t8.8.8.8:53\n\n"
|
||||
GOOD = HEADER + "Non-authoritative answer:\nName:\tbronsvn.developer.li\nAddress: 132.243.19.232\n"
|
||||
MOCKS = r'''
|
||||
safe_id() { printf '%s' "$1"; }
|
||||
wan_dns_server() { printf '%s' "${TEST_DNS:-8.8.8.8}"; }
|
||||
log() { printf '%s\n' "$*" >&2; }
|
||||
date() { printf 1800000000; }
|
||||
remote_clock_ms() { printf 1000; }
|
||||
nslookup() {
|
||||
printf '%s\n' "$*" >>"$TEST_ROOT/queries"
|
||||
cat "$TEST_ROOT/reply"
|
||||
cat "$TEST_ROOT/reply-stderr" >&2
|
||||
return "${TEST_RC:-0}"
|
||||
}
|
||||
# Resolution must not change network state or use another resolver.
|
||||
ip() { printf forbidden-ip >&2; exit 90; }
|
||||
nft() { printf forbidden-nft >&2; exit 91; }
|
||||
uci() { printf forbidden-uci >&2; exit 92; }
|
||||
'''
|
||||
|
||||
|
||||
@unittest.skipUnless(BUSYBOX or SH, "POSIX shell required")
|
||||
class WanDnsTests(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.temp = tempfile.TemporaryDirectory(prefix="wan-dns-")
|
||||
self.addCleanup(self.temp.cleanup)
|
||||
self.root = Path(self.temp.name)
|
||||
self.state = self.root / "state"
|
||||
self.state.mkdir()
|
||||
self.cache = self.state / "resolve-bronsvn.developer.li-8.8.8.8"
|
||||
self.source = (ROOT / "files/usr/lib/owrt-remote/wan.sh").read_text(encoding="utf-8")
|
||||
|
||||
def run_shell(self, reply=GOOD, rc=0, stderr="", commands="wan_resolve_host bronsvn.developer.li", **env):
|
||||
self.root.joinpath("reply").write_text(reply, encoding="utf-8", newline="\n")
|
||||
self.root.joinpath("reply-stderr").write_text(stderr, encoding="utf-8", newline="\n")
|
||||
script = self.root / "run.sh"
|
||||
script.write_text(self.source + '\nWAN_STATE="$TEST_ROOT/state"\n' + MOCKS + "\n" + commands + "\n",
|
||||
encoding="utf-8", newline="\n")
|
||||
args = [BUSYBOX, "ash"] if BUSYBOX else [SH]
|
||||
process_env = dict(os.environ)
|
||||
if not BUSYBOX and os.name == "nt":
|
||||
process_env["PATH"] = str(Path(SH).parent) + os.pathsep + process_env["PATH"]
|
||||
return subprocess.run(args + [script.as_posix()], capture_output=True, encoding="utf-8",
|
||||
env={**process_env, "TEST_ROOT": self.root.as_posix(), "TEST_RC": str(rc), **env}, timeout=15)
|
||||
|
||||
def save_cache(self, timestamp=1799999699, ip="132.243.19.231"):
|
||||
self.cache.write_text(f"{timestamp} {ip}\n", encoding="ascii", newline="\n")
|
||||
|
||||
def test_explicit_a_query_for_both_reported_resolvers_and_no_false_warning(self):
|
||||
for dns in ("8.8.8.8", "8.8.4.4"):
|
||||
with self.subTest(dns=dns):
|
||||
result = self.run_shell(TEST_DNS=dns)
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
self.assertEqual(result.stdout, "132.243.19.232")
|
||||
self.assertEqual(result.stderr, "")
|
||||
self.assertEqual(self.root.joinpath("queries").read_text().splitlines(),
|
||||
[f"-type=A -timeout=3 -retry=1 bronsvn.developer.li {dns}" for dns in ("8.8.8.8", "8.8.4.4")])
|
||||
|
||||
def test_busybox_and_numbered_address_formats(self):
|
||||
for address in ("Address: 132.243.19.232", "Address 1: 132.243.19.232", "Address 1: 132.243.19.232 bronsvn.developer.li"):
|
||||
with self.subTest(address=address):
|
||||
self.cache.unlink(missing_ok=True)
|
||||
result = self.run_shell(HEADER + "Name: bronsvn.developer.li\n" + address + "\n")
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
self.assertEqual(result.stdout, "132.243.19.232")
|
||||
|
||||
def test_cname_chain_case_and_trailing_dot(self):
|
||||
reply = HEADER + "BrOnSvN.Developer.Li. canonical name = edge.example.\nedge.example canonical name = origin.example.\nName: origin.example\nAddress: 132.243.19.232\n"
|
||||
result = self.run_shell(reply)
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
self.assertEqual(result.stdout, "132.243.19.232")
|
||||
|
||||
def test_host_containing_diagnostic_words_is_not_an_error(self):
|
||||
host = "timeout-servfail-refused.example"
|
||||
result = self.run_shell(GOOD.replace("bronsvn.developer.li", host),
|
||||
commands="wan_resolve_host " + host)
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
self.assertEqual(result.stdout, "132.243.19.232")
|
||||
self.assertEqual(result.stderr, "")
|
||||
|
||||
def test_unrelated_name_and_unscoped_address_are_not_answers(self):
|
||||
for reply in (HEADER + "Address: 132.243.19.232\n", HEADER + "Name: other.example\nAddress: 132.243.19.232\n"):
|
||||
with self.subTest(reply=reply):
|
||||
result = self.run_shell(reply)
|
||||
self.assertNotEqual(result.returncode, 0)
|
||||
self.assertEqual(result.stdout, "")
|
||||
self.assertFalse(self.cache.exists())
|
||||
|
||||
def test_no_a_record_is_distinct_from_timeout_and_parse_error(self):
|
||||
replies = ((HEADER, 0),
|
||||
(HEADER + "Non-authoritative answer:\n", 0),
|
||||
(HEADER + "*** Can't find bronsvn.developer.li: No answer\n", 0),
|
||||
(HEADER + "** server can't find bronsvn.developer.li: NXDOMAIN\n", 1),
|
||||
(HEADER + "Name: bronsvn.developer.li\nAddress: 2001:db8::1\n", 0))
|
||||
for reply, rc in replies:
|
||||
with self.subTest(reply=reply):
|
||||
result = self.run_shell(reply, rc)
|
||||
self.assertNotEqual(result.returncode, 0)
|
||||
self.assertEqual(result.stdout, "")
|
||||
self.assertIn("reason=no_a_record", result.stderr)
|
||||
|
||||
def test_dns_timeout_stderr_and_original_return_code_are_preserved(self):
|
||||
result = self.run_shell("", 1, ";; connection timed out; no servers could be reached\n")
|
||||
self.assertNotEqual(result.returncode, 0)
|
||||
self.assertIn("reason=timeout rc=1", result.stderr)
|
||||
|
||||
def test_malformed_empty_and_invalid_ipv4_are_parse_errors(self):
|
||||
for reply in ("", "unexpected output\n", HEADER + "*** Can't find bronsvn.developer.li: Parse error\n",
|
||||
*(HEADER + f"Name: bronsvn.developer.li\nAddress: {ip}\n" for ip in
|
||||
("999.243.19.232", "132.243.19", "132.243.19.232.evil", "0132.243.19.232", "", "-1.2.3.4"))):
|
||||
with self.subTest(reply=reply):
|
||||
result = self.run_shell(reply)
|
||||
self.assertNotEqual(result.returncode, 0)
|
||||
self.assertEqual(result.stdout, "")
|
||||
self.assertIn("reason=parse_error", result.stderr)
|
||||
|
||||
def test_nonzero_nslookup_is_not_success_even_with_valid_looking_answer(self):
|
||||
result = self.run_shell(GOOD, 1)
|
||||
self.assertNotEqual(result.returncode, 0)
|
||||
self.assertEqual(result.stdout, "")
|
||||
self.assertIn("reason=resolver_error", result.stderr)
|
||||
self.assertFalse(self.cache.exists())
|
||||
|
||||
def test_servfail_is_resolver_error(self):
|
||||
result = self.run_shell(HEADER + "** server can't find bronsvn.developer.li: SERVFAIL\n", 1)
|
||||
self.assertNotEqual(result.returncode, 0)
|
||||
self.assertIn("reason=resolver_error", result.stderr)
|
||||
|
||||
def test_fake_ip_is_rejected_and_later_valid_a_is_used(self):
|
||||
for ip in ("198.18.0.1", "198.19.255.255"):
|
||||
result = self.run_shell(GOOD.replace("132.243.19.232", ip))
|
||||
self.assertNotEqual(result.returncode, 0)
|
||||
self.assertIn("reason=rejected_address", result.stderr)
|
||||
result = self.run_shell(GOOD.replace("132.243.19.232", "198.18.0.1") + "Address: 132.243.19.232\n")
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
self.assertEqual(result.stdout, "132.243.19.232")
|
||||
self.assertEqual(result.stderr, "")
|
||||
|
||||
def test_success_refreshes_stale_cache_without_warning(self):
|
||||
self.save_cache()
|
||||
result = self.run_shell()
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
self.assertEqual(result.stderr, "")
|
||||
self.assertEqual(self.cache.read_text(), "1800000000 132.243.19.232\n")
|
||||
|
||||
def test_recent_valid_cache_skips_lookup(self):
|
||||
self.save_cache(1799999701)
|
||||
result = self.run_shell("", 1)
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
self.assertEqual(result.stdout, "132.243.19.231")
|
||||
self.assertFalse(self.root.joinpath("queries").exists())
|
||||
|
||||
def test_last_success_fallback_preserves_age_and_logs_exact_failure(self):
|
||||
for reply, rc, reason in ((";; connection timed out\n", 1, "timeout"),
|
||||
(HEADER, 0, "no_a_record"), ("broken reply", 0, "parse_error")):
|
||||
with self.subTest(reason=reason):
|
||||
self.save_cache(1799996401)
|
||||
before = self.cache.read_bytes()
|
||||
result = self.run_shell(reply, rc)
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
self.assertEqual(result.stdout, "132.243.19.231")
|
||||
self.assertIn("WAN DNS unavailable", result.stderr)
|
||||
self.assertIn("reason=" + reason, result.stderr)
|
||||
self.assertEqual(self.cache.read_bytes(), before)
|
||||
|
||||
def test_expired_corrupt_future_and_ipv6_cache_are_never_fallback(self):
|
||||
for timestamp, ip in ((1799996400, "132.243.19.231"), (1800000001, "132.243.19.231"),
|
||||
("invalid", "132.243.19.231"), ("08", "132.243.19.231"),
|
||||
("999999999999999999999999", "132.243.19.231"),
|
||||
(1799999999, "2001:db8::1"), (1799999999, "999.1.1.1"),
|
||||
(1799999999, "198.18.0.1"), (1799999999, "198.19.255.255")):
|
||||
with self.subTest(timestamp=timestamp, ip=ip):
|
||||
self.save_cache(timestamp, ip)
|
||||
result = self.run_shell(HEADER, 0)
|
||||
self.assertNotEqual(result.returncode, 0)
|
||||
self.assertEqual(result.stdout, "")
|
||||
self.assertIn("reason=no_a_record", result.stderr)
|
||||
|
||||
def test_cache_metrics_still_distinguish_actual_lookup(self):
|
||||
result = self.run_shell(commands=r'''
|
||||
OWRT_REMOTE_DNS_METRICS="$TEST_ROOT/metrics"
|
||||
wan_resolve_host bronsvn.developer.li || exit
|
||||
cat "$TEST_ROOT/metrics"
|
||||
wan_resolve_host bronsvn.developer.li || exit
|
||||
cat "$TEST_ROOT/metrics"
|
||||
''')
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
self.assertIn("0 lookup", result.stdout)
|
||||
self.assertIn("0 cache", result.stdout)
|
||||
|
||||
def test_shell_syntax(self):
|
||||
script = self.root / "wan.sh"
|
||||
script.write_text(self.source, encoding="utf-8", newline="\n")
|
||||
args = [BUSYBOX, "ash"] if BUSYBOX else [SH]
|
||||
result = subprocess.run(args + ["-n", script.as_posix()], capture_output=True, timeout=15)
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,129 @@
|
||||
"""Install/rollback DNS functions while preserving every other WAN function."""
|
||||
import os
|
||||
from pathlib import Path
|
||||
import shlex
|
||||
import subprocess
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
from test_wan_dns import ROOT, SH, BUSYBOX
|
||||
|
||||
# Stable legacy layout: keep testing an installation without wan_dns_metric
|
||||
# after this fix becomes HEAD, and when tests run from a source archive.
|
||||
LEGACY_DNS = '''wan_resolve_host() {
|
||||
local host dns answer
|
||||
host="$1"; dns="$(wan_dns_server)" || return 1
|
||||
answer="$(nslookup -timeout=3 -retry=1 "$host" "$dns" 2>/dev/null)"
|
||||
printf '%s' "$answer"
|
||||
}
|
||||
|
||||
'''
|
||||
|
||||
|
||||
@unittest.skipUnless(BUSYBOX or SH, "POSIX shell required")
|
||||
class WanDnsDeploymentTests(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.temp = tempfile.TemporaryDirectory(prefix="wan-dns-deploy-")
|
||||
self.addCleanup(self.temp.cleanup)
|
||||
self.root = Path(self.temp.name)
|
||||
self.target = self.root / "wan.sh"
|
||||
self.backup = self.root / "backup"
|
||||
self.current = (ROOT / "files/usr/lib/owrt-remote/wan.sh").read_text(encoding="utf-8")
|
||||
self.published = (self.current.split("wan_dns_metric() {", 1)[0] + LEGACY_DNS
|
||||
+ "wan_endpoint_ip() {" + self.current.split("wan_endpoint_ip() {", 1)[1])
|
||||
self.target.write_text(self.published, encoding="utf-8", newline="\n")
|
||||
source = (ROOT / "vps/deploy-wan-dns-fix.ps1").read_text(encoding="utf-8")
|
||||
self.script = source.split("$RemoteScript = @'\n", 1)[1].split("\n'@", 1)[0]
|
||||
self.script = self.script.replace("target=/usr/lib/owrt-remote/wan.sh", "target=" + shlex.quote(self.target.as_posix()))
|
||||
self.script = self.script.replace("backup_dir=/root/owrt-remote-backup-before-wan-dns-v116",
|
||||
"backup_dir=" + shlex.quote(self.backup.as_posix()))
|
||||
|
||||
def deploy(self, action="Install", bad=False, fail_verify=False, fail_signal=False):
|
||||
stage = self.root / "stage"
|
||||
stage.mkdir()
|
||||
block = "wan_dns_metric() {" + self.current.split("wan_dns_metric() {", 1)[1].split("wan_endpoint_ip() {", 1)[0]
|
||||
if bad:
|
||||
block = "if true; then\n"
|
||||
stage.joinpath("dns.sh").write_text(block, encoding="utf-8", newline="\n")
|
||||
script = self.script.replace("stage=/tmp/__UPLOAD_NAME__", "stage=" + shlex.quote(stage.as_posix()))
|
||||
script = script.replace("__UPLOAD_NAME__", "sandbox").replace("__ACTION__", action)
|
||||
if fail_verify:
|
||||
script = script.replace('cmp "$source_file" "$target"', "false")
|
||||
mocks = r'''
|
||||
ubus() {
|
||||
printf '%s\n' "$*" >>"$TEST_ROOT/ubus-calls"
|
||||
if [ "$3" = signal ]; then
|
||||
[ "${TEST_SIGNAL_FAIL:-0}" = 0 ] || return 1
|
||||
printf 202 >"$TEST_ROOT/pid"
|
||||
fi
|
||||
printf '{}'
|
||||
}
|
||||
jsonfilter() { cat >/dev/null; cat "$TEST_ROOT/pid"; }
|
||||
sleep() { :; }
|
||||
'''
|
||||
self.root.joinpath("pid").write_text("101")
|
||||
run = self.root / "run.sh"
|
||||
run.write_text(mocks + script, encoding="utf-8", newline="\n")
|
||||
args = [BUSYBOX, "ash"] if BUSYBOX else [SH]
|
||||
env = dict(os.environ)
|
||||
if not BUSYBOX and os.name == "nt":
|
||||
env["PATH"] = str(Path(SH).parent) + os.pathsep + env["PATH"]
|
||||
result = subprocess.run(args + [run.as_posix()], capture_output=True, encoding="utf-8", timeout=20,
|
||||
env={**env, "TEST_ROOT": self.root.as_posix(), "TEST_SIGNAL_FAIL": "1" if fail_signal else "0"})
|
||||
self.assertFalse(stage.exists())
|
||||
self.assertFalse(list(self.root.glob("*.new-sandbox")))
|
||||
return result
|
||||
|
||||
def test_published_and_local_transport_versions_keep_all_non_dns_code(self):
|
||||
for before in (self.published, self.current):
|
||||
with self.subTest(version="local" if before == self.current else "published"):
|
||||
self.target.write_text(before, encoding="utf-8", newline="\n")
|
||||
result = self.deploy()
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
after = self.target.read_text(encoding="utf-8")
|
||||
prefix = before.split("wan_dns_metric() {" if "wan_dns_metric() {" in before else "wan_resolve_host() {", 1)[0]
|
||||
suffix = "wan_endpoint_ip() {" + before.split("wan_endpoint_ip() {", 1)[1]
|
||||
self.assertTrue(after.startswith(prefix))
|
||||
self.assertTrue(after.endswith(suffix))
|
||||
self.assertIn("nslookup -type=A -timeout=3 -retry=1", after)
|
||||
self.assertIn("WAN_DNS_ROUTER_Install_OK", result.stdout)
|
||||
self.assertNotIn('"instance":"xray"', self.root.joinpath("ubus-calls").read_text())
|
||||
|
||||
def test_repeated_install_then_rollback_preserves_first_backup(self):
|
||||
previous = self.target.read_bytes()
|
||||
for attempt in range(2):
|
||||
result = self.deploy()
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
self.assertEqual(self.backup.joinpath("wan.sh").read_bytes(), previous)
|
||||
result = self.deploy("Rollback")
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
self.assertEqual(self.target.read_bytes(), previous)
|
||||
|
||||
def test_bad_candidate_and_missing_backup_leave_target_unchanged(self):
|
||||
before = self.target.read_bytes()
|
||||
for action, bad in (("Install", True), ("Rollback", False)):
|
||||
result = self.deploy(action, bad)
|
||||
self.assertNotEqual(result.returncode, 0)
|
||||
self.assertEqual(self.target.read_bytes(), before)
|
||||
self.assertFalse(self.backup.exists())
|
||||
|
||||
def test_unknown_target_structure_is_rejected_before_changes(self):
|
||||
self.target.write_text("#!/bin/sh\necho unknown\n", encoding="utf-8", newline="\n")
|
||||
before = self.target.read_bytes()
|
||||
result = self.deploy()
|
||||
self.assertNotEqual(result.returncode, 0)
|
||||
self.assertEqual(self.target.read_bytes(), before)
|
||||
self.assertFalse(self.backup.exists())
|
||||
|
||||
def test_verification_or_reload_failure_restores_previous_wan_helper(self):
|
||||
before = self.target.read_bytes()
|
||||
for kwargs in ({"fail_verify": True}, {"fail_signal": True}):
|
||||
result = self.deploy(**kwargs)
|
||||
self.assertNotEqual(result.returncode, 0)
|
||||
self.assertIn("Restoring WAN helper", result.stderr)
|
||||
self.assertEqual(self.target.read_bytes(), before)
|
||||
self.assertNotIn("WAN_DNS_ROUTER_Install_OK", result.stdout)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -84,7 +84,8 @@ render_page() { printf 'KIND=%s\nTITLE=%s\nBODY=%s\nDRAFT=%s\n' "$RESULT_KIND" "
|
||||
env={**self.env, "REQUEST_METHOD": "POST", "CONTENT_TYPE": "application/x-www-form-urlencoded",
|
||||
"CONTENT_LENGTH": str(len(body))}, timeout=20)
|
||||
self.assertEqual(result.returncode, 0, result.stderr.decode("utf-8", errors="replace"))
|
||||
self.assertFalse(list(self.directory.glob("owrt-remote-*")), "CGI temporary files must be removed")
|
||||
leftovers = [path for path in self.directory.glob("owrt-remote-*") if path.name != "owrt-remote-heartbeat-last"]
|
||||
self.assertFalse(leftovers, "CGI temporary files must be removed")
|
||||
return result.stdout.decode("utf-8")
|
||||
|
||||
def test_mobile_smart_quotes_reproduce_uci_255_and_are_repaired(self):
|
||||
@@ -219,7 +220,7 @@ logger() { :; }
|
||||
response = self.post(script.replace("\n", "\r\n"))
|
||||
self.assertIn("KIND=bad", response)
|
||||
self.assertIn("Ошибка отправки Heartbeat после применения настроек", response)
|
||||
self.assertIn("Failed to allocate uclient context", response)
|
||||
self.assertIn("reason=http_client_context_failed", response)
|
||||
self.assertNotIn("каждая команда должна быть на отдельной строке", response)
|
||||
self.assertTrue(self.directory.joinpath("restarted").exists())
|
||||
|
||||
|
||||
@@ -0,0 +1,152 @@
|
||||
param(
|
||||
[ValidateNotNullOrEmpty()][string]$Router = 'root@192.168.2.1',
|
||||
[ValidateSet('Install', 'Rollback')][string]$Action = 'Install',
|
||||
[switch]$PrepareOnly
|
||||
)
|
||||
|
||||
$ErrorActionPreference = 'Stop'
|
||||
$RepoRoot = Split-Path -Parent $PSScriptRoot
|
||||
$UploadName = 'owrt-heartbeat-transport-' + [guid]::NewGuid().ToString('N')
|
||||
$StageRoot = Join-Path ([System.IO.Path]::GetTempPath()) $UploadName
|
||||
$Utf8 = [System.Text.UTF8Encoding]::new($false)
|
||||
$Payloads = @{
|
||||
'wan.sh' = 'files\usr\lib\owrt-remote\wan.sh'
|
||||
'agent' = 'files\usr\sbin\owrt-remote'
|
||||
}
|
||||
$RemoteScript = @'
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
stage=/tmp/__UPLOAD_NAME__
|
||||
backup_dir=/root/owrt-remote-backup-before-heartbeat-transport-v116
|
||||
changed=0
|
||||
phase=preflight
|
||||
item_path() {
|
||||
case "$1" in
|
||||
wan.sh) printf /usr/lib/owrt-remote/wan.sh ;;
|
||||
agent) printf /usr/sbin/owrt-remote ;;
|
||||
esac
|
||||
}
|
||||
complete_backup() {
|
||||
[ -f "$1/complete" ] && [ -s "$1/wan.sh" ] && [ -s "$1/agent" ]
|
||||
}
|
||||
restore_files() {
|
||||
local dir item path
|
||||
dir=$1
|
||||
complete_backup "$dir" || return 1
|
||||
for item in agent wan.sh; do
|
||||
path=$(item_path "$item")
|
||||
cp -p "$dir/$item" "$path.new-__UPLOAD_NAME__" || return 1
|
||||
mv -f "$path.new-__UPLOAD_NAME__" "$path" || return 1
|
||||
done
|
||||
}
|
||||
heartbeat_pid() {
|
||||
local state
|
||||
state=$(ubus call service list '{"name":"owrt-remote"}') || return 1
|
||||
printf '%s' "$state" | jsonfilter -e '@["owrt-remote"].instances.heartbeat.pid' 2>/dev/null || true
|
||||
}
|
||||
refresh_heartbeat() {
|
||||
local old_pid new_pid attempt
|
||||
old_pid=$(heartbeat_pid) || return 1
|
||||
case "$old_pid" in ''|0) echo 'Heartbeat loop is stopped; files will be used at its next start.'; return 0 ;; *[!0-9]*) return 1 ;; esac
|
||||
# Signal only the supervised heartbeat shell; procd respawns it from the
|
||||
# new agent. The Xray instance and reverse tunnel stay running.
|
||||
ubus call service signal '{"name":"owrt-remote","instance":"heartbeat","signal":9}' >/dev/null || return 1
|
||||
attempt=0
|
||||
while [ "$attempt" -lt 20 ]; do
|
||||
sleep 1
|
||||
new_pid=$(heartbeat_pid) || return 1
|
||||
case "$new_pid" in ''|0|*[!0-9]*) ;; *)
|
||||
[ "$new_pid" = "$old_pid" ] || { echo 'Heartbeat loop reloaded; Xray was not restarted.'; return 0; } ;;
|
||||
esac
|
||||
attempt=$((attempt+1))
|
||||
done
|
||||
echo 'Heartbeat loop did not respawn. Code will be restored.' >&2
|
||||
return 1
|
||||
}
|
||||
cleanup() {
|
||||
code=$?
|
||||
trap - EXIT
|
||||
if [ "$code" -ne 0 ]; then
|
||||
printf 'Failed during %s (rc=%s).\n' "$phase" "$code" >&2
|
||||
if [ "$changed" = 1 ]; then
|
||||
echo 'Restoring the agent and WAN helper from this attempt.' >&2
|
||||
restore_files "$stage/previous" && refresh_heartbeat || echo 'Restore failed; retained backup is available.' >&2
|
||||
fi
|
||||
fi
|
||||
for item in agent wan.sh; do path=$(item_path "$item"); rm -f "$path.new-__UPLOAD_NAME__"; done
|
||||
rm -rf "$stage"
|
||||
exit "$code"
|
||||
}
|
||||
trap cleanup EXIT
|
||||
for item in agent wan.sh; do
|
||||
path=$(item_path "$item")
|
||||
test -s "$path"
|
||||
done
|
||||
heartbeat_pid >/dev/null
|
||||
if [ '__ACTION__' = Install ]; then
|
||||
for item in agent wan.sh; do test -s "$stage/$item"; sh -n "$stage/$item"; done
|
||||
grep -F -q 'remote_curl_post()' "$stage/agent"
|
||||
grep -F -q 'reason=https_required' "$stage/agent"
|
||||
grep -F -q 'remote_curl_post' "$stage/wan.sh"
|
||||
if [ ! -e "$backup_dir" ]; then
|
||||
mkdir -p "$stage/retained-backup"
|
||||
chmod 700 "$stage/retained-backup"
|
||||
for item in agent wan.sh; do path=$(item_path "$item"); cp -p "$path" "$stage/retained-backup/$item"; done
|
||||
touch "$stage/retained-backup/complete"
|
||||
mv "$stage/retained-backup" "$backup_dir"
|
||||
fi
|
||||
complete_backup "$backup_dir" || { echo "Incomplete backup: $backup_dir. Nothing changed." >&2; exit 1; }
|
||||
source_dir=$stage
|
||||
else
|
||||
complete_backup "$backup_dir" || { echo "No complete backup: $backup_dir. Nothing changed." >&2; exit 1; }
|
||||
for item in agent wan.sh; do sh -n "$backup_dir/$item"; done
|
||||
source_dir=$backup_dir
|
||||
fi
|
||||
printf 'Backup: %s\n' "$backup_dir"
|
||||
mkdir -p "$stage/previous"
|
||||
for item in agent wan.sh; do path=$(item_path "$item"); cp -p "$path" "$stage/previous/$item"; done
|
||||
touch "$stage/previous/complete"
|
||||
phase=install
|
||||
changed=1
|
||||
for item in agent wan.sh; do
|
||||
path=$(item_path "$item")
|
||||
cp "$source_dir/$item" "$path.new-__UPLOAD_NAME__"
|
||||
chmod 755 "$path.new-__UPLOAD_NAME__"
|
||||
mv -f "$path.new-__UPLOAD_NAME__" "$path"
|
||||
done
|
||||
phase=verify
|
||||
for item in agent wan.sh; do
|
||||
path=$(item_path "$item")
|
||||
sh -n "$path"
|
||||
cmp "$source_dir/$item" "$path"
|
||||
done
|
||||
phase=heartbeat-reload
|
||||
refresh_heartbeat
|
||||
# Configuration, Xray and routing are not regenerated by this deployment.
|
||||
printf '\nHEARTBEAT_TRANSPORT_ROUTER_%s_OK\n' '__ACTION__'
|
||||
|
||||
'@
|
||||
$RemoteScript = $RemoteScript.Replace('__UPLOAD_NAME__', $UploadName).Replace('__ACTION__', $Action)
|
||||
try {
|
||||
[System.IO.Directory]::CreateDirectory($StageRoot) | Out-Null
|
||||
[System.IO.File]::WriteAllText((Join-Path $StageRoot 'run.sh'), $RemoteScript.Replace("`r`n", "`n") + "`n", $Utf8)
|
||||
if ($Action -eq 'Install') {
|
||||
foreach ($Item in $Payloads.GetEnumerator()) {
|
||||
$Content = [System.IO.File]::ReadAllText((Join-Path $RepoRoot $Item.Value)).Replace("`r`n", "`n")
|
||||
[System.IO.File]::WriteAllText((Join-Path $StageRoot $Item.Key), $Content, $Utf8)
|
||||
}
|
||||
}
|
||||
if ($PrepareOnly) { Write-Host "Prepared only: $StageRoot"; return }
|
||||
& scp -O -r -- $StageRoot "${Router}:/tmp/"
|
||||
if ($LASTEXITCODE -ne 0) { throw 'Upload failed. The installation has not started.' }
|
||||
& ssh -T -o ConnectTimeout=10 $Router "sh /tmp/$UploadName/run.sh"
|
||||
if ($LASTEXITCODE -ne 0) { throw "$Action failed. See the output above; success was not confirmed." }
|
||||
Write-Host "Heartbeat transport fix $Action finished successfully."
|
||||
} finally {
|
||||
if (-not $PrepareOnly) {
|
||||
$Resolved = [System.IO.Path]::GetFullPath($StageRoot)
|
||||
$Expected = [System.IO.Path]::GetFullPath((Join-Path ([System.IO.Path]::GetTempPath()) $UploadName))
|
||||
if ($Resolved -ne $Expected -or (Split-Path -Leaf $Resolved) -ne $UploadName) { throw 'Unsafe staging cleanup path.' }
|
||||
if (Test-Path -LiteralPath $Resolved) { Remove-Item -LiteralPath $Resolved -Recurse -Force }
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,128 @@
|
||||
param(
|
||||
[ValidateNotNullOrEmpty()][string]$Router = 'root@192.168.2.1',
|
||||
[ValidateSet('Install', 'Rollback')][string]$Action = 'Install',
|
||||
[switch]$PrepareOnly
|
||||
)
|
||||
|
||||
$ErrorActionPreference = 'Stop'
|
||||
$RepoRoot = Split-Path -Parent $PSScriptRoot
|
||||
$UploadName = 'owrt-wan-dns-' + [guid]::NewGuid().ToString('N')
|
||||
$StageRoot = Join-Path ([System.IO.Path]::GetTempPath()) $UploadName
|
||||
$Utf8 = [System.Text.UTF8Encoding]::new($false)
|
||||
$RemoteScript = @'
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
stage=/tmp/__UPLOAD_NAME__
|
||||
target=/usr/lib/owrt-remote/wan.sh
|
||||
backup_dir=/root/owrt-remote-backup-before-wan-dns-v116
|
||||
changed=0
|
||||
phase=preflight
|
||||
heartbeat_pid() {
|
||||
local state
|
||||
state=$(ubus call service list '{"name":"owrt-remote"}') || return 1
|
||||
printf '%s' "$state" | jsonfilter -e '@["owrt-remote"].instances.heartbeat.pid' 2>/dev/null || true
|
||||
}
|
||||
refresh_heartbeat() {
|
||||
local old_pid new_pid attempt
|
||||
old_pid=$(heartbeat_pid) || return 1
|
||||
case "$old_pid" in ''|0) echo 'Heartbeat is stopped; the fix will load at its next start.'; return 0 ;; *[!0-9]*) return 1 ;; esac
|
||||
ubus call service signal '{"name":"owrt-remote","instance":"heartbeat","signal":9}' >/dev/null || return 1
|
||||
attempt=0
|
||||
while [ "$attempt" -lt 20 ]; do
|
||||
sleep 1
|
||||
new_pid=$(heartbeat_pid) || return 1
|
||||
case "$new_pid" in ''|0|*[!0-9]*) ;; *)
|
||||
[ "$new_pid" = "$old_pid" ] || { echo 'Heartbeat reloaded; Xray was not restarted.'; return 0; } ;;
|
||||
esac
|
||||
attempt=$((attempt+1))
|
||||
done
|
||||
echo 'Heartbeat did not respawn.' >&2
|
||||
return 1
|
||||
}
|
||||
restore_file() {
|
||||
cp -p "$1" "$target.new-__UPLOAD_NAME__" && mv -f "$target.new-__UPLOAD_NAME__" "$target"
|
||||
}
|
||||
cleanup() {
|
||||
code=$?
|
||||
trap - EXIT
|
||||
if [ "$code" -ne 0 ]; then
|
||||
printf 'Failed during %s (rc=%s).\n' "$phase" "$code" >&2
|
||||
if [ "$changed" = 1 ]; then
|
||||
echo 'Restoring WAN helper from this attempt.' >&2
|
||||
restore_file "$stage/previous" && refresh_heartbeat || echo 'Restore failed; retained backup is available.' >&2
|
||||
fi
|
||||
fi
|
||||
rm -f "$target.new-__UPLOAD_NAME__"
|
||||
rm -rf "$stage"
|
||||
exit "$code"
|
||||
}
|
||||
trap cleanup EXIT
|
||||
test -s "$target"
|
||||
heartbeat_pid >/dev/null
|
||||
if [ '__ACTION__' = Install ]; then
|
||||
test -s "$stage/dns.sh"
|
||||
sh -n "$stage/dns.sh"
|
||||
grep -F -q 'nslookup -type=A -timeout=3 -retry=1' "$stage/dns.sh"
|
||||
# Patch DNS functions only, preserving the router's other WAN code and
|
||||
# compatibility with both the published and locally updated agent.
|
||||
awk -v bundle="$stage/dns.sh" '
|
||||
/^(wan_dns_metric|wan_resolve_host)\(\) \{$/ && !seen {
|
||||
while ((getline line < bundle)>0) print line
|
||||
close(bundle); seen=1; skip=1
|
||||
}
|
||||
/^wan_endpoint_ip\(\) \{$/ && skip { skip=0; finished=1 }
|
||||
!skip { print }
|
||||
END { if(!seen || !finished) exit 1 }
|
||||
' "$target" >"$stage/candidate"
|
||||
sh -n "$stage/candidate"
|
||||
if [ ! -e "$backup_dir" ]; then
|
||||
mkdir "$stage/backup"
|
||||
chmod 700 "$stage/backup"
|
||||
cp -p "$target" "$stage/backup/wan.sh"
|
||||
mv "$stage/backup" "$backup_dir"
|
||||
fi
|
||||
test -s "$backup_dir/wan.sh"
|
||||
source_file="$stage/candidate"
|
||||
else
|
||||
[ -s "$backup_dir/wan.sh" ] || { echo "No backup: $backup_dir. Nothing changed." >&2; exit 1; }
|
||||
sh -n "$backup_dir/wan.sh"
|
||||
source_file="$backup_dir/wan.sh"
|
||||
fi
|
||||
printf 'Backup: %s/wan.sh\n' "$backup_dir"
|
||||
cp -p "$target" "$stage/previous"
|
||||
phase=install
|
||||
changed=1
|
||||
cp -p "$target" "$target.new-__UPLOAD_NAME__"
|
||||
cat "$source_file" >"$target.new-__UPLOAD_NAME__"
|
||||
mv -f "$target.new-__UPLOAD_NAME__" "$target"
|
||||
phase=verify
|
||||
sh -n "$target"
|
||||
cmp "$source_file" "$target"
|
||||
phase=heartbeat-reload
|
||||
refresh_heartbeat
|
||||
printf '\nWAN_DNS_ROUTER_%s_OK\n' '__ACTION__'
|
||||
'@
|
||||
$RemoteScript = $RemoteScript.Replace('__UPLOAD_NAME__', $UploadName).Replace('__ACTION__', $Action)
|
||||
try {
|
||||
[System.IO.Directory]::CreateDirectory($StageRoot) | Out-Null
|
||||
[System.IO.File]::WriteAllText((Join-Path $StageRoot 'run.sh'), $RemoteScript.Replace("`r`n", "`n") + "`n", $Utf8)
|
||||
if ($Action -eq 'Install') {
|
||||
$Source = [System.IO.File]::ReadAllText((Join-Path $RepoRoot 'files\usr\lib\owrt-remote\wan.sh')).Replace("`r`n", "`n")
|
||||
$Block = [regex]::Match($Source, '(?ms)^wan_dns_metric\(\) \{.*?(?=^wan_endpoint_ip\(\) \{)')
|
||||
if (-not $Block.Success) { throw 'Local WAN DNS functions not found.' }
|
||||
[System.IO.File]::WriteAllText((Join-Path $StageRoot 'dns.sh'), $Block.Value, $Utf8)
|
||||
}
|
||||
if ($PrepareOnly) { Write-Host "Prepared only: $StageRoot"; return }
|
||||
& scp -O -r -- $StageRoot "${Router}:/tmp/"
|
||||
if ($LASTEXITCODE -ne 0) { throw 'Upload failed. The installation has not started.' }
|
||||
& ssh -T -o ConnectTimeout=10 $Router "sh /tmp/$UploadName/run.sh"
|
||||
if ($LASTEXITCODE -ne 0) { throw "$Action failed. See the output above; success was not confirmed." }
|
||||
Write-Host "WAN DNS fix $Action finished successfully."
|
||||
} finally {
|
||||
if (-not $PrepareOnly) {
|
||||
$Resolved = [System.IO.Path]::GetFullPath($StageRoot)
|
||||
$Expected = [System.IO.Path]::GetFullPath((Join-Path ([System.IO.Path]::GetTempPath()) $UploadName))
|
||||
if ($Resolved -ne $Expected -or (Split-Path -Leaf $Resolved) -ne $UploadName) { throw 'Unsafe staging cleanup path.' }
|
||||
if (Test-Path -LiteralPath $Resolved) { Remove-Item -LiteralPath $Resolved -Recurse -Force }
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user