fix: 增强节点检测与IP检查回退

- /check-ip 支持 SOCKS5 回退成功

- IP 检测新增多服务 fallback + SBPM_IPCHECK_URLS

- TLS ALPN 逗号拆分

- ss:// Base64 全量格式兼容

- 版本升级到 1.3.13

Author: cheluen

backend/api/handlers.go

@@ -1201,22 +1201,7 @@ func (h *Handler) CheckNodeIP(c *gin.Context) {
 		`, id); clearErr != nil {
 			fmt.Printf("[API] Failed to clear node %d status after error: %v\n", id, clearErr)
 		}
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to check IP"})
-		return
-	}
-
-	// If HTTP path failed but SOCKS5 succeeded, treat it as an error because mixed inbound should serve both.
-	if ipInfo.Transport != "" && ipInfo.Transport != "http" {
-		msg := "http proxy failed while socks5 succeeded"
-		if ipInfo.HTTPError != "" {
-			msg = ipInfo.HTTPError
-		}
-		_, _ = h.db.Exec(`
-			UPDATE proxy_nodes 
-			SET node_ip = '', location = '', country_code = '', latency = 0, updated_at = CURRENT_TIMESTAMP
-			WHERE id = ?
-		`, id)
-		c.JSON(http.StatusBadGateway, gin.H{"error": msg})
+		c.JSON(http.StatusBadGateway, gin.H{"error": err.Error()})
 		return
 	}
 

backend/api/handlers_test.go

@@ -147,7 +147,7 @@ func TestCheckNodeIPFailureClearsStatus(t *testing.T) {
 
 	handler.CheckNodeIP(ctx)
 
-	if rec.Code != http.StatusInternalServerError {
+	if rec.Code != http.StatusBadGateway {
 		t.Fatalf("unexpected status %d", rec.Code)
 	}
 	var ip, location, countryCode string
@@ -163,16 +163,17 @@ func TestCheckNodeIPFailureClearsStatus(t *testing.T) {
 	}
 }
 
-func TestCheckNodeIPRejectsSocksFallback(t *testing.T) {
+func TestCheckNodeIPAcceptsSocksFallback(t *testing.T) {
 	gin.SetMode(gin.TestMode)
 
 	handler := newTestHandler(t, func(proxyAddr, username, password string) (*services.IPInfo, error) {
 		return &services.IPInfo{
-			IP:        "9.9.9.9",
-			Location:  "Fallback",
-			Latency:   40,
-			Transport: "socks5",
-			HTTPError: "http unavailable",
+			IP:          "9.9.9.9",
+			Location:    "Fallback",
+			CountryCode: "XX",
+			Latency:     40,
+			Transport:   "socks5",
+			HTTPError:   "http unavailable",
 		}, nil
 	})
 
@@ -184,8 +185,8 @@ func TestCheckNodeIPRejectsSocksFallback(t *testing.T) {
 
 	handler.CheckNodeIP(ctx)
 
-	if rec.Code != http.StatusBadGateway {
-		t.Fatalf("expected bad gateway, got %d", rec.Code)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("expected ok, got %d", rec.Code)
 	}
 	var ip, location, countryCode string
 	var latency int
@@ -195,8 +196,8 @@ func TestCheckNodeIPRejectsSocksFallback(t *testing.T) {
 	`, nodeID).Scan(&ip, &location, &countryCode, &latency); err != nil {
 		t.Fatalf("query node: %v", err)
 	}
-	if ip != "" || location != "" || countryCode != "" || latency != 0 {
-		t.Fatalf("expected cleared status after fallback, got ip=%s location=%s country=%s latency=%d", ip, location, countryCode, latency)
+	if ip != "9.9.9.9" || location != "Fallback" || countryCode != "XX" || latency != 40 {
+		t.Fatalf("expected status updated after fallback, got ip=%s location=%s country=%s latency=%d", ip, location, countryCode, latency)
 	}
 }
 

backend/services/ipcheck.go

