File size: 17,330 Bytes
e48a2d8
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
// 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:// 地址导入"
}