Hack around Wireguard

- Wireguard LinkTypeRaw is invalid, need to call .String() instead
- Reduce calls to log.Debug()
- Wireguard really is DLT_RAW (101).
- Compare LinkType() as a string, not int to work around Wireguard
    NIC bug which stores the DLT_NAME where DLT_VALUE should be
- Fix debug output which transposed interface names
- Improve debugging

Makefile

@@ -4,7 +4,7 @@ GOARCH ?= $(shell uname -m)
 BUILDINFOSDET ?=
 UDP_PROXY_2020_ARGS ?=
 
-PROJECT_VERSION    := 0.0.4
+PROJECT_VERSION    := 0.0.5
 DOCKER_REPO        := synfinatic
 PROJECT_NAME       := udp-proxy-2020
 PROJECT_TAG        := $(shell git describe --tags 2>/dev/null $(git rev-list --tags --max-count=1))

cmd/interfaces.go

@@ -46,7 +46,7 @@ func initializeInterface(l *Listen) {
 	}
 
 	if !isValidLayerType(l.handle.LinkType()) {
-		log.Fatalf("%s: has an invalid layer type: 0x%02x", l.iname, l.handle.LinkType())
+		log.Fatalf("%s: has an invalid layer type: %s", l.iname, l.handle.LinkType().String())
 	}
 
 	// set our BPF filter

cmd/listen.go

