node/globalfuncs.go

@@ -5,48 +5,25 @@ import (
 	"sync/atomic"
 )
 
-func _sendControlPacket(
+func _sendControlPacket(pkt interface{ Marshal([]byte) []byte }, route peerRoute, buf1, buf2 []byte) {
-	pkt interface{ Marshal([]byte) []byte },
+	buf := pkt.Marshal(buf2)
-	route peerRoute,
+	h := header{
-	buf1 []byte,
-	buf2 []byte,
-) {
-	buf := pkt.Marshal(buf1)
-	h1 := header{
 		StreamID: controlStreamID,
 		Counter:  atomic.AddUint64(&sendCounters[route.IP], 1),
 		SourceIP: localIP,
 		DestIP:   route.IP,
 	}
-	buf = route.ControlCipher.Encrypt(h1, buf, buf2)
+	buf = route.ControlCipher.Encrypt(h, buf, buf1)
 
 	if route.RelayIP == 0 {
 		_conn.WriteTo(buf, route.RemoteAddr)
 		return
 	}
 
-	relayRoute := routingTable[route.RelayIP].Load()
+	_relayPacket(route.RelayIP, route.IP, buf, buf2)
-	if !relayRoute.Up || !relayRoute.Relay {
-		log.Print("Failed to send control packet: relay not available.")
-		return
 }
 
-	h2 := header{
+func _sendDataPacket(route *peerRoute, pkt, buf1, buf2 []byte) {
-		StreamID: dataStreamID,
-		Counter:  atomic.AddUint64(&sendCounters[relayRoute.IP], 1),
-		SourceIP: localIP,
-		DestIP:   route.IP,
-	}
-	buf = relayRoute.DataCipher.Encrypt(h2, buf, buf1)
-	_conn.WriteTo(buf, relayRoute.RemoteAddr)
-}
-
-func _sendDataPacket(
-	pkt []byte,
-	route *peerRoute,
-	buf1 []byte,
-	buf2 []byte,
-) {
 	h := header{
 		StreamID: dataStreamID,
 		Counter:  atomic.AddUint64(&sendCounters[route.IP], 1),
@@ -61,19 +38,23 @@ func _sendDataPacket(
 		return
 	}
 
-	relayRoute := routingTable[route.RelayIP].Load()
+	_relayPacket(route.RelayIP, route.IP, enc, buf2)
+}
+
+func _relayPacket(relayIP, destIP byte, data, buf []byte) {
+	relayRoute := routingTable[relayIP].Load()
 	if !relayRoute.Up || !relayRoute.Relay {
 		log.Print("Failed to send data packet: relay not available.")
 		return
 	}
 
-	h2 := header{
+	h := header{
 		StreamID: dataStreamID,
 		Counter:  atomic.AddUint64(&sendCounters[relayRoute.IP], 1),
 		SourceIP: localIP,
-		DestIP:   route.IP,
+		DestIP:   destIP,
 	}
 
-	enc = relayRoute.DataCipher.Encrypt(h2, enc, buf2)
+	enc := relayRoute.DataCipher.Encrypt(h, data, buf)
 	_conn.WriteTo(enc, relayRoute.RemoteAddr)
 }

node/globals.go

@@ -27,31 +27,31 @@ type peerRoute struct {
 	RelayIP       byte           // Non-zero if we should relay.
 }
 
-// Configuration for this peer.
 var (
+	// Configuration for this peer.
 	netName    string
 	localIP    byte
 	localPub   bool
 	privateKey []byte
-)
 
 	// Shared interface for writing.
-var _iface *ifWriter
+	_iface *ifWriter
 
 	// Shared connection for writing.
-var _conn *connWriter
+	_conn *connWriter
 
 	// Counters for sending to each peer.
-var sendCounters [256]uint64
+	sendCounters [256]uint64
 
 	// Duplicate checkers for incoming packets.
-var dupChecks [256]*dupCheck
+	dupChecks [256]*dupCheck
 
 	// Channels for incoming control packets.
-var controlPackets [256]chan controlPacket
+	controlPackets [256]chan controlPacket
 
 	// Channels for incoming peer updates from the hub.
-var peerUpdates [256]chan *m.Peer
+	peerUpdates [256]chan *m.Peer
 
 	// Global routing table.
-var routingTable [256]*atomic.Pointer[peerRoute]
+	routingTable [256]*atomic.Pointer[peerRoute]
+)

node/main.go

@@ -287,6 +287,6 @@ func readFromIFace(iface io.ReadWriteCloser) {
 			continue
 		}
 
-		_sendDataPacket(packet, route, buf1, buf2)
+		_sendDataPacket(route, packet, buf1, buf2)
 	}
 }