add sanity test of ipv6 and ipv4 socket

Author: tonymet

.github/workflows/go.yml

@@ -12,6 +12,8 @@ jobs:
         uses: actions/setup-go@v5
         with:
           go-version: '1.24.x'   # Set to your Go version
+      - name: Run golangci-lint
+        uses: golangci/golangci-lint-action@v4
       - name: Install dependencies
         run: go mod tidy
       - name: Run tests

Makefile

@@ -1,2 +1,5 @@
 README.md:multilistener/*
-	gomarkdoc --header-file header.in --output README.md ./multilistener
+	gomarkdoc --header-file header.in --output README.md ./multilistener
+
+lint:
+	golangci-lint run

cmd/simple-listener/main.go

@@ -0,0 +1,29 @@
+package main
+
+import (
+    "fmt"
+    "log"
+    "net"
+)
+
+func main() {
+    // This listener is bound to the IPv6 loopback address and will accept
+    // connections from both [::1] (IPv6) and 127.0.0.1 (IPv4).
+    ln, err := net.Listen("tcp", "[::1]:8080")
+    if err != nil {
+        log.Fatal(err)
+    }
+    defer ln.Close()
+
+    fmt.Println("Listening on [::1]:8080. Try connecting with 'telnet 127.0.0.1 8080' and 'telnet ::1 8080'")
+
+    for {
+        conn, err := ln.Accept()
+        if err != nil {
+            log.Println(err)
+            continue
+        }
+        fmt.Printf("Accepted connection from %s\n", conn.RemoteAddr())
+        conn.Close()
+    }
+}

multilistener/multilistener_test.go

@@ -1,29 +1,83 @@
 package multilistener
 
 import (
+	"fmt"
 	"io"
+	"net"
 	"net/http"
-	"sync"
-	"fmt"
 	"testing"
 	"time"
 )
 
+// TestListenOnlyIPV6 sanity check that IPv6 Socket cannot receive ipv4 requests
+//
+// AI claimed IPV6 ::1 C sockets also accepted ipv4.  This test confirms go sockets do not
+// see also cmd/simple-listener and test with telnet
+// I feel like I'm taking crazy pills.
+func TestListenOnlyIPV6(t *testing.T){
+	ready := make(chan struct{})
+	port := "8084"
+	ml, err := net.Listen("tcp", "[::1]:"+port) // Listen only on IPv6 loopback
+	if err != nil {
+		t.Fatalf("Failed to create MultiListener for IPv6 only: %v", err)
+	}
+
+	go func() {
+		close(ready)
+		if err := http.Serve(ml, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			if _, err := io.WriteString(w, "Hello from IPv6 Listener!"); err != nil {
+				t.Errorf("error writing string: %v", err)
+			}
+		})); err != nil {
+			t.Errorf("http serve error: %v", err)
+		}
+	}()
+
+	// server is ready
+	<-ready
+
+	// Attempt to connect to the IPv4 loopback address
+	testAddr := "127.0.0.1:"+port
+	t.Logf("Attempting to connect to %s (IPv4) to an IPv6-only listener", testAddr)
+
+	resp, err := http.Get("http://" + testAddr)
+	if err != nil {
+		t.Logf("Expected error when connecting to IPv4 address on IPv6-only listener: %v", err)
+		// This is the expected behavior, as the listener is only on IPv6
+		return
+	}
+	defer resp.Body.Close()
+
+	// If we reach here, it means the IPv4 connection succeeded unexpectedly
+	t.Errorf("Unexpected success connecting to IPv4 address %s on an IPv6-only listener. Status: %d", testAddr, resp.StatusCode)
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		t.Errorf("Failed to read response body from %s: %v", testAddr, err)
+	}
+	t.Errorf("Received body: %s", string(body))
+}
+
+
 func TestMultiListener(t *testing.T) {
+	ready := make(chan struct{})
 	ml, err := NewLocalLoopback("8081") // Use port 0 to get a random available port
 	if err != nil {
 		t.Fatalf("Failed to create MultiListener: %v", err)
 	}
 	// Start an HTTP server on the MultiListener
-	var wg sync.WaitGroup
-	wg.Add(1)
 	go func() {
-		defer wg.Done()
-		http.Serve(ml, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			io.WriteString(w, "Hello from MultiListener!")
-		}))
+		close(ready)
+		if err := http.Serve(ml, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			if _, err := io.WriteString(w, "Hello from MultiListener!"); err != nil{
+				t.Errorf("error writeString")
+			}
+		})); err != nil{
+			t.Errorf("http serve error")
+		}
 	}()
 
+	<-ready
 	// Get the addresses of the listeners
 	addrs := ml.AllAddr().String()
 	t.Logf("MultiListener serving on: %s", addrs)
@@ -67,7 +121,7 @@ func ExampleNewLocalLoopback() {
 	}
 	fmt.Printf("Serving HTTP %+v\n", dual.AllAddr())
 	fmt.Printf("Preferred Addr: %+v\n", dual.Addr())
-	go http.Serve(dual, nil)
+	go http.Serve(dual, nil) //nolint:errcheck
 	// Output:
 	// Serving HTTP [::1]:8080,127.0.0.1:8080
 	// Preferred Addr: [::1]:8080