Files
universal-web-api/app/utils/site_url.py
T
2026-11-02 22:54:14 +08:00

257 lines
6.8 KiB
Python

"""
site_url.py - URL helpers for identifying real remote sites and route domains.
"""
from __future__ import annotations
import ipaddress
import hashlib
from typing import Optional, List
from urllib.parse import urlparse, urlunparse
from app.utils.site_rules import build_route_alias_groups, load_site_rules
_LOCAL_HOSTS = {"localhost", "127.0.0.1", "::1", "0.0.0.0"}
_LOCAL_SUFFIXES = (
".local",
".lan",
".internal",
".localhost",
".test",
".example",
".invalid",
".home.arpa",
)
def extract_remote_site_domain(url: str) -> Optional[str]:
"""Return the hostname for a real remote website, otherwise None."""
raw = str(url or "").strip()
if not raw:
return None
try:
parsed = urlparse(raw)
except Exception:
return None
if parsed.scheme not in {"http", "https"}:
return None
hostname = (parsed.hostname or "").strip().lower().rstrip(".")
if not hostname:
return None
if hostname in _LOCAL_HOSTS or hostname.endswith(_LOCAL_SUFFIXES):
return None
try:
ip = ipaddress.ip_address(hostname)
if (
ip.is_loopback
or ip.is_private
or ip.is_link_local
or ip.is_reserved
or ip.is_unspecified
or ip.is_multicast
):
return None
return hostname
except ValueError:
pass
if "." not in hostname:
return None
return hostname
def is_remote_site_url(url: str) -> bool:
return extract_remote_site_domain(url) is not None
def normalize_route_domain(value: str) -> str:
"""Normalize a route-domain-like input into a lowercase hostname."""
raw = str(value or "").strip().lower()
if not raw:
return ""
candidate = raw
if "://" not in candidate:
candidate = f"https://{candidate.lstrip('/')}"
try:
parsed = urlparse(candidate)
hostname = (parsed.hostname or "").strip().lower().rstrip(".")
if hostname:
return hostname
except Exception:
pass
return raw.strip().strip("/").split("/", 1)[0].strip().strip(".")
def build_route_domain_aliases(value: str) -> List[str]:
"""Build compatible route-domain aliases for a hostname-like value."""
normalized = normalize_route_domain(value)
if not normalized:
return []
aliases: List[str] = []
seen = set()
def _add(item: str):
host = normalize_route_domain(item)
if host and host not in seen:
seen.add(host)
aliases.append(host)
_add(normalized)
if normalized.startswith("www."):
_add(normalized[4:])
else:
_add(f"www.{normalized}")
for group in build_route_alias_groups():
if normalized in group:
for alias in group:
_add(alias)
return aliases
def get_preferred_route_domain(value: str) -> str:
"""Return the preferred public route-domain alias for a site."""
normalized = normalize_route_domain(value)
if not normalized:
return ""
for group in build_route_alias_groups():
if normalized in group:
return group[0]
if normalized.startswith("www."):
return normalized[4:]
return normalized
def get_canonical_route_domain(value: str) -> str:
"""Return the configured site domain for aliases used in routing."""
normalized = normalize_route_domain(value)
if not normalized:
return ""
rules = load_site_rules()
if normalized in rules:
return normalized
if normalized.startswith("www.") and normalized[4:] in rules:
return normalized[4:]
for site_domain, rule in rules.items():
aliases = list(rule.get("route_aliases", []) or [])
for alias in aliases:
normalized_alias = normalize_route_domain(alias)
if not normalized_alias:
continue
if normalized == normalized_alias:
return site_domain
if normalized.startswith("www.") and normalized[4:] == normalized_alias:
return site_domain
if normalized.startswith("www."):
return normalized[4:]
return normalized
def route_domain_matches(target_domain: str, actual_domain: str) -> bool:
"""Whether the route-domain target can represent the actual page domain."""
target_aliases = build_route_domain_aliases(target_domain)
actual_aliases = build_route_domain_aliases(actual_domain)
if not target_aliases or not actual_aliases:
return False
for target in target_aliases:
for actual in actual_aliases:
if actual == target:
return True
if actual.endswith(f".{target}") or target.endswith(f".{actual}"):
return True
return False
def normalize_exact_tab_url(value: str) -> str:
"""Normalize a full tab URL for strict route matching."""
raw = str(value or "").strip()
if not raw:
return ""
try:
parsed = urlparse(raw)
except Exception:
return raw
scheme = str(parsed.scheme or "").strip().lower()
hostname = str(parsed.hostname or "").strip().lower().rstrip(".")
if not scheme or not hostname:
return raw
default_port = 80 if scheme == "http" else 443 if scheme == "https" else None
try:
port = parsed.port
except ValueError:
return raw
host_for_netloc = f"[{hostname}]" if ":" in hostname else hostname
netloc = host_for_netloc
if port and port != default_port:
netloc = f"{host_for_netloc}:{port}"
path = parsed.path or "/"
return urlunparse((
scheme,
netloc,
path,
parsed.params,
parsed.query,
parsed.fragment,
))
def tab_url_matches(target_url: str, actual_url: str) -> bool:
"""Whether two tab URLs match after strict normalization."""
target = normalize_exact_tab_url(target_url)
actual = normalize_exact_tab_url(actual_url)
return bool(target and actual and target == actual)
def encode_tab_url_route_token(value: str) -> str:
"""Encode a normalized tab URL into a short stable route token."""
normalized = normalize_exact_tab_url(value)
if not normalized:
return ""
digest = hashlib.sha1(normalized.encode("utf-8")).hexdigest()
return digest[:12]
def decode_tab_url_route_token(token: str) -> str:
"""Short route tokens are one-way hashes; keep API shape for compatibility."""
return str(token or "").strip().lower()
__all__ = [
"build_route_domain_aliases",
"decode_tab_url_route_token",
"encode_tab_url_route_token",
"extract_remote_site_domain",
"get_canonical_route_domain",
"get_preferred_route_domain",
"is_remote_site_url",
"normalize_route_domain",
"normalize_exact_tab_url",
"route_domain_matches",
"tab_url_matches",
]