Refactor matching and hostname specificity

Author: sjberman

internal/state/dataplane/configuration.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"fmt"
 	"sort"
-	"strings"
 
 	"k8s.io/apimachinery/pkg/types"
 	"sigs.k8s.io/gateway-api/apis/v1beta1"
@@ -569,8 +568,6 @@ func convertPathType(pathType v1beta1.PathMatchType) PathType {
 }
 
 // listenerHostnameMoreSpecific returns true if host1 is more specific than host2.
-//
-// This function assumes that host1 and host2 match, either exactly or as a substring.
 func listenerHostnameMoreSpecific(host1, host2 *v1beta1.Hostname) bool {
 	var host1Str, host2Str string
 	if host1 != nil {
@@ -581,15 +578,5 @@ func listenerHostnameMoreSpecific(host1, host2 *v1beta1.Hostname) bool {
 		host2Str = string(*host2)
 	}
 
-	host1Segments := len(strings.Split(host1Str, "."))
-	host2Segments := len(strings.Split(host2Str, "."))
-	if host1Segments > host2Segments {
-		return true
-	}
-
-	if host2Segments > host1Segments {
-		return false
-	}
-
-	return len(host1Str) >= len(host2Str)
+	return graph.GetMoreSpecificHostname(host1Str, host2Str) == host1Str
 }

internal/state/dataplane/configuration_test.go

@@ -1996,8 +1996,6 @@ func TestConvertPathType(t *testing.T) {
 }
 
 func TestHostnameMoreSpecific(t *testing.T) {
-	g := NewGomegaWithT(t)
-
 	tests := []struct {
 		host1     *v1beta1.Hostname
 		host2     *v1beta1.Hostname
@@ -2050,6 +2048,8 @@ func TestHostnameMoreSpecific(t *testing.T) {
 
 	for _, tc := range tests {
 		t.Run(tc.msg, func(t *testing.T) {
+			g := NewGomegaWithT(t)
+
 			g.Expect(listenerHostnameMoreSpecific(tc.host1, tc.host2)).To(Equal(tc.host1Wins))
 		})
 	}

internal/state/graph/httproute.go

@@ -402,33 +402,91 @@ func findAcceptedHostnames(listenerHostname *v1beta1.Hostname, routeHostnames []
 		return []string{hostname}
 	}
 
-	match := func(h v1beta1.Hostname) bool {
-		if hostname == "" {
-			return true
-		}
+	var result []string
 
+	for _, h := range routeHostnames {
 		routeHost := string(h)
-		return routeHost == hostname || wildcardMatch(hostname, routeHost) || wildcardMatch(routeHost, hostname)
+		if match(hostname, routeHost) {
+			result = append(result, GetMoreSpecificHostname(hostname, routeHost))
+		}
 	}
 
-	var result []string
+	return result
+}
 
-	for _, h := range routeHostnames {
-		if match(h) {
-			if len(hostname) > len(h) {
-				result = append(result, hostname)
-			} else {
-				result = append(result, string(h))
+func match(listenerHost, routeHost string) bool {
+	if listenerHost == "" {
+		return true
+	}
+
+	if routeHost == listenerHost {
+		return true
+	}
+
+	wildcardMatch := func(host1, host2 string) bool {
+		return strings.HasPrefix(host1, "*.") && strings.HasSuffix(host2, strings.TrimPrefix(host1, "*"))
+	}
+
+	// check if listenerHost is a wildcard and routeHost matches
+	if wildcardMatch(listenerHost, routeHost) {
+		return true
+	}
+
+	// check if routeHost is a wildcard and listener matchess
+	return wildcardMatch(routeHost, listenerHost)
+}
+
+// GetMoreSpecificHostname returns the more specific hostname between the two inputs.
+//
+// This function assumes that the two hostnames match each other, either:
+// - Exactly
+// - One as a substring of the other
+// - Both as substrings of some parent wildcard
+func GetMoreSpecificHostname(hostname1, hostname2 string) string {
+	if hostname1 == hostname2 {
+		return hostname1
+	}
+
+	if hostname1 == "" {
+		return hostname2
+	} else if hostname2 == "" {
+		return hostname1
+	}
+
+	// Compare if wildcards are present
+	if strings.HasPrefix(hostname1, "*.") {
+		if strings.HasPrefix(hostname2, "*.") {
+			subdomains1 := strings.Split(hostname1, ".")
+			subdomains2 := strings.Split(hostname2, ".")
+
+			// Compare number of subdomains
+			if len(subdomains1) > len(subdomains2) {
+				return hostname1
 			}
+
+			return hostname2
 		}
+
+		return hostname2
+	} else if strings.HasPrefix(hostname2, "*.") {
+		return hostname1
 	}
 
-	return result
-}
+	subdomains1 := strings.Split(hostname1, ".")
+	subdomains2 := strings.Split(hostname2, ".")
+
+	// Compare number of subdomains
+	if len(subdomains1) > len(subdomains2) {
+		return hostname1
+	} else if len(subdomains1) < len(subdomains2) {
+		return hostname2
+	}
+
+	if len(hostname1) > len(hostname2) {
+		return hostname1
+	}
 
-// wildcardMatch checks if host1 is a wildcard host, and if so, checks if host2 is a match for that wildcard.
-func wildcardMatch(host1, host2 string) bool {
-	return strings.HasPrefix(host1, "*.") && strings.HasSuffix(host2, strings.TrimPrefix(host1, "*"))
+	return hostname2
 }
 
 func routeAllowedByListener(

internal/state/graph/httproute_test.go

@@ -1280,6 +1280,12 @@ func TestFindAcceptedHostnames(t *testing.T) {
 			expected:         []string{"*.example.com"},
 			msg:              "route wildcard hostname; nil listener hostname",
 		},
+		{
+			listenerHostname: &listenerHostnameWildcard,
+			routeHostnames:   []v1beta1.Hostname{"*.bar.example.com"},
+			expected:         []string{"*.bar.example.com"},
+			msg:              "route and listener wildcard hostnames",
+		},
 	}
 
 	for _, test := range tests {

internal/state/graph/validation_test.go

@@ -32,6 +32,11 @@ func TestValidateHostname(t *testing.T) {
 			expectErr: true,
 			name:      "invalid hostname",
 		},
+		{
+			hostname:  "*.example.*.com",
+			expectErr: true,
+			name:      "invalid wildcard hostname",
+		},
 	}
 
 	for _, test := range tests {