chore: move ip utils

Author: gosunuts

portal/api_server.go

@@ -432,17 +432,6 @@ func (s *Server) handleQUICTunnelConn(conn *quic.Conn) {
 		Msg("quic tunnel connected")
 }
 
-func sanitizeReportedIP(raw string) string {
-	candidate := strings.TrimSpace(raw)
-	if candidate == "" {
-		return ""
-	}
-	if net.ParseIP(candidate) == nil {
-		return ""
-	}
-	return candidate
-}
-
 func (s *Server) registerLease(req types.RegisterRequest, clientIP string) (types.RegisterResponse, error) {
 	name, err := utils.NormalizeDNSLabel(req.Name)
 	if err != nil {
@@ -503,7 +492,7 @@ func (s *Server) registerLease(req types.RegisterRequest, clientIP string) (type
 			FirstSeenAt:  now,
 			LastSeenAt:   now,
 			ClientIP:     clientIP,
-			ReportedIP:   sanitizeReportedIP(req.ReportedIP),
+			ReportedIP:   utils.SanitizeReportedIP(req.ReportedIP),
 			UDPEnabled:   req.UDPEnabled,
 		},
 		ReverseToken: req.ReverseToken,
@@ -580,7 +569,7 @@ func (s *Server) renewLease(req types.RenewRequest, clientIP string) (types.Rene
 	if req.TTL > 0 {
 		ttl = time.Duration(req.TTL) * time.Second
 	}
-	record, err := s.registry.Renew(req.LeaseID, req.ReverseToken, ttl, clientIP, sanitizeReportedIP(req.ReportedIP))
+	record, err := s.registry.Renew(req.LeaseID, req.ReverseToken, ttl, clientIP, utils.SanitizeReportedIP(req.ReportedIP))
 	if err != nil {
 		return types.RenewResponse{}, err
 	}

sdk/api_client.go

@@ -147,7 +147,7 @@ func (a *apiClient) ensureReady(ctx context.Context) error {
 	a.rawTLSConfig = rawTLSConfig
 
 	if a.resolvedPublicIP == "" {
-		a.resolvedPublicIP = resolvePublicIP(ctx)
+		a.resolvedPublicIP = utils.ResolvePublicIP(ctx)
 	}
 
 	return nil

sdk/public_ip.go

@@ -0,0 +1,105 @@
+package utils
+
+import (
+	"context"
+	"encoding/json"
+	"io"
+	"net"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/gosuda/portal/v2/types"
+)
+
+// ResolvePublicIP attempts to determine the caller's public IP address
+// using well-known external services. Returns empty string on failure.
+// Best-effort with a short timeout to avoid blocking registration.
+func ResolvePublicIP(ctx context.Context) string {
+	ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
+	defer cancel()
+
+	endpoints := []string{
+		"https://api.ipify.org",
+		"https://ifconfig.me/ip",
+	}
+	client := &http.Client{Timeout: 3 * time.Second}
+
+	for _, endpoint := range endpoints {
+		req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
+		if err != nil {
+			continue
+		}
+		req.Header.Set("User-Agent", "portal-tunnel")
+
+		resp, err := client.Do(req)
+		if err != nil {
+			continue
+		}
+
+		body, readErr := io.ReadAll(io.LimitReader(resp.Body, 256))
+		_ = resp.Body.Close()
+		if resp.StatusCode != http.StatusOK || readErr != nil {
+			continue
+		}
+
+		if candidate := SanitizeReportedIP(string(body)); candidate != "" {
+			return candidate
+		}
+	}
+
+	return ""
+}
+
+func SanitizeReportedIP(raw string) string {
+	candidate := strings.TrimSpace(raw)
+	if candidate == "" {
+		return ""
+	}
+	if net.ParseIP(candidate) == nil {
+		return ""
+	}
+	return candidate
+}
+
+func ResolvePortalRelayURLs(ctx context.Context, explicit []string, includeDefaults bool) ([]string, error) {
+	explicit, err := NormalizeRelayURLs(explicit...)
+	if err != nil {
+		return nil, err
+	}
+	if !includeDefaults {
+		return explicit, nil
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, types.PortalRelayRegistryURL, nil)
+	if err != nil {
+		return explicit, nil
+	}
+
+	client := &http.Client{Timeout: 5 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return explicit, nil
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return explicit, nil
+	}
+
+	var registry struct {
+		Relays []string `json:"relays"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&registry); err != nil {
+		return explicit, nil
+	}
+
+	defaults, err := NormalizeRelayURLs(registry.Relays...)
+	if err != nil {
+		return explicit, nil
+	}
+	if len(defaults) == 0 {
+		return explicit, nil
+	}
+	return MergeRelayURLs(defaults, nil, explicit)
+}

utils/network.go

@@ -0,0 +1,30 @@
+package utils
+
+import "testing"
+
+func TestSanitizeReportedIP(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name string
+		raw  string
+		want string
+	}{
+		{name: "empty", raw: "", want: ""},
+		{name: "whitespace", raw: "   ", want: ""},
+		{name: "ipv4", raw: " 203.0.113.10 ", want: "203.0.113.10"},
+		{name: "ipv6", raw: " 2001:db8::1 ", want: "2001:db8::1"},
+		{name: "invalid", raw: "not-an-ip", want: ""},
+		{name: "host port", raw: "203.0.113.10:443", want: ""},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			if got := SanitizeReportedIP(tc.raw); got != tc.want {
+				t.Fatalf("SanitizeReportedIP(%q) = %q, want %q", tc.raw, got, tc.want)
+			}
+		})
+	}
+}