Refactor modules

Former-commit-id: 20b3331fff

olm/interface.go

@@ -1,167 +0,0 @@
-package olm
-
-import (
-	"fmt"
-	"net"
-	"os/exec"
-	"regexp"
-	"runtime"
-	"strconv"
-	"time"
-
-	"github.com/fosrl/newt/logger"
-	"github.com/fosrl/olm/network"
-	"github.com/vishvananda/netlink"
-)
-
-// ConfigureInterface configures a network interface with an IP address and brings it up
-func ConfigureInterface(interfaceName string, wgData WgData, mtu int) error {
-	logger.Info("The tunnel IP is: %s", wgData.TunnelIP)
-
-	// Parse the IP address and network
-	ip, ipNet, err := net.ParseCIDR(wgData.TunnelIP)
-	if err != nil {
-		return fmt.Errorf("invalid IP address: %v", err)
-	}
-
-	// Convert CIDR mask to dotted decimal format (e.g., 255.255.255.0)
-	mask := net.IP(ipNet.Mask).String()
-	destinationAddress := ip.String()
-
-	logger.Debug("The destination address is: %s", destinationAddress)
-
-	// network.SetTunnelRemoteAddress() // what does this do?
-	network.SetIPv4Settings([]string{destinationAddress}, []string{mask})
-	network.SetMTU(mtu)
-	apiServer.SetTunnelIP(destinationAddress)
-
-	if interfaceName == "" {
-		return nil
-	}
-
-	switch runtime.GOOS {
-	case "linux":
-		return configureLinux(interfaceName, ip, ipNet)
-	case "darwin":
-		return configureDarwin(interfaceName, ip, ipNet)
-	case "windows":
-		return configureWindows(interfaceName, ip, ipNet)
-	default:
-		return fmt.Errorf("unsupported operating system: %s", runtime.GOOS)
-	}
-}
-
-// waitForInterfaceUp polls the network interface until it's up or times out
-func waitForInterfaceUp(interfaceName string, expectedIP net.IP, timeout time.Duration) error {
-	logger.Info("Waiting for interface %s to be up with IP %s", interfaceName, expectedIP)
-	deadline := time.Now().Add(timeout)
-	pollInterval := 500 * time.Millisecond
-
-	for time.Now().Before(deadline) {
-		// Check if interface exists and is up
-		iface, err := net.InterfaceByName(interfaceName)
-		if err == nil {
-			// Check if interface is up
-			if iface.Flags&net.FlagUp != 0 {
-				// Check if it has the expected IP
-				addrs, err := iface.Addrs()
-				if err == nil {
-					for _, addr := range addrs {
-						ipNet, ok := addr.(*net.IPNet)
-						if ok && ipNet.IP.Equal(expectedIP) {
-							logger.Info("Interface %s is up with correct IP", interfaceName)
-							return nil // Interface is up with correct IP
-						}
-					}
-					logger.Info("Interface %s is up but doesn't have expected IP yet", interfaceName)
-				}
-			} else {
-				logger.Info("Interface %s exists but is not up yet", interfaceName)
-			}
-		} else {
-			logger.Info("Interface %s not found yet: %v", interfaceName, err)
-		}
-
-		// Wait before next check
-		time.Sleep(pollInterval)
-	}
-
-	return fmt.Errorf("timed out waiting for interface %s to be up with IP %s", interfaceName, expectedIP)
-}
-
-func findUnusedUTUN() (string, error) {
-	ifaces, err := net.Interfaces()
-	if err != nil {
-		return "", fmt.Errorf("failed to list interfaces: %v", err)
-	}
-	used := make(map[int]bool)
-	re := regexp.MustCompile(`^utun(\d+)$`)
-	for _, iface := range ifaces {
-		if matches := re.FindStringSubmatch(iface.Name); len(matches) == 2 {
-			if num, err := strconv.Atoi(matches[1]); err == nil {
-				used[num] = true
-			}
-		}
-	}
-	// Try utun0 up to utun255.
-	for i := 0; i < 256; i++ {
-		if !used[i] {
-			return fmt.Sprintf("utun%d", i), nil
-		}
-	}
-	return "", fmt.Errorf("no unused utun interface found")
-}
-
-func configureDarwin(interfaceName string, ip net.IP, ipNet *net.IPNet) error {
-	logger.Info("Configuring darwin interface: %s", interfaceName)
-
-	prefix, _ := ipNet.Mask.Size()
-	ipStr := fmt.Sprintf("%s/%d", ip.String(), prefix)
-
-	cmd := exec.Command("ifconfig", interfaceName, "inet", ipStr, ip.String(), "alias")
-	logger.Info("Running command: %v", cmd)
-
-	out, err := cmd.CombinedOutput()
-	if err != nil {
-		return fmt.Errorf("ifconfig command failed: %v, output: %s", err, out)
-	}
-
-	// Bring up the interface
-	cmd = exec.Command("ifconfig", interfaceName, "up")
-	logger.Info("Running command: %v", cmd)
-
-	out, err = cmd.CombinedOutput()
-	if err != nil {
-		return fmt.Errorf("ifconfig up command failed: %v, output: %s", err, out)
-	}
-
-	return nil
-}
-
-func configureLinux(interfaceName string, ip net.IP, ipNet *net.IPNet) error {
-	// Get the interface
-	link, err := netlink.LinkByName(interfaceName)
-	if err != nil {
-		return fmt.Errorf("failed to get interface %s: %v", interfaceName, err)
-	}
-
-	// Create the IP address attributes
-	addr := &netlink.Addr{
-		IPNet: &net.IPNet{
-			IP:   ip,
-			Mask: ipNet.Mask,
-		},
-	}
-
-	// Add the IP address to the interface
-	if err := netlink.AddrAdd(link, addr); err != nil {
-		return fmt.Errorf("failed to add IP address: %v", err)
-	}
-
-	// Bring up the interface
-	if err := netlink.LinkSetUp(link); err != nil {
-		return fmt.Errorf("failed to bring up interface: %v", err)
-	}
-
-	return nil
-}

