send captured packets to server

client/main.go

@@ -5,14 +5,24 @@ import (
 	"log"
 	"net"
 	"os"
+	"os/exec"
 
 	"baalvpn/shared"
+
+	"github.com/songgao/packets/ethernet"
+	"github.com/songgao/water"
 )
 
-const SERVER_IP = "172.20.12.47"
+const (
+	SERVER_IP  = "172.20.12.47"
+	IFACE_NAME = "baalvpn"
+)
 
 var (
 	internalIP net.IP = nil
+	serverAddr *net.UDPAddr
+	iface      *water.Interface
+	conn       *net.UDPConn
 )
 
 func main() {
@@ -24,34 +34,34 @@ func main() {
 	if err != nil {
 		panic(err)
 	}
-	listener, err := net.ListenUDP("udp", listenAddr)
+	conn, err = net.ListenUDP("udp", listenAddr)
 	if err != nil {
 		panic(err)
 	}
-	defer listener.Close()
+	defer conn.Close()
 
-	go receivePackets(listener)
+	serverAddr, err = net.ResolveUDPAddr("udp", SERVER_IP+":38000")
-	register(listener)
+	if err != nil {
+		panic(err)
+	}
+
+	go receivePackets()
+	register()
 
 	<-make(chan int) // block forever
 }
 
-func register(c *net.UDPConn) {
+func register() {
-	serverAddr, err := net.ResolveUDPAddr("udp", SERVER_IP+":38000")
-	if err != nil {
-		panic(err)
-	}
-
 	req := shared.BuildPkt(shared.REQ_REGISTER, []byte{})
-	if _, err := c.WriteToUDP(req, serverAddr); err != nil {
+	if _, err := conn.WriteToUDP(req, serverAddr); err != nil {
 		panic(err)
 	}
 }
 
-func receivePackets(listener *net.UDPConn) {
+func receivePackets() {
 	for {
 		buffer := make([]byte, 50000)
-		n, addr, err := listener.ReadFromUDP(buffer)
+		n, addr, err := conn.ReadFromUDP(buffer)
 		if err != nil {
 			log.Println(err)
 			continue
@@ -59,12 +69,16 @@ func receivePackets(listener *net.UDPConn) {
 		if n == 0 {
 			continue
 		}
+		if addr.String() != serverAddr.String() {
+			log.Println("non-server connection rejected")
+			continue
+		}
 
-		go receivePacket(listener, buffer[:n], addr)
+		go receivePacket(buffer[:n])
 	}
 }
 
-func receivePacket(c *net.UDPConn, pkt []byte, addr *net.UDPAddr) {
+func receivePacket(pkt []byte) {
 	if len(pkt) < 4 {
 		log.Println("packet too short")
 		return
@@ -81,7 +95,46 @@ func receivePacket(c *net.UDPConn, pkt []byte, addr *net.UDPAddr) {
 	case shared.RESP_REGISTER:
 		internalIP = net.IP(pkt[4:])
 		log.Println("Received IP from the server:", internalIP.String())
+		initInterface()
+		go sendPackets()
 	default:
 		log.Println("unknown packet type")
 	}
 }
+
+func initInterface() {
+	config := water.Config{DeviceType: water.TAP}
+	config.Name = IFACE_NAME
+
+	var err error
+	iface, err = water.New(config)
+	if err != nil {
+		panic(err)
+	}
+
+	if err := exec.Command("ip", "addr", "add", internalIP.String()+"/24", "dev", IFACE_NAME).Run(); err != nil {
+		panic(err)
+	}
+	if err := exec.Command("ip", "link", "set", "dev", IFACE_NAME, "up").Run(); err != nil {
+		panic(err)
+	}
+}
+
+func sendPackets() {
+	log.Println("Listening for packets...")
+
+	var frame ethernet.Frame
+	for {
+		frame.Resize(1500)
+		n, err := iface.Read([]byte(frame))
+		if err != nil {
+			panic(err)
+		}
+		frame = frame[:n]
+
+		pkt := shared.BuildPkt(shared.REQ_DATA, frame)
+		if _, err := conn.WriteToUDP(pkt, serverAddr); err != nil {
+			log.Println(err)
+		}
+	}
+}

server/main.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"encoding/binary"
+	"encoding/hex"
 	"fmt"
 	"log"
 	"net"
@@ -11,7 +12,6 @@ import (
 
 	"baalvpn/shared"
 
-	"github.com/songgao/packets/ethernet"
 	"github.com/songgao/water"
 )
 
@@ -26,6 +26,7 @@ var (
 	peers      = map[string]*Peer{}
 	peersMutex sync.Mutex
 	nextIP     = 3
+	iface      *water.Interface
 )
 
 func main() {
@@ -36,47 +37,25 @@ func main() {
 	config := water.Config{DeviceType: water.TAP}
 	config.Name = IFACE_NAME
 
-	iface, err := water.New(config)
+	var err error
+	iface, err = water.New(config)
 	if err != nil {
 		panic(err)
 	}
 
-	if err := exec.Command("ip", "addr", "add", "10.1.0.10/24", "dev", IFACE_NAME).Run(); err != nil {
+	if err := exec.Command("ip", "addr", "add", "10.1.0.2/24", "dev", IFACE_NAME).Run(); err != nil {
 		panic(err)
 	}
 	if err := exec.Command("ip", "link", "set", "dev", IFACE_NAME, "up").Run(); err != nil {
 		panic(err)
 	}
 
-	log.Println("Listening...")
+	receivePackets()
-
-	go receivePackets()
-	sendPackets(iface)
-}
-
-func sendPackets(iface *water.Interface) {
-	var frame ethernet.Frame
-	for {
-		frame.Resize(1500)
-		n, err := iface.Read([]byte(frame))
-		if err != nil {
-			panic(err)
-		}
-		frame = frame[:n]
-
-		if frame.Destination()[0]&0x01 == 0x01 {
-			log.Println("multicast")
-			continue
-		}
-
-		log.Printf("Dst: %s\n", frame.Destination())
-		log.Printf("Src: %s\n", frame.Source())
-		log.Printf("Ethertype: % x\n", frame.Ethertype())
-		log.Printf("Payload: % x\n", frame.Payload())
-	}
 }
 
 func receivePackets() {
+	log.Println("Listening for packets...")
+
 	listenAddr, err := net.ResolveUDPAddr("udp", ":38000")
 	if err != nil {
 		panic(err)
@@ -102,7 +81,7 @@ func receivePackets() {
 	}
 }
 
-func receivePacket(c *net.UDPConn, pkt []byte, addr *net.UDPAddr) {
+func receivePacket(conn *net.UDPConn, pkt []byte, addr *net.UDPAddr) {
 	if len(pkt) < 4 {
 		log.Println("packet too short")
 		return
@@ -135,9 +114,12 @@ func receivePacket(c *net.UDPConn, pkt []byte, addr *net.UDPAddr) {
 		}
 
 		resp := shared.BuildPkt(shared.RESP_REGISTER, net.ParseIP(internalIP).To4())
-		if _, err := c.WriteToUDP(resp, addr); err != nil {
+		if _, err := conn.WriteToUDP(resp, addr); err != nil {
-			log.Printf("register WriteToUDP: %v\n", err)
+			log.Println(err)
 		}
+	case shared.REQ_DATA:
+		fmt.Println("received packet from " + peerIP + ":")
+		fmt.Println(hex.EncodeToString(pkt[4:]))
 	default:
 		log.Println("unknown packet type")
 	}

shared/proto.go

@@ -8,6 +8,7 @@ const (
 	unused uint16 = iota
 	REQ_REGISTER
 	RESP_REGISTER
+	REQ_DATA
 )
 
 func Uint16(v uint16) []byte {