@@ -8,6 +8,8 @@ import (
 	"net"
 	"net/http"
 	"net/url"
+	"os"
+	"strings"
 	"time"
 
 	"golang.org/x/net/proxy"
@@ -27,6 +29,57 @@ type IPInfo struct {
 
 const maxIPCheckResponseBytes = 1024 * 1024
 
+func ipCheckServiceURLs() []string {
+	if fromEnv := parseIPCheckServiceURLsFromEnv(); len(fromEnv) > 0 {
+		return fromEnv
+	}
+
+	return []string{
+		"https://api.ip2location.io/?format=json",
+		"http://ip-api.com/json/",
+		"https://api.ip.sb/geoip",
+		"https://ipwho.is/",
+		"https://ipapi.co/json/",
+		"https://api.myip.com",
+		"https://api64.ipify.org?format=json",
+	}
+}
+
+func parseIPCheckServiceURLsFromEnv() []string {
+	raw := strings.TrimSpace(os.Getenv("SBPM_IPCHECK_URLS"))
+	if raw == "" {
+		return nil
+	}
+
+	parts := strings.FieldsFunc(raw, func(r rune) bool {
+		switch r {
+		case ',', '\n', '\r', '\t', ' ':
+			return true
+		default:
+			return false
+		}
+	})
+
+	out := make([]string, 0, len(parts))
+	seen := make(map[string]struct{}, len(parts))
+	for _, part := range parts {
+		part = strings.TrimSpace(part)
+		if part == "" {
+			continue
+		}
+		if !strings.HasPrefix(part, "http://") && !strings.HasPrefix(part, "https://") {
+			continue
+		}
+		if _, ok := seen[part]; ok {
+			continue
+		}
+		seen[part] = struct{}{}
+		out = append(out, part)
+	}
+
+	return out
+}
+
 func waitForTCPReady(addr string, maxWait time.Duration) error {
 	deadline := time.Now().Add(maxWait)
 	backoff := 50 * time.Millisecond
@@ -54,13 +107,12 @@ func waitForTCPReady(addr string, maxWait time.Duration) error {
 func CheckProxyIP(proxyAddr string, username string, password string) (*IPInfo, error) {
 	log.Printf("[IPCheck] Starting IP check for proxy: %s (auth: %v)", proxyAddr, username != "")
 
-	// Measure latency start time
-	startTime := time.Now()
-
 	if err := waitForTCPReady(proxyAddr, 2*time.Second); err != nil {
 		return nil, fmt.Errorf("proxy not ready: %w", err)
 	}
 
+	httpStartTime := time.Now()
+
 	// Build proxy URL with authentication if provided
 	proxyURLStr := "http://"
 	if username != "" && password != "" {
@@ -88,11 +140,7 @@ func CheckProxyIP(proxyAddr string, username string, password string) (*IPInfo,
 	}
 	defer transport.CloseIdleConnections()
 
-	// Use ip2location.io API (free tier, no API key needed for basic usage)
-	services := []string{
-		"https://api.ip2location.io/?format=json",
-		"http://ip-api.com/json/",
-	}
+	services := ipCheckServiceURLs()
 
 	var lastErr error
 	var httpErr error
@@ -101,7 +149,7 @@ func CheckProxyIP(proxyAddr string, username string, password string) (*IPInfo,
 		info, err := checkWithService(client, service)
 		if err == nil && info.IP != "" {
 			// Calculate latency in milliseconds
-			info.Latency = int(time.Since(startTime).Milliseconds())
+			info.Latency = int(time.Since(httpStartTime).Milliseconds())
 			info.Transport = "http"
 			log.Printf("[IPCheck] Success! IP: %s, Location: %s, Latency: %dms", info.IP, info.Location, info.Latency)
 			return info, nil
@@ -115,7 +163,8 @@ func CheckProxyIP(proxyAddr string, username string, password string) (*IPInfo,
 
 	// Try with SOCKS5 if HTTP fails
 	log.Printf("[IPCheck] HTTP proxy failed (%v), trying SOCKS5...", httpErr)
-	result, err := checkWithSOCKS5(proxyAddr, username, password, services, startTime)
+	socksStartTime := time.Now()
+	result, err := checkWithSOCKS5(proxyAddr, username, password, services, socksStartTime)
 	if err == nil {
 		result.Transport = "socks5"
 		if httpErr != nil {
@@ -178,7 +227,14 @@ func checkWithSOCKS5(proxyAddr string, username string, password string, service
 }
 
 func checkWithService(client *http.Client, serviceURL string) (*IPInfo, error) {
-	resp, err := client.Get(serviceURL)
+	req, err := http.NewRequest(http.MethodGet, serviceURL, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %v", err)
+	}
+	req.Header.Set("User-Agent", "sb-proxy-manager/1.0")
+	req.Header.Set("Accept", "application/json")
+
+	resp, err := client.Do(req)
 	if err != nil {
 		return nil, fmt.Errorf("request failed: %v", err)
 	}
@@ -224,6 +280,8 @@ func checkWithService(client *http.Client, serviceURL string) (*IPInfo, error) {
 	// ip2location.io uses "country_code", ip-api uses "countryCode"
 	if countryCode, ok := result["country_code"].(string); ok {
 		info.CountryCode = countryCode
+	} else if countryCode, ok := result["cc"].(string); ok {
+		info.CountryCode = countryCode
 	} else if countryCode, ok := result["countryCode"].(string); ok {
 		info.CountryCode = countryCode
 	}
@@ -277,10 +335,7 @@ func CheckDirectIP() (*IPInfo, error) {
 		Timeout:   10 * time.Second,
 	}
 
-	services := []string{
-		"https://api.ip2location.io/?format=json",
-		"http://ip-api.com/json/",
-	}
+	services := ipCheckServiceURLs()
 
 	var lastErr error
 	for _, service := range services {

backend/services/ipcheck_test.go

@@ -0,0 +1,74 @@
+package services
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+)
+
+func TestCheckWithService_SendsHeaders(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Header.Get("User-Agent") != "sb-proxy-manager/1.0" {
+			w.WriteHeader(http.StatusBadRequest)
+			return
+		}
+		if !strings.Contains(strings.ToLower(r.Header.Get("Accept")), "application/json") {
+			w.WriteHeader(http.StatusBadRequest)
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		_, _ = w.Write([]byte(`{"ip":"1.2.3.4","country":"Testland","cc":"TL","city":"Test City","region":"Test Region"}`))
+	}))
+	t.Cleanup(srv.Close)
+
+	client := &http.Client{}
+	info, err := checkWithService(client, srv.URL)
+	if err != nil {
+		t.Fatalf("checkWithService: %v", err)
+	}
+	if info.IP != "1.2.3.4" {
+		t.Fatalf("unexpected ip: %q", info.IP)
+	}
+}
+
+func TestCheckWithService_ParsesCountryCodeCC(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		_, _ = w.Write([]byte(`{"ip":"1.2.3.4","country":"Testland","cc":"TL"}`))
+	}))
+	t.Cleanup(srv.Close)
+
+	client := &http.Client{}
+	info, err := checkWithService(client, srv.URL)
+	if err != nil {
+		t.Fatalf("checkWithService: %v", err)
+	}
+	if info.CountryCode != "TL" {
+		t.Fatalf("unexpected country code: %q", info.CountryCode)
+	}
+}
+
+func TestCheckDirectIP_UsesEnvServicesWithFallback(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/fail":
+			w.WriteHeader(http.StatusInternalServerError)
+		case "/ok":
+			w.Header().Set("Content-Type", "application/json")
+			_, _ = w.Write([]byte(`{"ip":"1.2.3.4","country":"Testland","cc":"TL"}`))
+		default:
+			w.WriteHeader(http.StatusNotFound)
+		}
+	}))
+	t.Cleanup(srv.Close)
+
+	t.Setenv("SBPM_IPCHECK_URLS", srv.URL+"/fail,"+srv.URL+"/ok")
+	info, err := CheckDirectIP()
+	if err != nil {
+		t.Fatalf("CheckDirectIP: %v", err)
+	}
+	if info.IP != "1.2.3.4" {
+		t.Fatalf("unexpected ip: %q", info.IP)
+	}
+}