音乐模块调整

This commit is contained in:
zhongluofeng committed 2026-09-15 17:17:16 +08:00
1 parent 4f574cb5fa
commit 8f853f7ef3
31 files changed
+3819 -936

No files matched your search

+211 -70
View File
@@ -1,51 +1,86 @@
//! FnConnect 远程连接解析(参考 feiniu-car-music `fn-api.js`)。
//! FnConnect 远程连接解析。
//!
//! fnId → 网关 `https://5ddd.com/api/v1/fn/con`(authx md5 签名)→ 内网/公网/中继候选 →
//! 探测可达性 → 得到可用的 base_url(含 mode=relay 的中继地址)。
//! 链路参考第三方客户端 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};
/// 网关地址与签名常量(对齐 feiniu-car-music)。
const FN_CONNECT_URL: &str = "https://5ddd.com/api/v1/fn/con";
/// 网关主机(按序回退;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>`、`<id>.5ddd.com`、或裸 fnId。
/// 从输入识别 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;
}
if let Some(id) = s.split_once("fnos.net/").map(|(_, r)| r.split('/').next().unwrap_or("")) {
if !id.is_empty() {
return Some(id.trim().to_string());
// 去协议后统一按「可能带路径的 host」处理
let mut t = s;
for p in ["https://", "http://"] {
if let Some(r) = t.strip_prefix(p) {
t = r;
break;
}
}
if let Some(rest) = s.rsplit_once("/") {
let last = rest.1;
if last.ends_with(".5ddd.com") {
return Some(last.trim_end_matches(".5ddd.com").to_string());
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());
}
}
}
if s.ends_with(".5ddd.com") {
return Some(s.trim_end_matches(".5ddd.com").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 == '_') && !s.starts_with("http") {
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()
@@ -62,93 +97,199 @@ fn fn_authx(method: &str, url: &str, data: &Value) -> String {
.map(|d| d.as_millis().to_string())
.unwrap_or_default();
let raw = format!(
"{FN_AUTHX_PREFIX}_{url}_{nonce}_{timestamp}_{}__{FN_API_KEY}",
"{FN_AUTHX_PREFIX}_{url}_{nonce}_{timestamp}_{}_{FN_API_KEY}",
md5_hex(&body)
);
format!("nonce={nonce}&timestamp={timestamp}&sign={}", md5_hex(&raw))
}
/// 从网关查询 fnId 的连接参数。
/// 从网关查询 fnId 的连接参数(多网关按序回退)。
pub async fn query_fn_connect(fn_id: &str) -> Result<Value, String> {
let client = reqwest::Client::builder()
.timeout(std::time::Duration::from_secs(10))
.timeout(FN_QUERY_TIMEOUT)
.build()
.map_err(|e| e.to_string())?;
let body = json!({ "fnId": fn_id });
let resp = client
.post(FN_CONNECT_URL)
.header("Content-Type", "application/json")
.header("authx", fn_authx("post", "/api/v1/fn/con", &body))
.json(&body)
.send()
.await
.map_err(|e| format!("FnConnect 网关不可达: {e}"))?;
let b: Value = resp.json().await.map_err(|e| e.to_string())?;
if b["code"].as_i64().unwrap_or(-1) != 0 {
return Err(b["msg"].as_str().unwrap_or("FnConnect 网关返回错误").to_string());
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());
}
Ok(b["data"].clone())
Err(last_err)
}
/// 构建候选 base_url 列表。返回 (url, is_relay)。
pub fn build_candidates(data: &Value) -> Vec<(String, bool)> {
/// 去掉 `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![];
for ip in data["ipv4"].as_array().unwrap_or(&empty).iter().filter_map(|v| v.as_str()) {
out.push((format!("http://{ip}:{http}"), false));
out.push((format!("https://{ip}:{https}"), false));
}
for ip in data["publicIpv4"].as_array().unwrap_or(&empty).iter().filter_map(|v| v.as_str()) {
out.push((format!("http://{ip}:{http}"), false));
out.push((format!("https://{ip}:{https}"), false));
}
for ip in data["publicIpv6"].as_array().unwrap_or(&empty).iter().filter_map(|v| v.as_str()) {
out.push((format!("http://[{ip}]:{http}"), false));
out.push((format!("https://[{ip}]:{https}"), false));
}
let relays = data["fn"].as_array().unwrap_or(&empty);
let relay_addrs: Vec<String> = if relays.is_empty() {
vec!["5ddd.com".to_string()]
} else {
relays
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()))
.filter_map(|v| v.as_str())
.map(|s| s.to_string())
.collect()
};
for addr in relay_addrs {
let domain = addr.split(':').next().unwrap_or(&addr).to_string();
out.push((format!("https://{domain}"), true));
// 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 是否可用。
async fn probe(url: &str) -> bool {
let client = reqwest::Client::builder()
.timeout(std::time::Duration::from_secs(6))
.build()
.unwrap_or_else(|_| reqwest::Client::new());
let full = format!("{}/music/api/v1/track/list?page=1&size=1", url.trim_end_matches('/'));
match client.get(&full).send().await {
Ok(resp) => resp.status().as_u16() < 500,
/// 探测单个 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)。
/// 解析 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);
let candidates = build_candidates(&data, fn_id);
if candidates.is_empty() {
return Err("FnConnect 未返回可用地址".into());
}
for (url, relay) in &candidates {
if probe(url).await {
return Ok((url.clone(), *relay));
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;
}
}
}
Err(format!("FnConnect 候选均不可达({} 个)", candidates.len()))
match best {
Some((idx, url, relay)) => {
let _ = idx;
Ok((url, relay))
}
None => Err(format!("FnConnect 候选均不可达({} 个)", candidates.len())),
}
}