@@ -2,7 +2,9 @@ package main
 
 import (
 	"encoding/binary"
+	"encoding/hex"
 	"net"
+	"strings"
 	"sync"
 	"time"
 
@@ -142,17 +144,15 @@ func (l *Listen) sendPackets(sndpkt Send) {
 
 	log.Debugf("processing packet from %s on %s", sndpkt.srcif, l.iname)
 
-	switch sndpkt.linkType {
-	case layers.LinkTypeNull:
+	switch sndpkt.linkType.String() {
+	case layers.LinkTypeNull.String(), layers.LinkTypeLoop.String():
 		parser = gopacket.NewDecodingLayerParser(layers.LayerTypeLoopback, &loop, &ip4, &udp, &payload)
-	case layers.LinkTypeLoop:
-		parser = gopacket.NewDecodingLayerParser(layers.LayerTypeLoopback, &loop, &ip4, &udp, &payload)
-	case layers.LinkTypeEthernet:
+	case layers.LinkTypeEthernet.String():
 		parser = gopacket.NewDecodingLayerParser(layers.LayerTypeEthernet, &eth, &ip4, &udp, &payload)
-	case layers.LinkTypeRaw:
+	case layers.LinkTypeRaw.String():
 		parser = gopacket.NewDecodingLayerParser(layers.LayerTypeIPv4, &ip4, &udp, &payload)
 	default:
-		log.Fatalf("Unsupported source linktype: 0x%02x", sndpkt.linkType)
+		log.Fatalf("Unsupported source linktype: %s", sndpkt.linkType.String())
 	}
 
 	// try decoding our packet
@@ -187,6 +187,9 @@ func (l *Listen) sendPackets(sndpkt Send) {
 		}
 	} else {
 		// sent packet to every client
+		if len(l.clients) == 0 {
+			log.Debugf("%s: Unable to send packet; no discovered clients", l.iname)
+		}
 		for ip, _ := range l.clients {
 			dstip := net.ParseIP(ip).To4()
 			if err, bytes := l.sendPacket(dstip, eth, loop, ip4, udp, payload); err != nil {
@@ -250,17 +253,15 @@ func (l *Listen) sendPacket(dstip net.IP, eth layers.Ethernet, loop layers.Loopb
 	}
 
 	// Add our L2 header to the buffer
-	switch l.handle.LinkType() {
-	case layers.LinkTypeNull, layers.LinkTypeLoop:
+	switch l.handle.LinkType().String() {
+	case layers.LinkTypeNull.String(), layers.LinkTypeLoop.String():
 		loop := layers.Loopback{
 			Family: layers.ProtocolFamilyIPv4,
 		}
 		if err := loop.SerializeTo(buffer, opts); err != nil {
 			log.Fatalf("can't serialize Loop header: %v", loop)
 		}
-	case layers.LinkTypeRaw:
-		// nothing
-	case layers.LinkTypeEthernet:
+	case layers.LinkTypeEthernet.String():
 		// build a new ethernet header
 		new_eth := layers.Ethernet{
 			BaseLayer:    layers.BaseLayer{},
@@ -271,10 +272,15 @@ func (l *Listen) sendPacket(dstip net.IP, eth layers.Ethernet, loop layers.Loopb
 		if err := new_eth.SerializeTo(buffer, opts); err != nil {
 			log.Fatalf("can't serialize Eth header: %v", new_eth)
 		}
+	case layers.LinkTypeRaw.String():
+		// no L2 header
+	default:
+		log.Warnf("Unsupported linktype: %s", l.handle.LinkType().String())
 	}
 
 	outgoingPacket := buffer.Bytes()
-	log.Debugf("%s => %s: packet len: %d: %v", l.iname, dstip.String(), len(outgoingPacket), outgoingPacket)
+	log.Debugf("%s => %s: packet len: %d: %s",
+		l.iname, dstip.String(), len(outgoingPacket), hex.EncodeToString(outgoingPacket))
 	return l.handle.WritePacketData(outgoingPacket), len(outgoingPacket)
 }
 
@@ -286,17 +292,15 @@ func (l *Listen) learnClientIP(packet gopacket.Packet) {
 	var payload gopacket.Payload
 	var parser *gopacket.DecodingLayerParser
 
-	switch l.handle.LinkType() {
-	case layers.LinkTypeNull:
-		parser = gopacket.NewDecodingLayerParser(layers.LayerTypeLoopback, &loop, &ip4, &udp, &payload)
-	case layers.LinkTypeLoop:
+	switch l.handle.LinkType().String() {
+	case layers.LinkTypeNull.String(), layers.LinkTypeLoop.String():
 		parser = gopacket.NewDecodingLayerParser(layers.LayerTypeLoopback, &loop, &ip4, &udp, &payload)
-	case layers.LinkTypeEthernet:
+	case layers.LinkTypeEthernet.String():
 		parser = gopacket.NewDecodingLayerParser(layers.LayerTypeEthernet, &eth, &ip4, &udp, &payload)
-	case layers.LinkTypeRaw:
+	case layers.LinkTypeRaw.String():
 		parser = gopacket.NewDecodingLayerParser(layers.LayerTypeIPv4, &ip4, &udp, &payload)
 	default:
-		log.Fatalf("Unsupported source linktype: 0x%02x", l.handle.LinkType())
+		log.Fatalf("Unsupported source linktype: %s", l.handle.LinkType().String())
 	}
 
 	decoded := []gopacket.LayerType{}
@@ -314,14 +318,15 @@ func (l *Listen) learnClientIP(packet gopacket.Packet) {
 	}
 
 	if found_ipv4 {
+		log.Debugf("%s: Learned client IP: %s", l.iname, ip4.SrcIP.String())
 		l.clients[ip4.SrcIP.String()] = time.Now().Add(l.clientTTL)
 	}
 }
 
 // Returns if the provided layertype is valid
 func isValidLayerType(layertype layers.LinkType) bool {
 	for _, b := range validLinkTypes {
-		if b == layertype {
+		if strings.Compare(b.String(), layertype.String()) == 0 {
 			return true
 		}
 	}

cmd/send.go

@@ -24,19 +24,15 @@ type SendPktFeed struct {
 
 // Send is a function to send a packet out all the other interfaces other than srcif
 func (s *SendPktFeed) Send(p gopacket.Packet, srcif string, linkType layers.LinkType) {
-	log.Debugf("Lock()???")
 	s.lock.Lock()
-	log.Debugf("Lock() achieved.  Sending out %d interfaces", len(s.senders)-1)
-	for key, send := range s.senders {
-		if strings.Compare(key, srcif) == 0 {
+	for thisif, send := range s.senders {
+		if strings.Compare(thisif, srcif) == 0 {
 			continue
 		}
-		log.Debugf("%s: sending out because we're not %s", srcif, key)
+		log.Debugf("%s: sending out because we're not %s", thisif, srcif)
 		send <- Send{packet: p, srcif: srcif, linkType: linkType}
-		log.Debugf("%s: sent", srcif)
 	}
 	s.lock.Unlock()
-	log.Debugf("Unlock()")
 }
 
 // RegisterSender registers a channel to recieve packet data we want to send