exec gofmt on the code & fix some problems for test

Author: NNdroid

.github/workflows/test.yml

@@ -129,7 +129,7 @@ jobs:
           ./librespeed-cli --local-json config_librespeed.json --server 2 --json --share --telemetry-level disabled | python3 -m json.tool
 
           ping 10.66.0.2 -w 20 -c 10
-          ping6 fd00:66:0::2 -w 20 -c 10 || true
+          ping6 fd00:66:0::2 -w 20 -c 10
           # TODO: remove this temporal hack for linux
           ping awl-tester.awl -w 20 -c 10 || true
 
@@ -232,6 +232,7 @@ jobs:
           ./librespeed-cli --local-json config_librespeed.json --server 2 --json --share --telemetry-level disabled | python3 -m json.tool
 
           ping 10.66.0.2 -c 10
+          ping6 fd00:66:0::2 -c 10
           ping awl-tester.awl -c 10
 
           sleep 1
@@ -252,6 +253,7 @@ jobs:
           ./librespeed-cli.exe --local-json config_librespeed.json --server 2 --json --share --telemetry-level disabled | python3 -m json.tool
 
           ping -w 20000 -n 10 10.66.0.2
+          ping -6 -w 20000 -n 10 fd00:66:0::2
           ping -w 20000 -n 10 -a awl-tester.awl
 
           # ---- VPN gateway server (exit-node) mode: runtime enable/disable round-trips OS state ----

application_test.go

@@ -795,51 +795,6 @@ func TestUpdatePeerSettingsIPAddr(t *testing.T) {
 		ts.NoError(err)
 	})
 
