checkpoint

server/BUILD.bazel

@@ -2,8 +2,16 @@ load("@io_bazel_rules_go//go:def.bzl", "go_library")
 
 go_library(
     name = "server",
-    srcs = ["server.go"],
+    srcs = [
+        "addr.go",
+        "config.go",
+        "packet.go",
+        "server.go",
+    ],
     importpath = "git.wntrmute.dev/kyle/kdhcp/server",
     visibility = ["//visibility:public"],
-    deps = ["@com_github_davecgh_go_spew//spew"],
+    deps = [
+        "//bazel-kdhcp/external/com_github_davecgh_go_spew/spew",
+        "//log",
+    ],
 )

server/addr.go

@@ -0,0 +1,61 @@
+package server
+
+import (
+	"fmt"
+	"net"
+
+	"git.wntrmute.dev/kyle/kdhcp/bazel-kdhcp/external/com_github_davecgh_go_spew/spew"
+	"git.wntrmute.dev/kyle/kdhcp/log"
+)
+
+type addr struct {
+	ifi *net.Interface
+	IP  net.IP
+	ipn *net.IPNet
+}
+
+func addrsForDevice(dev string) ([]addr, error) {
+	netInterface, err := net.InterfaceByName(dev)
+	if err != nil {
+		return nil, fmt.Errorf("while selecting interface %s: %w", dev, err)
+	}
+
+	spew.Dump(netInterface)
+
+	var addrs []addr
+	devAddrs, err := netInterface.Addrs()
+	if err != nil {
+		return nil, err
+	}
+
+	for _, devAddr := range devAddrs {
+		log.Debugf("consider %s", devAddr.String())
+		ip, ipn, err := net.ParseCIDR(devAddr.String())
+		if err != nil {
+			continue
+		}
+
+		if ip == nil {
+			continue // address isn't an IP address
+		}
+
+		log.Debugf("found IP: %s", ip)
+		ip = ip.To4()
+
+		// DHCP should only listen on private addresses.
+		if !ip.IsPrivate() {
+			log.Debugln("skipping non-private")
+			continue
+		}
+
+		// only support IPv4 for now
+		if len(ip) != 4 {
+			log.Debugf("%d IP, only supporting v4 right now", len(ip))
+			continue
+		}
+
+		addrs = append(addrs, addr{netInterface, ip, ipn})
+	}
+
+	return addrs, nil
+}

server/config.go

@@ -0,0 +1,19 @@
+package server
+
+const (
+	DefaultPort          = 67
+	DefaultMaxPacketSize = 512
+	DefaultNetwork       = "udp4"
+)
+
+type Config struct {
+	Port          int
+	MaxPacketSize int
+}
+
+func DefaultConfig() *Config {
+	return &Config{
+		Port:          DefaultPort,
+		MaxPacketSize: DefaultMaxPacketSize,
+	}
+}

server/packet.go

@@ -0,0 +1,8 @@
+package server
+
+import "net"
+
+type Packet struct {
+	Data []byte
+	Addr net.Addr
+}

server/server.go

@@ -1,82 +1,62 @@
 package server
 
-
 import (
-	"errors"
-	"log"
+	"fmt"
 	"net"
 
-	"github.com/davecgh/go-spew/spew"
+	"git.wntrmute.dev/kyle/kdhcp/log"
 )
 
 // github.com/insomniacslk/dhcp
 
-type addr struct {
-	IP  net.IP
-	ipn *net.IPNet
-}
-
-type Config struct {
-	Device string `yaml:"device"`
-}
-
 type Server struct {
-	addrs []net.IP
-	l     net.Listener
+	cfg  *Config
+	conn net.PacketConn
 }
 
-func addrsForDevice(dev string) ([]addr, error) {
-	netInterface, err := net.InterfaceByName(dev)
+func (srv *Server) Listen() (err error) {
+	if srv.conn != nil {
+		srv.conn.Close()
+	}
+
+	log.Debugf("attempting to set up packet listener on %s 0.0.0.0:%d", DefaultNetwork, srv.cfg.Port)
+	srv.conn, err = net.ListenPacket(DefaultNetwork, fmt.Sprintf(":%d", srv.cfg.Port))
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (srv *Server) Close() error {
+	if srv.conn != nil {
+		return srv.conn.Close()
+	}
+	return nil
+}
+
+func (srv *Server) ReadFrom() (*Packet, error) {
+	b := make([]byte, srv.cfg.MaxPacketSize)
+	n, addr, err := srv.conn.ReadFrom(b)
 	if err != nil {
 		return nil, err
 	}
 
-	spew.Dump(netInterface)
-
-	var addrs []addr
-	devAddrs, err := netInterface.Addrs()
-	if err != nil {
-		return nil, err
-	}
-
-	for _, devAddr := range devAddrs {
-		log.Printf("consider %s", devAddr.String())
-		ip, ipn, err := net.ParseCIDR(devAddr.String())
-		if err != nil {
-			continue
-		}
-
-		if ip == nil {
-			continue // address isn't an IP address
-		}
-
-		log.Printf("found IP: %s", ip)
-		ip = ip.To4()
-
-		// DHCP should only listen on private addresses.
-		if !ip.IsPrivate() {
-			log.Println("skipping non-private")
-			continue
-		}
-
-		// only support IPv4 for now
-		if len(ip) != 4 {
-			log.Printf("%d IP, only supporting v4 right now", len(ip))
-			continue
-		}
-
-		addrs = append(addrs, addr{ip, ipn})
-	}
-
-	return addrs, nil
+	return &Packet{
+		Data: b[:n],
+		Addr: addr,
+	}, nil
 }
 
 func NewServer(cfg *Config) (*Server, error) {
-	addrs, err := addrsForDevice(cfg.Device)
+	srv := &Server{
+		cfg: cfg,
+	}
+
+	err := srv.Listen()
 	if err != nil {
 		return nil, err
 	}
 
-	log.Println("server IP list: ", addrs)
-	return nil, errors.New("not implemented")
+	return srv, nil
 }