Files
Thing/src-tauri/src/music/feiniu/fnconnect.rs
T
2026-09-15 17:17:16 +08:00

296 lines
10 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! FnConnect 远程连接解析。
//!
//! 链路参考第三方客户端 FnMusic 的 `fn_connection_probe_service.dart`:
//! fnId → 网关 `<网关>/api/v1/fn/con`(authx md5 签名)→ 内网 / 公网 IPv6 / 公网 IPv4 / 中继
//! 候选 → 并发探测(按优先级早停)→ 首个可达的 base_url。
//!
//! 关键约束(实测确认):
//! 1. authx 原文为 `PREFIX_url_nonce_timestamp_md5(body)_API_KEY`,
//! md5 与 API_KEY 之间是**单个**下划线;多一个下划线网关即返回 `invalid sign`。
//! 2. 中继地址(`<fnId>.fnos.net`)必须携带 `Cookie: mode=relay` 才会被网关转发到
//! NAS 音乐后端,否则网关直接 302 回登录页。
use std::time::Duration;
use futures_util::stream::{FuturesUnordered, StreamExt};
use md5::{Digest, Md5};
use rand::RngCore;
use serde_json::{json, Value};
/// 网关主机(按序回退;5ddd.com 与 fnos.net 为同一服务的不同集群入口)。
const FN_CONNECT_HOSTS: [&str; 2] = ["https://5ddd.com", "https://fnos.net"];
/// 连接参数接口路径(签名原文中的 url 部分)。
const FN_CON_PATH: &str = "/api/v1/fn/con";
/// 签名常量(对齐第三方实现)。
const FN_AUTHX_PREFIX: &str = "NDzZTVxnRKP8Z0jXg1VAMonaG8akvh";
const FN_API_KEY: &str = "zIGtkc3dqZnJpd29qZXJqa2w7c";
/// 网关查询超时。
const FN_QUERY_TIMEOUT: Duration = Duration::from_secs(10);
/// 直连候选(内网/公网 IP)探测超时。
const FN_PROBE_TIMEOUT_DIRECT: Duration = Duration::from_secs(3);
/// 中继候选探测超时(走公网网关,放宽)。
const FN_PROBE_TIMEOUT_RELAY: Duration = Duration::from_secs(10);
fn md5_hex(input: &str) -> String {
let mut h = Md5::new();
h.update(input.as_bytes());
format!("{:x}", h.finalize())
}
/// 从输入识别 fnId:`fnos.net/<id>`、`5ddd.com/<id>`、`<id>.fnos.net`、`<id>.5ddd.com`、或裸 fnId。
pub fn extract_fn_id(input: &str) -> Option<String> {
let s = input.trim();
if s.is_empty() {
return None;
}
// 去协议后统一按「可能带路径的 host」处理
let mut t = s;
for p in ["https://", "http://"] {
if let Some(r) = t.strip_prefix(p) {
t = r;
break;
}
}
let t = t.trim_end_matches('/');
// 形如 <网关>/<id>
for gw in ["fnos.net/", "5ddd.com/"] {
if let Some((_, rest)) = t.split_once(gw) {
let id = rest.split('/').next().unwrap_or("").trim();
if !id.is_empty() {
return Some(id.to_string());
}
}
}
// 形如 <id>.<网关>
for suffix in [".fnos.net", ".5ddd.com"] {
if let Some(id) = t.strip_suffix(suffix) {
if !id.is_empty() {
return Some(id.to_string());
}
}
}
// 裸 fnId
if s.len() >= 3 && s.chars().all(|c| c.is_alphanumeric() || c == '-' || c == '_') {
return Some(s.to_string());
}
None
}
/// 计算网关 authx 签名。
///
/// 原文(下划线连接,**注意 md5 与 API_KEY 之间只有一个下划线**):
/// `PREFIX_url_nonce_timestamp_md5(body)_API_KEY` → 取 md5 作为 sign。
fn fn_authx(method: &str, url: &str, data: &Value) -> String {
let body = if method.eq_ignore_ascii_case("get") {
String::new()
} else {
serde_json::to_string(data).unwrap_or_default()
};
let mut nonce = String::new();
let mut rng = rand::thread_rng();
for _ in 0..6 {
nonce.push(char::from(b'0' + (rng.next_u32() % 10) as u8));
}
let timestamp = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_millis().to_string())
.unwrap_or_default();
let raw = format!(
"{FN_AUTHX_PREFIX}_{url}_{nonce}_{timestamp}_{}_{FN_API_KEY}",
md5_hex(&body)
);
format!("nonce={nonce}&timestamp={timestamp}&sign={}", md5_hex(&raw))
}
/// 从网关查询 fnId 的连接参数(多网关按序回退)。
pub async fn query_fn_connect(fn_id: &str) -> Result<Value, String> {
let client = reqwest::Client::builder()
.timeout(FN_QUERY_TIMEOUT)
.build()
.map_err(|e| e.to_string())?;
let body = json!({ "fnId": fn_id });
let authx = fn_authx("post", FN_CON_PATH, &body);
let mut last_err = String::from("FnConnect 网关不可达");
for host in FN_CONNECT_HOSTS {
let resp = match client
.post(format!("{host}{FN_CON_PATH}"))
.header("Content-Type", "application/json")
.header("authx", authx.clone())
.json(&body)
.send()
.await
{
Ok(r) => r,
Err(e) => {
last_err = format!("FnConnect 网关不可达: {e}");
continue;
}
};
let b: Value = match resp.json().await {
Ok(v) => v,
Err(e) => {
last_err = format!("FnConnect 网关响应异常: {e}");
continue;
}
};
if b["code"].as_i64().unwrap_or(-1) != 0 {
last_err = b["msg"]
.as_str()
.filter(|s| !s.is_empty())
.map(|s| s.to_string())
.unwrap_or_else(|| "FnConnect 网关返回错误".to_string());
continue;
}
return Ok(b["data"].clone());
}
Err(last_err)
}
/// 去掉 `host:port` 形式的端口(仅用于中继域名,中继恒走 443)。
fn strip_port(addr: &str) -> &str {
match addr.rsplit_once(':') {
Some((host, port)) if !host.is_empty() && port.chars().all(|c| c.is_ascii_digit()) => host,
_ => addr,
}
}
/// 构建候选 base_url 列表。返回 `(url, is_relay)`,顺序即优先级:
/// 内网 IPv4 → 公网 IPv6 → 公网 IPv4 → 中继。
///
/// IP 直连地址 HTTP 优先、HTTPS 兜底(自签证书场景 HTTP 更易通);
/// `forbbidPublicIpv6` 为真时跳过公网 IPv6。
pub fn build_candidates(data: &Value, fn_id: &str) -> Vec<(String, bool)> {
let mut out: Vec<(String, bool)> = Vec::new();
let port = &data["port"];
let http = port["httpPort"].as_u64().unwrap_or(5666);
let https = port["httpsPort"].as_u64().unwrap_or(5667);
let empty: Vec<Value> = Vec::new();
let strings = |key: &str| -> Vec<String> {
data[key]
.as_array()
.unwrap_or(&empty)
.iter()
.filter_map(|v| v.as_str())
.map(|s| s.to_string())
.collect()
};
// 1) 内网 IPv4
for ip in strings("ipv4") {
out.push((format!("http://{ip}:{http}"), false));
out.push((format!("https://{ip}:{https}"), false));
}
// 2) 公网 IPv6(NAS 侧可禁用)
if !data["forbbidPublicIpv6"].as_bool().unwrap_or(false) {
for ip in strings("publicIpv6") {
out.push((format!("http://[{ip}]:{http}"), false));
out.push((format!("https://[{ip}]:{https}"), false));
}
}
// 3) 公网 IPv4
for ip in strings("publicIpv4") {
out.push((format!("http://{ip}:{http}"), false));
out.push((format!("https://{ip}:{https}"), false));
}
// 4) 中继:仅 HTTPS;网关未返回时按两种集群域名兜底
let mut relays = strings("fn");
if relays.is_empty() {
relays = vec![
format!("{fn_id}.fnos.net"),
format!("{fn_id}.5ddd.com"),
];
}
for addr in relays {
let domain = strip_port(&addr);
if !domain.is_empty() {
out.push((format!("https://{domain}"), true));
}
}
out
}
/// 探测单个 base_url 是否可用(中继候选携带 `mode=relay` 才会被网关转发)。
///
/// 判据必须排除 3xx:重定向说明请求**没有真正落到 NAS 音乐后端**
/// (中继缺 `mode=relay` 时网关 302 回登录页;端口上实际是 fnOS Web UI 时同样 302)。
/// 早先把「任何 < 500」都当可达,结果候选探测通过、紧接着登录报 `HTTP 302 Found`。
async fn probe(client: &reqwest::Client, url: &str, relay: bool) -> bool {
let timeout = if relay {
FN_PROBE_TIMEOUT_RELAY
} else {
FN_PROBE_TIMEOUT_DIRECT
};
let full = format!(
"{}/music/api/v1/track/list?page=1&size=1",
url.trim_end_matches('/')
);
let mut rb = client.get(&full).timeout(timeout);
if relay {
rb = rb.header("cookie", "mode=relay");
}
match rb.send().await {
// 未登录时中继会返回 401(已触达 NAS 音乐后端),直连返回 200/401,
// 均视为链路可达;3xx(重定向)与 5xx 视为不可达。
Ok(resp) => {
let code = resp.status().as_u16();
code < 500 && !(300..400).contains(&code)
}
Err(_) => false,
}
}
/// 解析 fnId → 首个可达的 base_url;返回 `(base_url, is_relay)`。
///
/// 所有候选并发探测,按优先级(索引越小越优先)取首个确认可达者并早停,
/// 避免远程场景下顺序探测逐个等待超时。
pub async fn resolve_base_url(fn_id: &str) -> Result<(String, bool), String> {
let data = query_fn_connect(fn_id).await?;
let candidates = build_candidates(&data, fn_id);
if candidates.is_empty() {
return Err("FnConnect 未返回可用地址".into());
}
let client = reqwest::Client::builder()
.timeout(FN_PROBE_TIMEOUT_RELAY)
.build()
.map_err(|e| e.to_string())?;
let mut pending = FuturesUnordered::new();
for (i, (url, relay)) in candidates.iter().enumerate() {
let client = client.clone();
let url = url.clone();
let relay = *relay;
pending.push(async move {
let ok = probe(&client, &url, relay).await;
(i, url, relay, ok)
});
}
let mut undecided: Vec<usize> = (0..candidates.len()).collect();
let mut best: Option<(usize, String, bool)> = None;
while let Some((i, url, relay, ok)) = pending.next().await {
undecided.retain(|x| *x != i);
if ok && best.as_ref().map_or(true, |(bi, _, _)| i < *bi) {
best = Some((i, url, relay));
}
// 早停:已有可达候选,且不存在索引更小(优先级更高)的未决候选
if let Some((bi, _, _)) = best.as_ref() {
if !undecided.iter().any(|x| x < bi) {
break;
}
}
}
match best {
Some((idx, url, relay)) => {
let _ = idx;
Ok((url, relay))
}
None => Err(format!("FnConnect 候选均不可达({} 个)", candidates.len())),
}
}