Add new API settings

dialer/bypass.go

@@ -0,0 +1,133 @@
+package dialer
+
+import (
+	"context"
+	"fmt"
+	"net"
+	"net/url"
+	"path"
+	"strings"
+)
+
+type bypassPattern struct {
+	raw  string
+	host string
+}
+
+type BypassDialer struct {
+	direct   ContextDialer
+	proxied  ContextDialer
+	patterns []bypassPattern
+}
+
+func NewBypassDialer(patterns []string, direct, proxied ContextDialer) (*BypassDialer, error) {
+	compiled := make([]bypassPattern, 0, len(patterns))
+	for _, raw := range patterns {
+		hostPattern, err := normalizeBypassPattern(raw)
+		if err != nil {
+			return nil, fmt.Errorf("invalid proxy bypass pattern %q: %w", raw, err)
+		}
+		if _, err := path.Match(hostPattern, ""); err != nil {
+			return nil, fmt.Errorf("invalid proxy bypass pattern %q: %w", raw, err)
+		}
+		compiled = append(compiled, bypassPattern{
+			raw:  raw,
+			host: hostPattern,
+		})
+	}
+	return &BypassDialer{
+		direct:   direct,
+		proxied:  proxied,
+		patterns: compiled,
+	}, nil
+}
+
+func (d *BypassDialer) Dial(network, address string) (net.Conn, error) {
+	return d.DialContext(context.Background(), network, address)
+}
+
+func (d *BypassDialer) DialContext(ctx context.Context, network, address string) (net.Conn, error) {
+	if d.shouldBypass(address) {
+		return d.direct.DialContext(ctx, network, address)
+	}
+	return d.proxied.DialContext(ctx, network, address)
+}
+
+func (d *BypassDialer) shouldBypass(address string) bool {
+	host := normalizeDialTarget(address)
+	if host == "" {
+		return false
+	}
+	for _, pattern := range d.patterns {
+		matched, err := path.Match(pattern.host, host)
+		if err != nil {
+			continue
+		}
+		if matched {
+			return true
+		}
+	}
+	return false
+}
+
+func normalizeBypassPattern(raw string) (string, error) {
+	pattern := strings.TrimSpace(raw)
+	if pattern == "" {
+		return "", fmt.Errorf("empty pattern")
+	}
+
+	switch {
+	case strings.Contains(pattern, "://"):
+		parsed, err := url.Parse(pattern)
+		if err != nil {
+			return "", fmt.Errorf("unable to parse URL: %w", err)
+		}
+		if parsed.Host == "" {
+			return "", fmt.Errorf("URL does not contain a host")
+		}
+		pattern = parsed.Hostname()
+	case strings.HasPrefix(pattern, "//"):
+		parsed, err := url.Parse("https:" + pattern)
+		if err != nil {
+			return "", fmt.Errorf("unable to parse URL: %w", err)
+		}
+		if parsed.Host == "" {
+			return "", fmt.Errorf("URL does not contain a host")
+		}
+		pattern = parsed.Hostname()
+	case strings.ContainsAny(pattern, "/?"):
+		parsed, err := url.Parse("https://" + strings.TrimLeft(pattern, "/"))
+		if err != nil {
+			return "", fmt.Errorf("unable to parse URL-like pattern: %w", err)
+		}
+		if parsed.Host == "" {
+			return "", fmt.Errorf("pattern does not contain a host")
+		}
+		pattern = parsed.Hostname()
+	default:
+		if host, _, err := net.SplitHostPort(pattern); err == nil {
+			pattern = host
+		}
+	}
+
+	pattern = strings.Trim(pattern, "[]")
+	pattern = strings.ToLower(pattern)
+	if pattern == "" {
+		return "", fmt.Errorf("empty host pattern")
+	}
+	return pattern, nil
+}
+
+func normalizeDialTarget(address string) string {
+	host := strings.TrimSpace(address)
+	if host == "" {
+		return ""
+	}
+	if parsed, err := url.Parse(host); err == nil && parsed.Host != "" {
+		host = parsed.Hostname()
+	} else if h, _, err := net.SplitHostPort(host); err == nil {
+		host = h
+	}
+	host = strings.Trim(host, "[]")
+	return strings.ToLower(host)
+}