frontend: use more robust method to get host/port from WHOIS server setting

Author: xddxdd

frontend/whois.go

@@ -10,6 +10,21 @@ import (
 	"github.com/google/shlex"
 )
 
+// addDefaultWhoisPort adds the default whois port (43) if not specified.
+// Handles IPv4, IPv6 (bare and bracketed), and domain names.
+func addDefaultWhoisPort(server string) string {
+	if _, _, err := net.SplitHostPort(server); err != nil {
+		// No port specified, add default whois port
+		// Strip brackets from IPv6 addresses like [::1] before JoinHostPort adds them back
+		host := server
+		if strings.HasPrefix(host, "[") && strings.HasSuffix(host, "]") {
+			host = host[1 : len(host)-1]
+		}
+		return net.JoinHostPort(host, "43")
+	}
+	return server
+}
+
 // Send a whois request
 func whois(s string) string {
 	if setting.whoisServer == "" {
@@ -36,10 +51,7 @@ func whois(s string) string {
 	} else {
 		buf := make([]byte, 65536)
 
-		whoisServer := setting.whoisServer
-		if !strings.Contains(whoisServer, ":") {
-			whoisServer = whoisServer + ":43"
-		}
+		whoisServer := addDefaultWhoisPort(setting.whoisServer)
 
 		conn, err := net.DialTimeout("tcp", whoisServer, 5*time.Second)
 		if err != nil {

frontend/whois_test.go

@@ -7,11 +7,51 @@ import (
 	"testing"
 )
 
+func TestAddDefaultWhoisPort(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected string
+	}{
+		// IPv4 addresses
+		{"IPv4 without port", "192.0.2.1", "192.0.2.1:43"},
+		{"IPv4 with port", "192.0.2.1:4343", "192.0.2.1:4343"},
+
+		// IPv6 addresses - bare format
+		{"IPv6 bare without port", "::1", "[::1]:43"},
+		{"IPv6 bare full without port", "2001:db8::1", "[2001:db8::1]:43"},
+
+		// IPv6 addresses - bracketed format
+		{"IPv6 bracketed without port", "[::1]", "[::1]:43"},
+		{"IPv6 bracketed full without port", "[2001:db8::1]", "[2001:db8::1]:43"},
+		{"IPv6 bracketed with port", "[::1]:4343", "[::1]:4343"},
+		{"IPv6 bracketed full with port", "[2001:db8::1]:4343", "[2001:db8::1]:4343"},
+
+		// Domain names
+		{"Domain without port", "whois.example.com", "whois.example.com:43"},
+		{"Domain with port", "whois.example.com:4343", "whois.example.com:4343"},
+
+		// Edge cases
+		{"Localhost without port", "localhost", "localhost:43"},
+		{"Localhost with port", "localhost:4343", "localhost:4343"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := addDefaultWhoisPort(tt.input)
+			if result != tt.expected {
+				t.Errorf("addDefaultWhoisPort(%q) = %q, want %q", tt.input, result, tt.expected)
+			}
+		})
+	}
+}
+
 type WhoisServer struct {
 	t             *testing.T
 	expectedQuery string
 	response      string
 	server        net.Listener
+	listenAddr    string // Address to listen on, defaults to "127.0.0.1:0"
 }
 
 const AS6939Response = `
@@ -23,12 +63,14 @@ Updated:        2003-11-04
 Ref:            https://rdap.arin.net/registry/autnum/6939
 `
 
-func (s *WhoisServer) Listen() {
+func (s *WhoisServer) Listen() error {
 	var err error
-	s.server, err = net.Listen("tcp", "127.0.0.1:0")
-	if err != nil {
-		s.t.Error(err)
+	listenAddr := s.listenAddr
+	if listenAddr == "" {
+		listenAddr = "127.0.0.1:0"
 	}
+	s.server, err = net.Listen("tcp", listenAddr)
+	return err
 }
 
 func (s *WhoisServer) Run() {
@@ -68,7 +110,9 @@ func TestWhois(t *testing.T) {
 		response:      AS6939Response,
 	}
 
-	server.Listen()
+	if err := server.Listen(); err != nil {
+		t.Fatal(err)
+	}
 	go server.Run()
 	defer server.Close()
 
@@ -126,3 +170,55 @@ func TestWhoisHostProcessVeryLong(t *testing.T) {
 		t.Errorf("Whois result incorrectly truncated, actual len %d", len(result))
 	}
 }
+
+func TestWhoisIPv6(t *testing.T) {
+	server := WhoisServer{
+		t:             t,
+		expectedQuery: "AS6939",
+		response:      AS6939Response,
+		listenAddr:    "[::1]:0",
+	}
+
+	if err := server.Listen(); err != nil {
+		t.Skip("IPv6 not available:", err)
+	}
+	go server.Run()
+	defer server.Close()
+
+	setting.whoisServer = server.server.Addr().String()
+	result := whois("AS6939")
+	if !strings.Contains(result, "HURRICANE") {
+		t.Errorf("Whois AS6939 over IPv6 failed, got %s", result)
+	}
+}
+
+func TestWhoisIPv6WithoutPort(t *testing.T) {
+	server := WhoisServer{
+		t:             t,
+		expectedQuery: "AS6939",
+		response:      AS6939Response,
+		listenAddr:    "[::1]:43",
+	}
+
+	if err := server.Listen(); err != nil {
+		t.Skip("IPv6 not available or port 43 not bindable:", err)
+	}
+	go server.Run()
+	defer server.Close()
+
+	// Test that bare IPv6 address (without port) gets default port 43 appended
+	setting.whoisServer = "::1"
+	result := whois("AS6939")
+	if !strings.Contains(result, "HURRICANE") {
+		t.Errorf("Whois AS6939 over IPv6 (bare address) failed, got %s", result)
+	}
+}
+
+func TestWhoisIPv6ConnectionError(t *testing.T) {
+	// Use IPv6 loopback with a port that should be refused
+	setting.whoisServer = "[::1]:1"
+	result := whois("AS6939")
+	if !strings.Contains(result, "connect: connection refused") && !strings.Contains(result, "network is unreachable") {
+		t.Errorf("Whois AS6939 IPv6 connection error produced unexpected output, got %s", result)
+	}
+}