olm/interface_notwindows.go

@@ -1,12 +0,0 @@
-//go:build !windows
-
-package olm
-
-import (
-	"fmt"
-	"net"
-)
-
-func configureWindows(interfaceName string, ip net.IP, ipNet *net.IPNet) error {
-	return fmt.Errorf("configureWindows called on non-Windows platform")
-}

olm/interface_windows.go

@@ -1,63 +0,0 @@
-//go:build windows
-
-package olm
-
-import (
-	"fmt"
-	"net"
-	"net/netip"
-
-	"github.com/fosrl/newt/logger"
-	"golang.zx2c4.com/wireguard/windows/tunnel/winipcfg"
-)
-
-func configureWindows(interfaceName string, ip net.IP, ipNet *net.IPNet) error {
-	logger.Info("Configuring Windows interface: %s", interfaceName)
-
-	// Get the LUID for the interface
-	iface, err := net.InterfaceByName(interfaceName)
-	if err != nil {
-		return fmt.Errorf("failed to get interface %s: %v", interfaceName, err)
-	}
-
-	luid, err := winipcfg.LUIDFromIndex(uint32(iface.Index))
-	if err != nil {
-		return fmt.Errorf("failed to get LUID for interface %s: %v", interfaceName, err)
-	}
-
-	// Create the IP address prefix
-	maskBits, _ := ipNet.Mask.Size()
-
-	// Ensure we convert to the correct IP version (IPv4 vs IPv6)
-	var addr netip.Addr
-	if ip4 := ip.To4(); ip4 != nil {
-		// IPv4 address
-		addr, _ = netip.AddrFromSlice(ip4)
-	} else {
-		// IPv6 address
-		addr, _ = netip.AddrFromSlice(ip)
-	}
-	if !addr.IsValid() {
-		return fmt.Errorf("failed to convert IP address")
-	}
-	prefix := netip.PrefixFrom(addr, maskBits)
-
-	// Add the IP address to the interface
-	logger.Info("Adding IP address %s to interface %s", prefix.String(), interfaceName)
-	err = luid.AddIPAddress(prefix)
-	if err != nil {
-		return fmt.Errorf("failed to add IP address: %v", err)
-	}
-
-	// This was required when we were using the subprocess "netsh" command to bring up the interface.
-	// With the winipcfg library, the interface should already be up after adding the IP so we dont
-	// need this step anymore as far as I can tell.
-
-	// // Wait for the interface to be up and have the correct IP
-	// err = waitForInterfaceUp(interfaceName, ip, 30*time.Second)
-	// if err != nil {
-	// 	return fmt.Errorf("interface did not come up within timeout: %v", err)
-	// }
-
-	return nil
-}

