From 0ed69fbc705cc44f03516560dc8886e213fe3e3c Mon Sep 17 00:00:00 2001
From: Toni <antpiasecki@gmail.com>
Date: Tue, 21 Jul 2026 22:38:34 +0200
Subject: [PATCH] log ipv6 addresses

---
 client/main.go |  2 +-
 server/main.go | 46 +++++++++++++++++++++-------------------------
 2 files changed, 22 insertions(+), 26 deletions(-)

diff --git a/client/main.go b/client/main.go
index 40af4a4..58b92ed 100644
--- a/client/main.go
+++ b/client/main.go
@@ -31,7 +31,7 @@ func main() {
 		panic("root permissions needed")
 	}
 
-	listenAddr, err := net.ResolveUDPAddr("udp", ":38001")
+	listenAddr, err := net.ResolveUDPAddr("udp", ":38000")
 	if err != nil {
 		panic(err)
 	}
diff --git a/server/main.go b/server/main.go
index c6ad62c..594985a 100644
--- a/server/main.go
+++ b/server/main.go
@@ -1,3 +1,6 @@
+// TODO: slice bounds checking
+// TODO: authentication
+// TODO: encryption
 package main
 
 import (
@@ -12,7 +15,7 @@ import (
 )
 
 type Peer struct {
-	RealIP     string
+	RealAddr   *net.UDPAddr
 	InternalIP string
 }
 
@@ -72,7 +75,8 @@ func receivePacket(pkt []byte, addr *net.UDPAddr) {
 
 	pktType := binary.LittleEndian.Uint16(pkt[2:])
 
-	peerIP := addr.IP.String()
+	// idk if it needs to lock the mutex
+	peer := peers[addr.IP.String()]
 
 	switch pktType {
 	case shared.REQ_REGISTER:
@@ -82,23 +86,19 @@ func receivePacket(pkt []byte, addr *net.UDPAddr) {
 		// TODO
 		internalIP := fmt.Sprintf("10.1.0.%d", nextIP)
 
-		if peer, ok := peers[addr.IP.String()]; ok {
-			internalIP = peer.InternalIP
+		if destPeer, ok := peers[addr.IP.String()]; ok {
+			internalIP = destPeer.InternalIP
 		} else {
 			peers[addr.IP.String()] = &Peer{
-				RealIP:     peerIP,
+				RealAddr:   addr,
 				InternalIP: internalIP,
 			}
 			nextIP++
 		}
 
 		resp := shared.BuildPkt(shared.RESP_REGISTER, net.ParseIP(internalIP).To4())
-		if _, err := conn.WriteToUDP(resp, addr); err != nil {
-			log.Println(err)
-		}
+		sendTo(addr, resp)
 	case shared.REQ_DATA:
-		log.Println("received packet from " + peerIP + ":")
-
 		frame := pkt[4:]
 		etherType := binary.BigEndian.Uint16(frame[12:14])
 		payload := frame[14:]
@@ -106,19 +106,20 @@ func receivePacket(pkt []byte, addr *net.UDPAddr) {
 		switch etherType {
 		case 0x0800: // IPv4
 			destIP := net.IP(payload[16:20]).String()
-			if peer := getPeerByInternalIP(destIP); peer != nil {
-				log.Println("relaying to", peer.RealIP)
+			if destPeer := getPeerByInternalIP(destIP); destPeer != nil {
+				log.Println(peer.InternalIP + " -> " + destIP)
 				resp := shared.BuildPkt(shared.RESP_DATA, frame)
-				sendTo(peer.RealIP, resp)
+				sendTo(peer.RealAddr, resp)
 			} else {
-				log.Println("unknown dest IP: " + destIP)
+				log.Println(peer.InternalIP + " -/> " + destIP + " (unrecognized IP)")
 			}
 		case 0x0806: // ARP
-			log.Println("broadcasting ARP")
+			log.Println(peer.InternalIP + " -> *")
 			resp := shared.BuildPkt(shared.RESP_DATA, frame)
-			broadcast(resp, peerIP)
+			broadcast(resp, peer.InternalIP)
 		case 0x86dd: // IPv6
-			log.Println("IPv6") // TODO
+			destIP := net.IP(payload[24:40]).String()
+			log.Println(peer.InternalIP + " -/> " + destIP + " (IPv6)") // TODO
 		default:
 			log.Printf("unhandled EtherType: 0x%x\n", etherType)
 		}
@@ -131,19 +132,14 @@ func broadcast(pkt []byte, except string) {
 	peersMutex.Lock()
 	defer peersMutex.Unlock()
 	for _, p := range peers {
-		if p.RealIP == except {
+		if p.RealAddr.IP.String() == except {
 			continue
 		}
-		sendTo(p.RealIP, pkt)
+		sendTo(p.RealAddr, pkt)
 	}
 }
 
-func sendTo(ip string, pkt []byte) {
-	addr, err := net.ResolveUDPAddr("udp", ip+":38001")
-	if err != nil {
-		log.Println(err)
-		return
-	}
+func sendTo(addr *net.UDPAddr, pkt []byte) {
 	if _, err := conn.WriteToUDP(pkt, addr); err != nil {
 		log.Println(err)
 	}