gcli2api / internal /proxypool /subscription.go
a3216's picture
feat: 同步上游 320f5d4;扩展模型(多免费渠道/自定义映射/访问密钥/模型白名单)
e48a2d8
Raw History Blame Contribute Delete
17.3 kB
// subscription.go 代理订阅归一化:把「订阅内容」变成可导入的代理 URL(借鉴
// ardeyouxipianyi/workbuddy2api-hub 的 wb_subbridge.py 的输入侧)。
//
// 为什么需要:本网关的传输层只支持 http / https / socks5 三种代理(见 transport.go),
// 而订阅给的是 base64 的 ss/vmess/trojan 列表或 Clash YAML。此前唯一的导入入口是
// 「一行一个 http:// 或 socks5:// URL」,于是订阅拿到手还得手工转一遍。
//
// 本文件做的是**纯文本解析**,不做的事有三件,都是刻意的:
//
// 1. **不抓取订阅 URL**。面板进程去 GET 任意外部地址是 SSRF 面(内网地址探测、
// 云元数据端点),要有独立的域名白名单与出站审计才安全,不在这版范围。用户把
// 订阅内容(或订阅返回的正文)粘进来即可。
// 2. **不起 mihomo/clash 子进程**。参照实现为了支持 ss/vmess/trojan 起一个本地
// mihomo 监听并渲染 yaml,那是把「网关」变成「代理编排器」:多一个二进制、
// 多一份配置生成器、多一组进程生命周期问题。本网关的取舍是不支持这些协议,
// 而是**明确报出被跳过的是哪些、为什么**(ImportResult.Status = "unsupported"
// 带上协议名),让运维知道该另外起一个本地 mihomo 再把它的 socks5 端口导入。
// 3. **不猜**。认不出的行报 invalid 并原样留在输入框里(面板既有行为),不做
// 「尽力而为」的模糊匹配——一条猜错的代理会把某个账号的流量发到不该去的地方。
package proxypool
import (
"encoding/base64"
"fmt"
"net"
"net/url"
"strconv"
"strings"
)
// SubEntry 订阅里的一项:要么归一出了受支持的 URL,要么带一条说明为什么不行。
type SubEntry struct {
// Line 原文行号(1 起)。Clash 块式条目取该条目首行,便于用户在 yaml 里定位。
Line int
// Name 订阅里给的名字(Clash 的 name 字段 / URI 的 fragment),仅作展示。
Name string
// Kind 原始协议名(http / socks5 / ss / vmess / …),报错文案用。
Kind string
// URL 归一后的代理 URL(http/https/socks5)。空 = 不支持或无法解析。
URL string
// Unsupported true = 协议**认得出来**,只是本网关的传输层不解析它
// (ss / vmess / trojan …)。与「认不出的行」是两件事:前者不是用户写错了,
// 报「格式错误」会让人去改一个本来正确的东西。
Unsupported bool
// Reason 不支持 / 无法解析的原因(人类可读)。URL 非空时为空。
Reason string
}
// supportedProxySchemes 传输层真正支持的协议(与 parseURL 的 defaultPort 同一份口径)。
var supportedProxySchemes = map[string]string{
"http": "80", "https": "443", "socks5": "1080", "socks5h": "1080",
}
// knownUnsupportedSchemes 认得出来、但本网关不解析的订阅协议。
//
// 列出来是为了给出**具体**的报错(「ss 不解析」)而不是笼统的「格式错误」——
// 后者会让用户以为是自己粘错了。
var knownUnsupportedSchemes = map[string]bool{
"ss": true, "ssr": true, "vmess": true, "vless": true, "trojan": true,
"hysteria": true, "hysteria2": true, "hy2": true, "tuic": true,
"wireguard": true, "wg": true, "snell": true, "juicity": true, "anytls": true,
"mieru": true, "ssh": true, "socks4": true, "socks4a": true,
}
// ParseSubscription 把订阅正文归一成条目列表。空输入返回空列表(不是错误)。
//
// 支持三种形态,自动识别:
// - 明文 URI 列表(一行一个 http:// / socks5:// / ss:// …);
// - base64 正文(V2Ray/机场最常见的 ss/vmess 订阅,整段 base64);
// - Clash / mihomo 的 YAML 配置(只取 proxies: 段)。
func ParseSubscription(text string) ([]SubEntry, error) {
// 刻意**不** TrimSpace 原文:行号是面板回填输入框的索引(无效行会被原样放回
// 文本框让用户改),前面少几行就会错位——实测「首行是空行」的输入因此把第 2 行
// 报成第 1 行。只在判空时 Trim。
if strings.TrimSpace(text) == "" {
return nil, nil
}
if decoded, ok := decodeBase64Body(text); ok {
text = strings.TrimSpace(decoded)
}
if hasClashProxies(text) {
return parseClashProxies(text)
}
return parseURILines(text)
}
// decodeBase64Body 整段 base64 订阅(去掉换行后解码)。判据刻意收紧:
//
// 原文必须既不含 "://" 也不含 "proxies:" —— 那两种是明文订阅与 yaml 的特征,
// 先排除掉才不会把「恰好全由 base64 字符组成的配置」误当编码内容;
// 解码结果必须含 "://" 或 "proxies:" —— 否则这就是一段碰巧能解出来的字,不是订阅。
//
// 返回 ok=false 时调用方按原文继续处理(绝不因为「不像 base64」就丢弃输入)。
func decodeBase64Body(text string) (string, bool) {
if strings.Contains(text, "://") || strings.Contains(strings.ToLower(text), "proxies:") {
return "", false
}
compact := strings.Join(strings.Fields(text), "")
if compact == "" {
return "", false
}
for _, enc := range []*base64.Encoding{
base64.StdEncoding, base64.RawStdEncoding,
base64.URLEncoding, base64.RawURLEncoding,
} {
raw, err := enc.DecodeString(compact)
if err != nil {
continue
}
decoded := string(raw)
if strings.Contains(decoded, "://") || strings.Contains(strings.ToLower(decoded), "proxies:") {
return decoded, true
}
}
return "", false
}
// hasClashProxies 报告正文是否是一个带 proxies: 段的 Clash 配置。
func hasClashProxies(text string) bool {
for _, line := range strings.Split(text, "\n") {
if isClashProxiesKey(line) {
return true
}
}
return false
}
// isClashProxiesKey 顶层(或任意缩进)的 `proxies:` 键。
//
// 允许缩进是因为有的订阅把 proxies 放在别的结构里;`proxies: []` 这种空值的也认
// (下面解析会得到 0 条,用户看到「没有可用节点」而不是「格式错误」)。
// 值为**流式序列**(`proxies: [{...}, {...}]`)时同样是合法的 proxies 段——此前只认
// 字面量 "[]",于是这种写法整体落到 URI 行解析,产出一个既无 type 也无 server 的
// 空条目:节点被静默丢掉,还不报错。
func isClashProxiesKey(line string) bool {
t := strings.TrimSpace(line)
if !strings.HasPrefix(t, "proxies:") {
return false
}
rest := strings.TrimSpace(strings.TrimPrefix(t, "proxies:"))
if rest == "" || strings.HasPrefix(rest, "#") {
return true
}
return strings.HasPrefix(rest, "[")
}
// parseClashProxies 只解析 proxies: 段,其余段一概不看。
//
// 为什么手写而不引 YAML 库:仓库当前零 yaml 依赖,而为「读一个 {type, server, port,
// username, password}」这五个标量字段引一个通用解析器不值得——它带来的是一整套
// 类型系统与宽松语法的边界问题,而我们只需要扁平的 key: value。
//
// 支持两种写法(都是真实订阅里出现的):
//
// - name: 香港 01
// type: socks5
// server: hk.example.com
// port: 1080
// username: u
// password: p
//
// - {name: "香港 01", type: socks5, server: hk.example.com, port: 1080}
//
// 段内出现新的顶层键(proxy-groups: 等)即结束。
func parseClashProxies(text string) ([]SubEntry, error) {
lines := strings.Split(text, "\n")
var out []SubEntry
inProxies := false
// baseIndent 「- 」列表项的缩进;块式条目的字段缩进必须比它深。
baseIndent := -1
var cur map[string]string
var curLine int
var curName string
flush := func() {
if cur == nil {
return
}
out = append(out, clashEntryToSubEntry(curLine, curName, cur))
cur = nil
}
for i, raw := range lines {
lineNo := i + 1
line := strings.TrimRight(raw, "\r")
trimmed := strings.TrimSpace(line)
if trimmed == "" || strings.HasPrefix(trimmed, "#") {
continue
}
indent := len(line) - len(strings.TrimLeft(line, " \t"))
if !inProxies {
if isClashProxiesKey(line) {
// proxies 的值是流式序列时整段取出来单独解析(可能同一行,也可能跨行:
// proxies: [{...}, {...}]
// proxies: [
// {...},
// ]
// )。块式写法(下一行起 "- name: ...")走下面的逐行状态机,两条路径
// 互斥,不会重复解析。
if val, vl, ok := flowSequenceValue(lines, i); ok {
if !bracketsBalanced(val) {
// 未闭合的数组按错误上报:静默返回 0 条会让用户以为订阅是空的。
return nil, fmt.Errorf("proxies 的流式数组未闭合(第 %d 行起)", vl)
}
return append(out, parseFlowArray(vl, val)...), nil
}
inProxies = true
}
continue
}
// 段结束:出现非列表项、且缩进不比列表项深的 key(如 proxy-groups:)。
if !strings.HasPrefix(trimmed, "- ") && trimmed != "-" {
if baseIndent < 0 || indent <= baseIndent {
flush()
inProxies = false
continue
}
// 块式条目的字段行。
if cur != nil {
if k, v, ok := splitYAMLKV(trimmed); ok {
cur[k] = v
}
}
continue
}
// 新的列表项。
flush()
if baseIndent < 0 {
baseIndent = indent
}
item := strings.TrimSpace(strings.TrimPrefix(trimmed, "-"))
curLine = lineNo
cur = map[string]string{}
curName = ""
if strings.HasPrefix(item, "{") {
// 流式写法:整条在行内。
cur = parseFlowMap(item)
curName = cur["name"]
flush()
continue
}
if k, v, ok := splitYAMLKV(item); ok {
cur[k] = v
if k == "name" {
curName = v
}
}
}
flush()
return out, nil
}
// flowSequenceValue 取出 `proxies:` 的流式序列值(`[...]`,含跨行形式),并返回其
// 起始行号(1 起)。值不是流式序列(块式 `- name: ...`)时 ok=false,调用方走原来的
// 逐行状态机。
//
// 三种真实写法都要认:
//
// proxies: [{name: a, ...}, {name: b, ...}]
// proxies: [
// {name: a, ...},
// ]
// proxies:
// [{name: a, ...}]
func flowSequenceValue(lines []string, keyIdx int) (string, int, bool) {
rest := strings.TrimSpace(valueAfterColon(lines[keyIdx]))
if rest == "" {
// 值在后续行:跳过空行与注释行,看第一行是不是 "["。
for j := keyIdx + 1; j < len(lines); j++ {
t := strings.TrimSpace(strings.TrimRight(lines[j], "\r"))
if t == "" || strings.HasPrefix(t, "#") {
continue
}
if !strings.HasPrefix(t, "[") {
return "", 0, false
}
return collectFlowValue(lines, j, t), j + 1, true
}
return "", 0, false
}
if !strings.HasPrefix(rest, "[") {
return "", 0, false
}
return collectFlowValue(lines, keyIdx, rest), keyIdx + 1, true
}
// collectFlowValue 从 start 行开始累积,直到方括号配平(跨行时按空格拼接,跳过纯注释行)。
func collectFlowValue(lines []string, start int, first string) string {
buf := first
if bracketsBalanced(buf) {
return buf
}
for j := start + 1; j < len(lines); j++ {
t := strings.TrimSpace(strings.TrimRight(lines[j], "\r"))
if t == "" || strings.HasPrefix(t, "#") {
continue
}
buf += " " + t
if bracketsBalanced(buf) {
break
}
}
return buf
}
// valueAfterColon 取 `key: value` 里冒号之后的部分(未去引号;只用于判形态)。
func valueAfterColon(line string) string {
i := strings.Index(line, ":")
if i < 0 {
return ""
}
return strings.TrimSpace(line[i+1:])
}
// bracketsBalanced 报告 [ ] 与 { } 是否配平,忽略引号内的括号(名字/密码里出现
// 括号是常见的,按字符数数必然误判)。
func bracketsBalanced(s string) bool {
depth := 0
var quote byte
for i := 0; i < len(s); i++ {
c := s[i]
switch {
case quote != 0:
if c == '\\' {
i++
} else if c == quote {
quote = 0
}
case c == '"' || c == '\'':
quote = c
case c == '[' || c == '{':
depth++
case c == ']' || c == '}':
depth--
}
}
return depth == 0 && quote == 0
}
// parseFlowArray 解析 `[ {...}, {...} ]` 形式的流式数组。
func parseFlowArray(lineNo int, s string) []SubEntry {
inner := strings.TrimSpace(strings.TrimPrefix(strings.TrimSuffix(strings.TrimSpace(s), "]"), "["))
var out []SubEntry
for _, part := range splitFlowItems(inner) {
m := parseFlowMap(part)
if len(m) == 0 {
continue
}
out = append(out, clashEntryToSubEntry(lineNo, m["name"], m))
}
return out
}
// splitFlowItems 按顶层逗号切分流式写法(引号内、花括号内的逗号不切)。
func splitFlowItems(s string) []string {
var parts []string
var buf strings.Builder
depth := 0
var quote byte
for i := 0; i < len(s); i++ {
c := s[i]
switch {
case quote != 0:
if c == quote {
quote = 0
} else if c == '\\' && i+1 < len(s) {
buf.WriteByte(c)
i++
c = s[i]
}
case c == '"' || c == '\'':
quote = c
case c == '{' || c == '[':
depth++
case c == '}' || c == ']':
depth--
case c == ',' && depth == 0:
parts = append(parts, buf.String())
buf.Reset()
continue
}
buf.WriteByte(c)
}
if s := strings.TrimSpace(buf.String()); s != "" {
parts = append(parts, s)
}
return parts
}
// parseFlowMap 把 `{k: v, k2: v2}`(或去掉花括号的 `k: v, k2: v2`)解析成 map。
func parseFlowMap(s string) map[string]string {
s = strings.TrimSpace(s)
s = strings.TrimPrefix(s, "{")
s = strings.TrimSuffix(s, "}")
out := map[string]string{}
for _, part := range splitFlowItems(s) {
if k, v, ok := splitYAMLKV(part); ok {
out[k] = v
}
}
return out
}
// splitYAMLKV 切 `key: value`,去掉值两端引号。没有冒号或键为空时 ok=false。
func splitYAMLKV(s string) (string, string, bool) {
s = strings.TrimSpace(s)
i := strings.Index(s, ":")
if i <= 0 {
return "", "", false
}
k := strings.TrimSpace(s[:i])
v := strings.TrimSpace(s[i+1:])
if k == "" {
return "", "", false
}
// 去掉 yaml 注释(值里的人名/密码带 # 的情况极少,且带引号时下面的 Trim 会先处理)。
if len(v) >= 2 && ((v[0] == '"' && v[len(v)-1] == '"') || (v[0] == '\'' && v[len(v)-1] == '\'')) {
v = v[1 : len(v)-1]
}
return strings.ToLower(k), v, true
}
// clashEntryToSubEntry 把一条 Clash 代理定义转成受支持的代理 URL,或给出不支持的说明。
func clashEntryToSubEntry(line int, name string, m map[string]string) SubEntry {
kind := strings.ToLower(strings.TrimSpace(m["type"]))
e := SubEntry{Line: line, Name: name, Kind: kind}
if kind == "" {
e.Reason = "缺少 type 字段,无法判定协议"
return e
}
if knownUnsupportedSchemes[kind] {
e.Unsupported = true
e.Reason = unsupportedReason(kind)
return e
}
if _, ok := supportedProxySchemes[kind]; !ok {
e.Reason = "未知的代理类型 " + kind + "(本网关只支持 http/https/socks5)"
return e
}
host := strings.TrimSpace(m["server"])
if host == "" {
e.Reason = "缺少 server 字段"
return e
}
port, err := strconv.Atoi(strings.TrimSpace(m["port"]))
if err != nil || port < 1 || port > 65535 {
e.Reason = "port 字段缺失或不是 1-65535 的整数"
return e
}
u := &url.URL{Scheme: kind, Host: net.JoinHostPort(host, strconv.Itoa(port))}
if user := strings.TrimSpace(m["username"]); user != "" {
u.User = url.UserPassword(user, strings.TrimSpace(m["password"]))
}
e.URL = u.String()
return e
}
// parseURILines 明文 URI 列表:一行一个。
func parseURILines(text string) ([]SubEntry, error) {
lines := strings.Split(text, "\n")
out := make([]SubEntry, 0, len(lines))
for i, raw := range lines {
line := strings.TrimSpace(strings.TrimRight(raw, "\r"))
if line == "" || strings.HasPrefix(line, "#") || strings.HasPrefix(line, "//") {
continue
}
out = append(out, parseURILine(i+1, line))
}
return out, nil
}
// parseURILine 归一一行 URI。socks:// 是 socks5 的常见别名,按 socks5 处理;
// 其余不支持的协议给出具体原因。
func parseURILine(line int, s string) SubEntry {
scheme := ""
if i := strings.Index(s, "://"); i > 0 {
scheme = strings.ToLower(s[:i])
}
e := SubEntry{Line: line, Kind: scheme}
if scheme == "" {
e.Reason = "不是代理 URL(缺少 scheme://);本框也接受 Clash/subscription 全文"
return e
}
if knownUnsupportedSchemes[scheme] {
e.Unsupported = true
e.Reason = unsupportedReason(scheme)
return e
}
switch scheme {
case "socks", "socks5", "socks5h", "http", "https":
default:
e.Reason = "未知的协议 " + scheme + "(本网关只支持 http/https/socks5)"
return e
}
u, err := url.Parse(s)
if err != nil || u == nil {
e.Reason = "无法解析的代理 URL"
return e
}
if scheme == "socks" {
u.Scheme = "socks5"
e.Kind = "socks5"
}
// 名字(#fragment)只作展示:parseURL 明确拒绝带 fragment 的 URL,这里剥掉。
if u.Fragment != "" {
e.Name = u.Fragment
u.Fragment, u.RawFragment = "", ""
}
e.URL = u.String()
return e
}
func unsupportedReason(kind string) string {
return kind + " 协议不由本网关解析(传输层只支持 http/https/socks5);" +
"可在本机另起一个 mihomo 导出 socks5 端口,再把那个 socks5:// 地址导入"
}