fix(wireguard): fix detection of kernelspace wireguard

internal/netlink/helpers_test.go

@@ -1,8 +1,18 @@
 package netlink
 
-import "net/netip"
+import (
+	"net/netip"
+
+	"github.com/qdm12/log"
+)
 
 func makeNetipPrefix(n byte) netip.Prefix {
 	const bits = 24
 	return netip.PrefixFrom(netip.AddrFrom4([4]byte{n, n, n, 0}), bits)
 }
+
+type noopLogger struct{}
+
+func (l *noopLogger) Debug(_ string)            {}
+func (l *noopLogger) Debugf(_ string, _ ...any) {}
+func (l *noopLogger) Patch(_ ...log.Option)     {}

internal/netlink/wireguard.go

@@ -3,52 +3,35 @@
 package netlink
 
 import (
-	"fmt"
-
 	"github.com/qdm12/gluetun/internal/mod"
 	"github.com/vishvananda/netlink"
 )
 
-func (n *NetLink) IsWireguardSupported() (ok bool, err error) {
+func (n *NetLink) IsWireguardSupported() bool {
 	// Check for Wireguard family without loading the wireguard module.
 	// Some kernels have the wireguard module built-in, and don't have a
 	// modules directory, such as WSL2 kernels.
-	ok, err = hasWireguardFamily()
-	if err != nil {
-		return false, fmt.Errorf("checking for wireguard family: %w", err)
-	}
+	ok := hasWireguardFamily()
 	if ok {
-		return true, nil
+		return true
 	}
 
 	// Try loading the wireguard module, since some systems do not load
 	// it after a boot. If this fails, wireguard is assumed to not be supported.
 	n.debugLogger.Debugf("wireguard family not found, trying to load wireguard kernel module")
-	err = mod.Probe("wireguard")
+	err := mod.Probe("wireguard")
 	if err != nil {
 		n.debugLogger.Debugf("failed loading wireguard kernel module: %s", err)
-		return false, nil
+		return false
 	}
 	n.debugLogger.Debugf("wireguard kernel module loaded successfully")
 
 	// Re-check if the Wireguard family is now available, after loading
 	// the wireguard kernel module.
-	ok, err = hasWireguardFamily()
-	if err != nil {
-		return false, fmt.Errorf("checking for wireguard family: %w", err)
-	}
-	return ok, nil
+	return hasWireguardFamily()
 }
 
-func hasWireguardFamily() (ok bool, err error) {
-	families, err := netlink.GenlFamilyList()
-	if err != nil {
-		return false, fmt.Errorf("listing gen 1 families: %w", err)
-	}
-	for _, family := range families {
-		if family.Name == "wireguard" {
-			return true, nil
-		}
-	}
-	return false, nil
+func hasWireguardFamily() bool {
+	_, err := netlink.GenlFamilyGet("wireguard")
+	return err == nil
 }

internal/netlink/wireguard_test.go

@@ -4,17 +4,15 @@ package netlink
 
 import (
 	"testing"
-
-	"github.com/stretchr/testify/require"
 )
 
 func Test_NetLink_IsWireguardSupported(t *testing.T) {
-	t.Skip() // TODO unskip once the data race problem with netlink.GenlFamilyList() is fixed
-
 	t.Parallel()
-	netLink := &NetLink{}
-	ok, err := netLink.IsWireguardSupported()
-	require.NoError(t, err)
+
+	netLink := &NetLink{
+		debugLogger: &noopLogger{},
+	}
+	ok := netLink.IsWireguardSupported()
 	if ok { // cannot assert since this depends on kernel
 		t.Log("wireguard is supported")
 	} else {