-	t.Run("IPv6TunnelPackets", func(t *testing.T) {
-		const packetSize = 1500
-		const packetsCount = 10
-
-		peer2Config, err := peer1.api.KnownPeerConfig(peer2.PeerID())
-		ts.NoError(err)
-		
-		peer2IPv4 := net.ParseIP(peer2Config.IPAddr).To4()
-		ts.NotNil(peer2IPv4)
-		
-		awlSubnet4, err := netip.ParsePrefix(peer1.app.Conf.VPNConfig.IPNet)
-		ts.NoError(err)
-		awlSubnet6, err := netip.ParsePrefix(peer1.app.Conf.VPNConfig.IPNetV6)
-		ts.NoError(err)
-		
-		// Map IPv4 to IPv6 using the same logic as peerIPv6FromIPv4
-		peer2IPv6 := make(net.IP, net.IPv6len)
-		copy(peer2IPv6, awlSubnet6.Addr().AsSlice())
-		v4Mask := net.CIDRMask(awlSubnet4.Bits(), 32)
-		for i := 0; i < net.IPv4len; i++ {
-			peer2IPv6[12+i] |= peer2IPv4[i] &^ v4Mask[i]
-		}
-
-		// Configure tunnel for packet testing
-		peer1.tun.SetInboundCapture(packetSize, nil)
-		peer2.tun.SetInboundCapture(packetSize, nil)
-		peer1.tun.ClearInboundCount()
-		peer2.tun.ClearInboundCount()
-
-		// Wait for IP map to be ready
-		time.Sleep(100 * time.Millisecond)
-
-		// Send IPv6 packets from peer1 to peer2
-		packet := testPacketWithDestV6(packetSize, peer2IPv6.String())
-		for i := 0; i < packetsCount; i++ {
-			peer1.tun.Outbound <- [][]byte{packet}
-		}
-
-		// Wait for packet processing
-		time.Sleep(500 * time.Millisecond)
-
-		// Verify packet reception
-		received := peer2.tun.InboundCount()
-		ts.EqualValues(packetsCount, received)
-	})
 }
 
 func TestDisableVPNInterface(t *testing.T) {
@@ -980,6 +935,50 @@ func TestTunnelPackets(t *testing.T) {
 	received2 := peer2.tun.InboundCount()
 	ts.EqualValues(packetsCount, received1)
 	ts.EqualValues(packetsCount, received2)
+
+	// --- IPv6 Routing Test ---
+	peer2ConfigInPeer1, _ := peer1.app.Conf.GetPeer(peer2.PeerID())
+	peer2IPv4 := net.ParseIP(peer2ConfigInPeer1.IPAddr).To4()
+
+	peer1ConfigInPeer2, _ := peer2.app.Conf.GetPeer(peer1.PeerID())
+	peer1IPv4 := net.ParseIP(peer1ConfigInPeer2.IPAddr).To4()
+
+	awlSubnet4, _ := netip.ParsePrefix(peer1.app.Conf.VPNConfig.IPNet)
+	awlSubnet6, _ := netip.ParsePrefix(peer1.app.Conf.VPNConfig.IPNetV6)
+	v4Mask := net.CIDRMask(awlSubnet4.Bits(), 32)
+	awlNet6 := &net.IPNet{IP: awlSubnet6.Addr().AsSlice(), Mask: net.CIDRMask(awlSubnet6.Bits(), 128)}
+	baseV6 := awlNet6.IP.Mask(awlNet6.Mask).To16()
+
+	peer1IPv6 := make(net.IP, net.IPv6len)
+	copy(peer1IPv6, baseV6)
+	for i := 0; i < net.IPv4len; i++ {
+		peer1IPv6[12+i] |= peer1IPv4[i] &^ v4Mask[i]
+	}
+
+	peer2IPv6 := make(net.IP, net.IPv6len)
+	copy(peer2IPv6, baseV6)
+	for i := 0; i < net.IPv4len; i++ {
+		peer2IPv6[12+i] |= peer2IPv4[i] &^ v4Mask[i]
+	}
+
+	ts.t.Logf("DEBUG: peer1 IPNetV6: %v", peer1.app.Conf.VPNConfig.IPNetV6)
+	ts.t.Logf("DEBUG: peer1IPv6 calculated: %s, peer2IPv6 calculated: %s", peer1IPv6.String(), peer2IPv6.String())
+
+	peer1.tun.ClearInboundCount()
+	peer2.tun.ClearInboundCount()
+
+	// Send IPv6 packets from peer1 to peer2
+	const ipv6PacketsCount = 10
+	ipv6Packet := testPacketWithSrcDestV6(packetSize, peer1IPv6.String(), peer2IPv6.String())
+
+	for i := 0; i < ipv6PacketsCount; i++ {
+		peer1.tun.Outbound <- [][]byte{ipv6Packet}
+		time.Sleep(10 * time.Millisecond)
+	}
+
+	time.Sleep(1 * time.Second)
+	receivedIPv6 := peer2.tun.InboundCount()
+	ts.EqualValues(ipv6PacketsCount, receivedIPv6, "peer2 should receive exactly %d IPv6 packets", ipv6PacketsCount)
 }
 
 func BenchmarkTunnelPackets(b *testing.B) {

service/tunnel.go

@@ -6,15 +6,13 @@ import (
 	"fmt"
 	"io"
 	"net"
-	"strings"
 	"sync"
 	"sync/atomic"
 	"time"
 
 	"github.com/ipfs/go-log/v2"
 	"github.com/libp2p/go-libp2p/core/network"
 	"github.com/libp2p/go-libp2p/core/peer"
-	"go.uber.org/zap"
 
 	"github.com/anywherelan/awl/awlevent"
 	"github.com/anywherelan/awl/config"
@@ -34,7 +32,7 @@ type Tunnel struct {
 	device *vpn.Device
 	logger *log.ZapEventLogger
 
-	isClosed atomic.Bool
+	isClosed     atomic.Bool
 	peersLock    sync.RWMutex
 	peerIDToPeer map[peer.ID]*VpnPeer
 	// netIPToPeer maps both IPv4 and IPv6 string representations to a VpnPeer.
@@ -821,7 +819,7 @@ func readBatchFromChan(ch chan *vpn.Packet, buf []*vpn.Packet, offset int) []*vp
 // peerIPv6FromIPv4 derives a peer's IPv6 address from their IPv4 address
 // by taking the host portion of the IPv4 address (unmasked by the IPv4 subnet)
 // and mapping it into the custom IPv6 subnet.
-// Returns nil if subnets are invalid, if peerIPv4 is out of bounds, 
+// Returns nil if subnets are invalid, if peerIPv4 is out of bounds,
 // or if the IPv6 subnet capacity is smaller than the IPv4 subnet capacity.
 func peerIPv6FromIPv4(peerIPv4 net.IP, awlSubnet4 *net.IPNet, awlSubnet6 *net.IPNet) net.IP {
 	if awlSubnet4 == nil || awlSubnet6 == nil {
@@ -839,7 +837,7 @@ func peerIPv6FromIPv4(peerIPv4 net.IP, awlSubnet4 *net.IPNet, awlSubnet6 *net.IP
 		return nil
 	}
 
-	// Capacity check: If IPv4 host bits exceed IPv6 host bits, 
+	// Capacity check: If IPv4 host bits exceed IPv6 host bits,
 	// the IPv6 subnet cannot accommodate all addresses of the IPv4 subnet.
 	v4HostBits := 32 - v4MaskLen
 	v6HostBits := 128 - v6MaskLen
@@ -866,7 +864,7 @@ func peerIPv6FromIPv4(peerIPv4 net.IP, awlSubnet4 *net.IPNet, awlSubnet6 *net.IP
 	}
 
 	// Align and embed the IPv4 host offset into the tail of the IPv6 address.
-	// Since capacity is already verified (v4HostBits <= v6HostBits), 
+	// Since capacity is already verified (v4HostBits <= v6HostBits),
 	// the IPv4 bytes safely fit into the trailing bytes of the IPv6 address.
 	addr := make(net.IP, net.IPv6len)
 	copy(addr, baseV6)
@@ -878,16 +876,3 @@ func peerIPv6FromIPv4(peerIPv4 net.IP, awlSubnet4 *net.IPNet, awlSubnet6 *net.IP
 
 	return addr
 }
-
-func (t *Tunnel) logRoutingTable() {
-	if !t.logger.Desugar().Core().Enabled(zap.DebugLevel) {
-		return
-	}
-	// The caller HandleReadPackets already holds the RLock, so we don't need to take it again.
-	routes := make([]string, 0, len(t.netIPToPeer))
-	for ip, peer := range t.netIPToPeer {
-		routes = append(routes, fmt.Sprintf("  %s -> %s", ip, peer.peerID))
-	}
-	// Use a single log call to avoid interleaving
-	t.logger.Debug("Dumping IPv4/IPv6 routing table:\n" + strings.Join(routes, "\n"))
-}

service/tunnel_test.go

@@ -46,9 +46,9 @@ func TestPeerIPv6FromIPv4(t *testing.T) {
 		{
 			name:       "capacity mismatch v4 host bits > v6 host bits",
 			peerIPv4:   "10.66.0.5",
-			awlSubnet4: "10.66.0.0/16", // 16 host bits
+			awlSubnet4: "10.66.0.0/16",  // 16 host bits
 			awlSubnet6: "fd00:66::/120", // 8 host bits
-			expected:   "", // expected nil
+			expected:   "",              // expected nil
 		},
 		{
 			name:       "invalid mask lengths (v4)",

test_suite_test.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"context"
 	"crypto/rand"
+	"encoding/binary"
 	"encoding/hex"
 	"errors"
 	"fmt"
@@ -549,8 +550,8 @@ func testPacket(length int) []byte {
 	return testPacketWithDest(length, "10.66.0.2")
 }
 
-func testPacketWithSrcDest(length int, srcIP, destIP string) []byte {
-	data, err := hex.DecodeString("4500002828f540004011fd490a4200010a420002a9d0238200148bfd68656c6c6f20776f726c6421")
+func buildPacketFromHex(length int, srcIP, destIP net.IP, hexStr string) []byte {
+	data, err := hex.DecodeString(hexStr)
 	if err != nil {
 		panic(err)
 	}
@@ -572,69 +573,57 @@ func testPacketWithSrcDest(length int, srcIP, destIP string) []byte {
 	}
 	vpnPacket.Parse()
 
+	if srcIP != nil {
+		copy(vpnPacket.Src, srcIP)
+	}
+	if destIP != nil {
+		copy(vpnPacket.Dst, destIP)
+	}
+
+	vpnPacket.RecalculateChecksum()
+
+	return vpnPacket.Packet
+}
+
+func testPacketWithSrcDest(length int, srcIP, destIP string) []byte {
 	srcIPParsed := net.ParseIP(srcIP).To4()
 	if srcIPParsed == nil {
 		panic(fmt.Sprintf("invalid source IP: %s", srcIP))
 	}
-	copy(vpnPacket.Src, srcIPParsed)
-
 	destIPParsed := net.ParseIP(destIP).To4()
 	if destIPParsed == nil {
 		panic(fmt.Sprintf("invalid destination IP: %s", destIP))
 	}
-	copy(vpnPacket.Dst, destIPParsed)
-
-	vpnPacket.RecalculateChecksum()
-
-	return vpnPacket.Packet
+	return buildPacketFromHex(length, srcIPParsed, destIPParsed, "4500002828f540004011fd490a4200010a420002a9d0238200148bfd68656c6c6f20776f726c6421")
 }
 
 func testPacketWithDest(length int, destIP string) []byte {
 	return testPacketWithSrcDest(length, "10.66.0.1", destIP)
 }
 
 func testPacketWithSrcDestV6(length int, srcIP, destIP string) []byte {
-	data, err := hex.DecodeString("6000000000141140fd000000000000000000000000000001fd00000000000000000000000000000204d2162e0014000068656c6c6f20776f726c6421")
-	if err != nil {
-		panic(err)
-	}
-
-	packet := data
-	if length > len(data) {
-		packet = make([]byte, length)
-		copy(packet, data)
-		_, err = rand.Read(packet[len(data):])
-		if err != nil {
-			panic(err)
-		}
-	}
-
-	vpnPacket := vpn.Packet{}
-	_, err = vpnPacket.ReadFrom(bytes.NewReader(packet))
-	if err != nil {
-		panic(err)
-	}
-	vpnPacket.Parse()
-
 	srcIPParsed := net.ParseIP(srcIP).To16()
 	if srcIPParsed == nil {
 		panic(fmt.Sprintf("invalid source IPv6: %s", srcIP))
 	}
-	copy(vpnPacket.Src, srcIPParsed)
-
 	destIPParsed := net.ParseIP(destIP).To16()
 	if destIPParsed == nil {
 		panic(fmt.Sprintf("invalid destination IPv6: %s", destIP))
 	}
-	copy(vpnPacket.Dst, destIPParsed)
-
-	vpnPacket.RecalculateChecksum()
-
-	return vpnPacket.Packet
-}
-
-func testPacketWithDestV6(length int, destIP string) []byte {
-	return testPacketWithSrcDestV6(length, "fd00:66:0::1", destIP)
+	packet := buildPacketFromHex(length, srcIPParsed, destIPParsed, "6000000000141140fd000000000000000000000000000001fd00000000000000000000000000000204d2162e0014000068656c6c6f20776f726c6421")
+	if length > 40 {
+		payloadLen := uint16(length - 40)
+		binary.BigEndian.PutUint16(packet[4:], payloadLen)
+		binary.BigEndian.PutUint16(packet[44:], payloadLen)
+
+		// Recalculate checksum after modifying lengths
+		vpnPacket := vpn.Packet{}
+		vpnPacket.Packet = packet
+		if vpnPacket.Parse() {
+			vpnPacket.RecalculateChecksum()
+		}
+	}
+	return packet
 }
 
 // parsePacketIPs extracts src and dst IPs from a raw IPv4 packet.

vpn/netstate/nat_linux.go

@@ -208,7 +208,7 @@ func setupIptables6(ipt6 *iptables.IPTables, state *natState) error {
 			return fmt.Errorf("add IPv6 DROP rule for %s to %s: %w", priv, awlForwardChain6, err)
 		}
 	}
-	
+
 	if err := ipt6.Append("filter", awlForwardChain6, "-j", "ACCEPT"); err != nil {
 		return fmt.Errorf("add ACCEPT rule to %s: %w", awlForwardChain6, err)
 	}

vpn/netstate/private_subnets.go

@@ -62,4 +62,4 @@ func parsePrefixList(subnets []string, name string) []netip.Prefix {
 		prefixes = append(prefixes, p)
 	}
 	return prefixes
-}
+}

vpn/netstate/routes_linux.go

@@ -5,9 +5,9 @@ package netstate
 import (
 	"errors"
 	"fmt"
+	"golang.org/x/sys/unix"
 	"net"
 	"syscall"
-	"golang.org/x/sys/unix"
 
 	"github.com/vishvananda/netlink"
 )

vpn/packet.go

@@ -12,8 +12,8 @@ import (
 )
 
 const (
-	IPProtocolTCP   = 6
-	IPProtocolUDP   = 17
+	IPProtocolTCP    = 6
+	IPProtocolUDP    = 17
 	IPProtocolICMPv6 = 58
 
 	ipv4offsetChecksum = 10
@@ -278,7 +278,6 @@ func checksumIPv6TCPUDP(headerAndPayload []byte, protocol uint32, srcIP net.IP,
 	return tcpipChecksum(headerAndPayload, csum)
 }
 
-
 // Calculate the TCP/IP checksum defined in rfc1071. The passed-in csum is any
 // initial checksum data that's already been computed.
 // Borrowed from google/gopacket

vpn/packet_test.go

@@ -28,7 +28,7 @@ func TestPacket_RecalculateChecksum_IPv6(t *testing.T) {
 	packet.RecalculateChecksum()
 	// Just verify it doesn't crash and actually modifies the checksum if it was 0000
 	a.NotEqual(rawData, packet.Packet)
-	
+
 	// Test idempotency
 	firstRecalculate := append([]byte(nil), packet.Packet...)
 	packet.RecalculateChecksum()