package proxy import ( "context" "errors" "fmt" "io" "net/http" "net/url" "regexp" "strings" "time" ) var whitelistIPRegex = regexp.MustCompile(`\b(?:\d{1,3}\.){3}\d{1,3}\b`) // Endpoint 是代理提供商返回的一条可连接代理。 type Endpoint struct { URL string IP string Port string Region string Protocol string Username string Password string Provider string ExpiresAt time.Time } // Provider 把不同代理平台的参数规则与响应格式隔离在各自实现中。 type Provider interface { ID() string Match(*url.URL) bool RequestURL(apiURL string, count int) (string, error) Parse(apiURL string, body []byte) ([]Endpoint, error) } // WhitelistConfig 是代理平台自动白名单所需参数。 type WhitelistConfig struct { APIURL string IP string LoginPassword string SignKey string ReplaceOldest bool AutoWhitelist bool } // WhitelistProvider 由支持自动白名单的代理平台实现。 type WhitelistProvider interface { Provider EnsureWhitelist(context.Context, *http.Client, WhitelistConfig) error AddWhitelist(context.Context, *http.Client, WhitelistConfig) error } // ProviderError 是代理平台返回的业务错误。 type ProviderError struct { Provider string Message string Fatal bool } func (e *ProviderError) Error() string { if e == nil { return "" } if e.Provider == "" { return e.Message } return e.Provider + ": " + e.Message } // IsFatal 判断错误是否重试也不会恢复,例如密钥错误、白名单缺失或套餐过期。 func IsFatal(err error) bool { var providerErr *ProviderError return errors.As(err, &providerErr) && providerErr.Fatal } // Service 负责通用 HTTP 请求、provider 选择和结果去重。 type Service struct { client *http.Client providers []Provider } func NewService() *Service { return NewServiceWithProviders( &http.Client{Timeout: 10 * time.Second}, NewIPZanProvider(), NewGenericProvider(), ) } func NewServiceWithProviders(client *http.Client, providers ...Provider) *Service { if client == nil { client = &http.Client{Timeout: 10 * time.Second} } return &Service{client: client, providers: providers} } // Extract 自动识别代理平台并请求所需数量;调用方可用剩余数量再次提取补足。 func (s *Service) Extract(ctx context.Context, apiURL string, count int) ([]Endpoint, error) { if count <= 0 { count = 1 } u, err := url.Parse(strings.TrimSpace(apiURL)) if err != nil { return nil, fmt.Errorf("代理 API 地址无效: %w", err) } if u.Scheme != "http" && u.Scheme != "https" { return nil, errors.New("代理 API 地址必须以 http:// 或 https:// 开头") } provider := s.providerFor(u) if provider == nil { return nil, errors.New("没有匹配的代理提供商") } requestURL, err := provider.RequestURL(apiURL, count) if err != nil { return nil, err } body, err := s.fetch(ctx, requestURL) if err != nil { return nil, err } endpoints, err := provider.Parse(apiURL, body) if err != nil { return nil, err } for i := range endpoints { if endpoints[i].Provider == "" { endpoints[i].Provider = provider.ID() } } endpoints = dedupeEndpoints(endpoints, count) if len(endpoints) == 0 { return nil, errors.New("代理 API 返回的代理均已过期或无效") } return endpoints, nil } func (s *Service) ExtractOne(ctx context.Context, apiURL string) (Endpoint, error) { endpoints, err := s.Extract(ctx, apiURL, 1) if err != nil { return Endpoint{}, err } if len(endpoints) == 0 { return Endpoint{}, errors.New("代理 API 未返回有效地址") } return endpoints[0], nil } // EnsureWhitelist 自动把指定公网 IP 加入当前 API 套餐白名单;已存在时直接跳过。 func (s *Service) EnsureWhitelist(ctx context.Context, cfg WhitelistConfig) error { u, err := url.Parse(strings.TrimSpace(cfg.APIURL)) if err != nil { return fmt.Errorf("代理 API 地址无效: %w", err) } provider := s.providerFor(u) manager, ok := provider.(WhitelistProvider) if !ok { return errors.New("当前代理提供商不支持自动白名单") } return manager.EnsureWhitelist(ctx, s.client, cfg) } // AddWhitelist 直接添加白名单,不再调用独立的 verify 接口。 func (s *Service) AddWhitelist(ctx context.Context, cfg WhitelistConfig) error { u, err := url.Parse(strings.TrimSpace(cfg.APIURL)) if err != nil { return fmt.Errorf("代理 API 地址无效: %w", err) } provider := s.providerFor(u) manager, ok := provider.(WhitelistProvider) if !ok { return errors.New("当前代理提供商不支持自动白名单") } return manager.AddWhitelist(ctx, s.client, cfg) } // ExtractWithWhitelist 先探测提取;若平台提示当前 IP 不在白名单,则直接使用错误中 // 平台实际看到的来源 IP,添加后重试,避免第三方公网 IP 探测与实际出口不一致。 func (s *Service) ExtractWithWhitelist(ctx context.Context, apiURL string, count int, cfg WhitelistConfig) ([]Endpoint, error) { endpoints, err := s.Extract(ctx, apiURL, count) if err == nil || !cfg.AutoWhitelist { return endpoints, err } ip, ok := whitelistIPFromError(err) if !ok { return nil, err } cfg.APIURL = apiURL cfg.IP = ip if addErr := s.AddWhitelist(ctx, cfg); addErr != nil { return nil, fmt.Errorf("品赞要求添加白名单 IP %s,自动添加失败: %w", ip, addErr) } return s.Extract(ctx, apiURL, count) } func whitelistIPFromError(err error) (string, bool) { if err == nil || !strings.Contains(err.Error(), "白名单") { return "", false } ip := whitelistIPRegex.FindString(err.Error()) return ip, ip != "" } func (s *Service) providerFor(u *url.URL) Provider { for _, provider := range s.providers { if provider != nil && provider.Match(u) { return provider } } return nil } func (s *Service) fetch(ctx context.Context, rawURL string) ([]byte, error) { req, err := http.NewRequestWithContext(ctx, http.MethodGet, rawURL, nil) if err != nil { return nil, fmt.Errorf("创建代理 API 请求失败: %w", err) } req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36") resp, err := s.client.Do(req) if err != nil { return nil, fmt.Errorf("请求代理 API 失败: %w", err) } defer resp.Body.Close() body, err := io.ReadAll(io.LimitReader(resp.Body, 128*1024)) if err != nil { return nil, fmt.Errorf("读取代理 API 响应失败: %w", err) } if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices { return nil, fmt.Errorf("代理 API HTTP %d: %s", resp.StatusCode, truncateText(string(body), 160)) } return body, nil } func dedupeEndpoints(endpoints []Endpoint, limit int) []Endpoint { out := make([]Endpoint, 0, min(len(endpoints), limit)) seen := make(map[string]struct{}, len(endpoints)) for _, endpoint := range endpoints { endpoint.URL = strings.TrimSpace(endpoint.URL) if endpoint.URL == "" { continue } if !endpoint.ExpiresAt.IsZero() && !time.Now().Before(endpoint.ExpiresAt) { continue } if _, ok := seen[endpoint.URL]; ok { continue } seen[endpoint.URL] = struct{}{} out = append(out, endpoint) if len(out) >= limit { break } } return out } func buildProxyURL(protocol, ip, port, username, password string) string { scheme := "http" if protocol == "3" || strings.EqualFold(protocol, "socks5") || strings.EqualFold(protocol, "socket5") { scheme = "socks5" } auth := "" if username != "" || password != "" { auth = url.UserPassword(username, password).String() + "@" } return fmt.Sprintf("%s://%s%s:%s", scheme, auth, strings.TrimSpace(ip), strings.TrimSpace(port)) } func protocolFromAPI(apiURL string) string { u, err := url.Parse(apiURL) if err != nil { return "1" } if value := strings.TrimSpace(u.Query().Get("protocol")); value != "" { return value } return "1" } func truncateText(value string, maxLen int) string { runes := []rune(strings.TrimSpace(value)) if len(runes) <= maxLen { return string(runes) } return string(runes[:maxLen]) + "..." }