olm/olm.go

@@ -14,7 +14,7 @@ import (
 	"github.com/fosrl/newt/logger"
 	"github.com/fosrl/newt/util"
 	"github.com/fosrl/olm/api"
-	middleDevice "github.com/fosrl/olm/device"
+	olmDevice "github.com/fosrl/olm/device"
 	"github.com/fosrl/olm/dns"
 	dnsOverride "github.com/fosrl/olm/dns/override"
 	"github.com/fosrl/olm/network"
@@ -79,7 +79,7 @@ var (
 	holePunchData    HolePunchData
 	uapiListener     net.Listener
 	tdev             tun.Device
-	middleDev        *middleDevice.MiddleDevice
+	middleDev        *olmDevice.MiddleDevice
 	dnsProxy         *dns.DNSProxy
 	apiServer        *api.API
 	olmClient        *websocket.Client
@@ -201,7 +201,6 @@ func Init(ctx context.Context, config GlobalConfig) {
 
 			// Clear peer statuses in API
 			apiServer.SetRegistered(false)
-			apiServer.SetTunnelIP("")
 
 			// Trigger re-registration with new orgId
 			logger.Info("Re-registering with new orgId: %s", req.OrgID)
@@ -418,11 +417,11 @@ func StartTunnel(config TunnelConfig) {
 
 		tdev, err = func() (tun.Device, error) {
 			if config.FileDescriptorTun != 0 {
-				return createTUNFromFD(config.FileDescriptorTun, config.MTU)
+				return olmDevice.CreateTUNFromFD(config.FileDescriptorTun, config.MTU)
 			}
 			var ifName = interfaceName
 			if runtime.GOOS == "darwin" { // this is if we dont pass a fd
-				ifName, err = findUnusedUTUN()
+				ifName, err = network.FindUnusedUTUN()
 				if err != nil {
 					return nil, err
 				}
@@ -458,7 +457,7 @@ func StartTunnel(config TunnelConfig) {
 		// }
 
 		// Wrap TUN device with packet filter for DNS proxy
-		middleDev = middleDevice.NewMiddleDevice(tdev)
+		middleDev = olmDevice.NewMiddleDevice(tdev)
 
 		wgLogger := logger.GetLogger().GetWireGuardLogger("wireguard: ")
 		// Use filtered device instead of raw TUN device
@@ -495,11 +494,11 @@ func StartTunnel(config TunnelConfig) {
 			logger.Error("Failed to create DNS proxy: %v", err)
 		}
 
-		if err = ConfigureInterface(interfaceName, wgData, config.MTU); err != nil {
+		if err = network.ConfigureInterface(interfaceName, wgData.TunnelIP, config.MTU); err != nil {
 			logger.Error("Failed to configure interface: %v", err)
 		}
 
-		if addRoutes([]string{wgData.UtilitySubnet}, interfaceName); err != nil { // also route the utility subnet
+		if network.AddRoutes([]string{wgData.UtilitySubnet}, interfaceName); err != nil { // also route the utility subnet
 			logger.Error("Failed to add route for utility subnet: %v", err)
 		}
 
@@ -549,11 +548,11 @@ func StartTunnel(config TunnelConfig) {
 				logger.Error("Failed to configure peer: %v", err)
 				return
 			}
-			if err := addRouteForServerIP(site.ServerIP, interfaceName); err != nil { // this is something for darwin only thats required
+			if err := network.AddRouteForServerIP(site.ServerIP, interfaceName); err != nil { // this is something for darwin only thats required
 				logger.Error("Failed to add route for peer: %v", err)
 				return
 			}
-			if err := addRoutes(site.RemoteSubnets, interfaceName); err != nil {
+			if err := network.AddRoutes(site.RemoteSubnets, interfaceName); err != nil {
 				logger.Error("Failed to add routes for remote subnets: %v", err)
 				return
 			}
@@ -676,13 +675,13 @@ func StartTunnel(config TunnelConfig) {
 
 		// Handle remote subnet route changes
 		if !stringSlicesEqual(oldRemoteSubnets, siteConfig.RemoteSubnets) {
-			if err := removeRoutesForRemoteSubnets(oldRemoteSubnets); err != nil {
+			if err := network.RemoveRoutesForRemoteSubnets(oldRemoteSubnets); err != nil {
 				logger.Error("Failed to remove old remote subnet routes: %v", err)
 				// Continue anyway to add new routes
 			}
 
 			// Add new remote subnet routes
-			if err := addRoutes(siteConfig.RemoteSubnets, interfaceName); err != nil {
+			if err := network.AddRoutes(siteConfig.RemoteSubnets, interfaceName); err != nil {
 				logger.Error("Failed to add new remote subnet routes: %v", err)
 				return
 			}
@@ -721,11 +720,11 @@ func StartTunnel(config TunnelConfig) {
 			logger.Error("Failed to add peer: %v", err)
 			return
 		}
-		if err := addRouteForServerIP(siteConfig.ServerIP, interfaceName); err != nil {
+		if err := network.AddRouteForServerIP(siteConfig.ServerIP, interfaceName); err != nil {
 			logger.Error("Failed to add route for new peer: %v", err)
 			return
 		}
-		if err := addRoutes(siteConfig.RemoteSubnets, interfaceName); err != nil {
+		if err := network.AddRoutes(siteConfig.RemoteSubnets, interfaceName); err != nil {
 			logger.Error("Failed to add routes for remote subnets: %v", err)
 			return
 		}
@@ -782,14 +781,14 @@ func StartTunnel(config TunnelConfig) {
 		}
 
 		// Remove route for the peer
-		err = removeRouteForServerIP(peerToRemove.ServerIP, interfaceName)
+		err = network.RemoveRouteForServerIP(peerToRemove.ServerIP, interfaceName)
 		if err != nil {
 			logger.Error("Failed to remove route for peer: %v", err)
 			return
 		}
 
 		// Remove routes for remote subnets
-		if err := removeRoutesForRemoteSubnets(peerToRemove.RemoteSubnets); err != nil {
+		if err := network.RemoveRoutesForRemoteSubnets(peerToRemove.RemoteSubnets); err != nil {
 			logger.Error("Failed to remove routes for remote subnets: %v", err)
 			return
 		}
@@ -851,7 +850,7 @@ func StartTunnel(config TunnelConfig) {
 		}
 
 		// Add routes for the new subnets
-		if err := addRoutes(newSubnets, interfaceName); err != nil {
+		if err := network.AddRoutes(newSubnets, interfaceName); err != nil {
 			logger.Error("Failed to add routes for new remote subnets: %v", err)
 			return
 		}
@@ -912,7 +911,7 @@ func StartTunnel(config TunnelConfig) {
 		}
 
 		// Remove routes for the removed subnets
-		if err := removeRoutesForRemoteSubnets(removedSubnets); err != nil {
+		if err := network.RemoveRoutesForRemoteSubnets(removedSubnets); err != nil {
 			logger.Error("Failed to remove routes for remote subnets: %v", err)
 			return
 		}
@@ -955,7 +954,7 @@ func StartTunnel(config TunnelConfig) {
 
 		// First, remove routes for old subnets
 		if len(updateSubnetsData.OldRemoteSubnets) > 0 {
-			if err := removeRoutesForRemoteSubnets(updateSubnetsData.OldRemoteSubnets); err != nil {
+			if err := network.RemoveRoutesForRemoteSubnets(updateSubnetsData.OldRemoteSubnets); err != nil {
 				logger.Error("Failed to remove routes for old remote subnets: %v", err)
 				return
 			}
@@ -964,10 +963,10 @@ func StartTunnel(config TunnelConfig) {
 
 		// Then, add routes for new subnets
 		if len(updateSubnetsData.NewRemoteSubnets) > 0 {
-			if err := addRoutes(updateSubnetsData.NewRemoteSubnets, interfaceName); err != nil {
+			if err := network.AddRoutes(updateSubnetsData.NewRemoteSubnets, interfaceName); err != nil {
 				logger.Error("Failed to add routes for new remote subnets: %v", err)
 				// Attempt to rollback by re-adding old routes
-				if rollbackErr := addRoutes(updateSubnetsData.OldRemoteSubnets, interfaceName); rollbackErr != nil {
+				if rollbackErr := network.AddRoutes(updateSubnetsData.OldRemoteSubnets, interfaceName); rollbackErr != nil {
 					logger.Error("Failed to rollback old routes: %v", rollbackErr)
 				}
 				return
@@ -1186,7 +1185,6 @@ func StopTunnel() {
 	// Update API server status
 	apiServer.SetConnectionStatus(false)
 	apiServer.SetRegistered(false)
-	apiServer.SetTunnelIP("")
 
 	network.ClearNetworkSettings()
 

olm/route.go

@@ -1,283 +0,0 @@
-package olm
-
-import (
-	"fmt"
-	"net"
-	"os/exec"
-	"runtime"
-	"strings"
-
-	"github.com/fosrl/newt/logger"
-	"github.com/fosrl/olm/network"
-	"github.com/vishvananda/netlink"
-)
-
-func DarwinAddRoute(destination string, gateway string, interfaceName string) error {
-	if runtime.GOOS != "darwin" {
-		return nil
-	}
-
-	var cmd *exec.Cmd
-
-	if gateway != "" {
-		// Route with specific gateway
-		cmd = exec.Command("route", "-q", "-n", "add", "-inet", destination, "-gateway", gateway)
-	} else if interfaceName != "" {
-		// Route via interface
-		cmd = exec.Command("route", "-q", "-n", "add", "-inet", destination, "-interface", interfaceName)
-	} else {
-		return fmt.Errorf("either gateway or interface must be specified")
-	}
-
-	logger.Info("Running command: %v", cmd)
-
-	out, err := cmd.CombinedOutput()
-	if err != nil {
-		return fmt.Errorf("route command failed: %v, output: %s", err, out)
-	}
-
-	return nil
-}
-
-func DarwinRemoveRoute(destination string) error {
-	if runtime.GOOS != "darwin" {
-		return nil
-	}
-
-	cmd := exec.Command("route", "-q", "-n", "delete", "-inet", destination)
-	logger.Info("Running command: %v", cmd)
-
-	out, err := cmd.CombinedOutput()
-	if err != nil {
-		return fmt.Errorf("route delete command failed: %v, output: %s", err, out)
-	}
-
-	return nil
-}
-
-func LinuxAddRoute(destination string, gateway string, interfaceName string) error {
-	if runtime.GOOS != "linux" {
-		return nil
-	}
-
-	// Parse destination CIDR
-	_, ipNet, err := net.ParseCIDR(destination)
-	if err != nil {
-		return fmt.Errorf("invalid destination address: %v", err)
-	}
-
-	// Create route
-	route := &netlink.Route{
-		Dst: ipNet,
-	}
-
-	if gateway != "" {
-		// Route with specific gateway
-		gw := net.ParseIP(gateway)
-		if gw == nil {
-			return fmt.Errorf("invalid gateway address: %s", gateway)
-		}
-		route.Gw = gw
-		logger.Info("Adding route to %s via gateway %s", destination, gateway)
-	} else if interfaceName != "" {
-		// Route via interface
-		link, err := netlink.LinkByName(interfaceName)
-		if err != nil {
-			return fmt.Errorf("failed to get interface %s: %v", interfaceName, err)
-		}
-		route.LinkIndex = link.Attrs().Index
-		logger.Info("Adding route to %s via interface %s", destination, interfaceName)
-	} else {
-		return fmt.Errorf("either gateway or interface must be specified")
-	}
-
-	// Add the route
-	if err := netlink.RouteAdd(route); err != nil {
-		return fmt.Errorf("failed to add route: %v", err)
-	}
-
-	return nil
-}
-
-func LinuxRemoveRoute(destination string) error {
-	if runtime.GOOS != "linux" {
-		return nil
-	}
-
-	// Parse destination CIDR
-	_, ipNet, err := net.ParseCIDR(destination)
-	if err != nil {
-		return fmt.Errorf("invalid destination address: %v", err)
-	}
-
-	// Create route to delete
-	route := &netlink.Route{
-		Dst: ipNet,
-	}
-
-	logger.Info("Removing route to %s", destination)
-
-	// Delete the route
-	if err := netlink.RouteDel(route); err != nil {
-		return fmt.Errorf("failed to delete route: %v", err)
-	}
-
-	return nil
-}
-
-// addRouteForServerIP adds an OS-specific route for the server IP
-func addRouteForServerIP(serverIP, interfaceName string) error {
-	if err := addRouteForNetworkConfig(serverIP); err != nil {
-		return err
-	}
-	if interfaceName == "" {
-		return nil
-	}
-	if runtime.GOOS == "darwin" {
-		return DarwinAddRoute(serverIP, "", interfaceName)
-	}
-	// else if runtime.GOOS == "windows" {
-	//	return WindowsAddRoute(serverIP, "", interfaceName)
-	// } else if runtime.GOOS == "linux" {
-	//	return LinuxAddRoute(serverIP, "", interfaceName)
-	// }
-	return nil
-}
-
-// removeRouteForServerIP removes an OS-specific route for the server IP
-func removeRouteForServerIP(serverIP string, interfaceName string) error {
-	if err := removeRouteForNetworkConfig(serverIP); err != nil {
-		return err
-	}
-	if interfaceName == "" {
-		return nil
-	}
-	if runtime.GOOS == "darwin" {
-		return DarwinRemoveRoute(serverIP)
-	}
-	// else if runtime.GOOS == "windows" {
-	// 	return WindowsRemoveRoute(serverIP)
-	// } else if runtime.GOOS == "linux" {
-	// 	return LinuxRemoveRoute(serverIP)
-	// }
-	return nil
-}
-
-func addRouteForNetworkConfig(destination string) error {
-	// Parse the subnet to extract IP and mask
-	_, ipNet, err := net.ParseCIDR(destination)
-	if err != nil {
-		return fmt.Errorf("failed to parse subnet %s: %v", destination, err)
-	}
-
-	// Convert CIDR mask to dotted decimal format (e.g., 255.255.255.0)
-	mask := net.IP(ipNet.Mask).String()
-	destinationAddress := ipNet.IP.String()
-
-	network.AddIPv4IncludedRoute(network.IPv4Route{DestinationAddress: destinationAddress, SubnetMask: mask})
-
-	return nil
-}
-
-func removeRouteForNetworkConfig(destination string) error {
-	// Parse the subnet to extract IP and mask
-	_, ipNet, err := net.ParseCIDR(destination)
-	if err != nil {
-		return fmt.Errorf("failed to parse subnet %s: %v", destination, err)
-	}
-
-	// Convert CIDR mask to dotted decimal format (e.g., 255.255.255.0)
-	mask := net.IP(ipNet.Mask).String()
-	destinationAddress := ipNet.IP.String()
-
-	network.RemoveIPv4IncludedRoute(network.IPv4Route{DestinationAddress: destinationAddress, SubnetMask: mask})
-
-	return nil
-}
-
-// addRoutes adds routes for each subnet in RemoteSubnets
-func addRoutes(remoteSubnets []string, interfaceName string) error {
-	if len(remoteSubnets) == 0 {
-		return nil
-	}
-
-	// Add routes for each subnet
-	for _, subnet := range remoteSubnets {
-		subnet = strings.TrimSpace(subnet)
-		if subnet == "" {
-			continue
-		}
-
-		if err := addRouteForNetworkConfig(subnet); err != nil {
-			logger.Error("Failed to add network config for subnet %s: %v", subnet, err)
-			continue
-		}
-
-		// Add route based on operating system
-		if interfaceName == "" {
-			continue
-		}
-
-		if runtime.GOOS == "darwin" {
-			if err := DarwinAddRoute(subnet, "", interfaceName); err != nil {
-				logger.Error("Failed to add Darwin route for subnet %s: %v", subnet, err)
-				return err
-			}
-		} else if runtime.GOOS == "windows" {
-			if err := WindowsAddRoute(subnet, "", interfaceName); err != nil {
-				logger.Error("Failed to add Windows route for subnet %s: %v", subnet, err)
-				return err
-			}
-		} else if runtime.GOOS == "linux" {
-			if err := LinuxAddRoute(subnet, "", interfaceName); err != nil {
-				logger.Error("Failed to add Linux route for subnet %s: %v", subnet, err)
-				return err
-			}
-		}
-
-		logger.Info("Added route for remote subnet: %s", subnet)
-	}
-	return nil
-}
-
-// removeRoutesForRemoteSubnets removes routes for each subnet in RemoteSubnets
-func removeRoutesForRemoteSubnets(remoteSubnets []string) error {
-	if len(remoteSubnets) == 0 {
-		return nil
-	}
-
-	// Remove routes for each subnet
-	for _, subnet := range remoteSubnets {
-		subnet = strings.TrimSpace(subnet)
-		if subnet == "" {
-			continue
-		}
-
-		if err := removeRouteForNetworkConfig(subnet); err != nil {
-			logger.Error("Failed to remove network config for subnet %s: %v", subnet, err)
-			continue
-		}
-
-		// Remove route based on operating system
-		if runtime.GOOS == "darwin" {
-			if err := DarwinRemoveRoute(subnet); err != nil {
-				logger.Error("Failed to remove Darwin route for subnet %s: %v", subnet, err)
-				return err
-			}
-		} else if runtime.GOOS == "windows" {
-			if err := WindowsRemoveRoute(subnet); err != nil {
-				logger.Error("Failed to remove Windows route for subnet %s: %v", subnet, err)
-				return err
-			}
-		} else if runtime.GOOS == "linux" {
-			if err := LinuxRemoveRoute(subnet); err != nil {
-				logger.Error("Failed to remove Linux route for subnet %s: %v", subnet, err)
-				return err
-			}
-		}
-
-		logger.Info("Removed route for remote subnet: %s", subnet)
-	}
-
-	return nil
-}

olm/route_notwindows.go

@@ -1,11 +0,0 @@
-//go:build !windows
-
-package olm
-
-func WindowsAddRoute(destination string, gateway string, interfaceName string) error {
-	return nil
-}
-
-func WindowsRemoveRoute(destination string) error {
-	return nil
-}

olm/route_windows.go

@@ -1,148 +0,0 @@
-//go:build windows
-
-package olm
-
-import (
-	"fmt"
-	"net"
-	"net/netip"
-	"runtime"
-
-	"github.com/fosrl/newt/logger"
-	"golang.zx2c4.com/wireguard/windows/tunnel/winipcfg"
-)
-
-func WindowsAddRoute(destination string, gateway string, interfaceName string) error {
-	if runtime.GOOS != "windows" {
-		return nil
-	}
-
-	// Parse destination CIDR
-	_, ipNet, err := net.ParseCIDR(destination)
-	if err != nil {
-		return fmt.Errorf("invalid destination address: %v", err)
-	}
-
-	// Convert to netip.Prefix
-	maskBits, _ := ipNet.Mask.Size()
-
-	// Ensure we convert to the correct IP version (IPv4 vs IPv6)
-	var addr netip.Addr
-	if ip4 := ipNet.IP.To4(); ip4 != nil {
-		// IPv4 address
-		addr, _ = netip.AddrFromSlice(ip4)
-	} else {
-		// IPv6 address
-		addr, _ = netip.AddrFromSlice(ipNet.IP)
-	}
-	if !addr.IsValid() {
-		return fmt.Errorf("failed to convert destination IP")
-	}
-	prefix := netip.PrefixFrom(addr, maskBits)
-
-	var luid winipcfg.LUID
-	var nextHop netip.Addr
-
-	if interfaceName != "" {
-		// Get the interface LUID - needed for both gateway and interface-only routes
-		iface, err := net.InterfaceByName(interfaceName)
-		if err != nil {
-			return fmt.Errorf("failed to get interface %s: %v", interfaceName, err)
-		}
-
-		luid, err = winipcfg.LUIDFromIndex(uint32(iface.Index))
-		if err != nil {
-			return fmt.Errorf("failed to get LUID for interface %s: %v", interfaceName, err)
-		}
-	}
-
-	if gateway != "" {
-		// Route with specific gateway
-		gwIP := net.ParseIP(gateway)
-		if gwIP == nil {
-			return fmt.Errorf("invalid gateway address: %s", gateway)
-		}
-		// Convert to correct IP version
-		if ip4 := gwIP.To4(); ip4 != nil {
-			nextHop, _ = netip.AddrFromSlice(ip4)
-		} else {
-			nextHop, _ = netip.AddrFromSlice(gwIP)
-		}
-		if !nextHop.IsValid() {
-			return fmt.Errorf("failed to convert gateway IP")
-		}
-		logger.Info("Adding route to %s via gateway %s on interface %s", destination, gateway, interfaceName)
-	} else if interfaceName != "" {
-		// Route via interface only
-		if addr.Is4() {
-			nextHop = netip.IPv4Unspecified()
-		} else {
-			nextHop = netip.IPv6Unspecified()
-		}
-		logger.Info("Adding route to %s via interface %s", destination, interfaceName)
-	} else {
-		return fmt.Errorf("either gateway or interface must be specified")
-	}
-
-	// Add the route using winipcfg
-	err = luid.AddRoute(prefix, nextHop, 1)
-	if err != nil {
-		return fmt.Errorf("failed to add route: %v", err)
-	}
-
-	return nil
-}
-
-func WindowsRemoveRoute(destination string) error {
-	// Parse destination CIDR
-	_, ipNet, err := net.ParseCIDR(destination)
-	if err != nil {
-		return fmt.Errorf("invalid destination address: %v", err)
-	}
-
-	// Convert to netip.Prefix
-	maskBits, _ := ipNet.Mask.Size()
-
-	// Ensure we convert to the correct IP version (IPv4 vs IPv6)
-	var addr netip.Addr
-	if ip4 := ipNet.IP.To4(); ip4 != nil {
-		// IPv4 address
-		addr, _ = netip.AddrFromSlice(ip4)
-	} else {
-		// IPv6 address
-		addr, _ = netip.AddrFromSlice(ipNet.IP)
-	}
-	if !addr.IsValid() {
-		return fmt.Errorf("failed to convert destination IP")
-	}
-	prefix := netip.PrefixFrom(addr, maskBits)
-
-	// Get all routes and find the one to delete
-	// We need to get the LUID from the existing route
-	var family winipcfg.AddressFamily
-	if addr.Is4() {
-		family = 2 // AF_INET
-	} else {
-		family = 23 // AF_INET6
-	}
-
-	routes, err := winipcfg.GetIPForwardTable2(family)
-	if err != nil {
-		return fmt.Errorf("failed to get route table: %v", err)
-	}
-
-	// Find and delete matching route
-	for _, route := range routes {
-		routePrefix := route.DestinationPrefix.Prefix()
-		if routePrefix == prefix {
-			logger.Info("Removing route to %s", destination)
-			err = route.Delete()
-			if err != nil {
-				return fmt.Errorf("failed to delete route: %v", err)
-			}
-			return nil
-		}
-	}
-
-	return fmt.Errorf("route to %s not found", destination)
-}

olm/unix.go

@@ -1,44 +0,0 @@
-//go:build !windows
-
-package olm
-
-import (
-	"net"
-	"os"
-
-	"github.com/fosrl/newt/logger"
-	"golang.org/x/sys/unix"
-	"golang.zx2c4.com/wireguard/ipc"
-	"golang.zx2c4.com/wireguard/tun"
-)
-
-func createTUNFromFD(tunFd uint32, mtuInt int) (tun.Device, error) {
-	dupTunFd, err := unix.Dup(int(tunFd))
-	if err != nil {
-		logger.Error("Unable to dup tun fd: %v", err)
-		return nil, err
-	}
-
-	err = unix.SetNonblock(dupTunFd, true)
-	if err != nil {
-		unix.Close(dupTunFd)
-		return nil, err
-	}
-
-	file := os.NewFile(uintptr(dupTunFd), "/dev/tun")
-	device, err := tun.CreateTUNFromFile(file, mtuInt)
-	if err != nil {
-		file.Close()
-		return nil, err
-	}
-
-	return device, nil
-}
-
-func uapiOpen(interfaceName string) (*os.File, error) {
-	return ipc.UAPIOpen(interfaceName)
-}
-
-func uapiListen(interfaceName string, fileUAPI *os.File) (net.Listener, error) {
-	return ipc.UAPIListen(interfaceName, fileUAPI)
-}

olm/windows.go

@@ -1,25 +0,0 @@
-//go:build windows
-
-package olm
-
-import (
-	"errors"
-	"net"
-	"os"
-
-	"golang.zx2c4.com/wireguard/ipc"
-	"golang.zx2c4.com/wireguard/tun"
-)
-
-func createTUNFromFD(tunFd uint32, mtuInt int) (tun.Device, error) {
-	return nil, errors.New("CreateTUNFromFile not supported on Windows")
-}
-
-func uapiOpen(interfaceName string) (*os.File, error) {
-	return nil, nil
-}
-
-func uapiListen(interfaceName string, fileUAPI *os.File) (net.Listener, error) {
-	// On Windows, UAPIListen only takes one parameter
-	return ipc.UAPIListen(interfaceName)
-}