Refactor pool discovery to be closer to other dhcpd implementations

Like how Cisco IOS and ISC do it, determine the relevant pool by comparing
the subnet/mask in each configured pool with the IPs of each local network
interface, as opposed to doing one pool per interface.

This gets us closer to supporting requests from relay agents, as well as supports
the use case of multiple IPs/subnets per interface.

Author: jrgp

README.md

@@ -19,13 +19,11 @@ I wanted to make a small and safe Go solution, as well as to learn the DHCP prot
 
 ### Configuration
 
-We use yaml. Multiple pools can be defined this way, with one per interface as needed. DHCP traffic to interfaces
-not listed will be ignored.
+We use yaml. Multiple pools can be defined this way. DHCP traffic to interfaces not listed will be ignored.
 
 ```yaml
 pools:
   - name: vm testing
-    interface: eth1
     network: 172.17.0.0
     mask: 255.255.255.0
     start: 172.17.0.100
@@ -35,6 +33,7 @@ pools:
     routers: [ 172.17.0.1 ]
     dns: [ 1.1.1.1, 8.8.8.8 ]
 
+interfaces: [ eth1 ]
 leasedir: /var/lib/godhcpd
 ```
 

app.go

@@ -10,18 +10,26 @@ import (
 )
 
 type App struct {
-	pools          []*Pool
-	interface2Pool map[string]*Pool
+	ipnet2pool map[HashableIpNet]*Pool
+	interfaces map[string]struct{}
 }
 
 func NewApp() *App {
 	return &App{
-		pools:          []*Pool{},
-		interface2Pool: map[string]*Pool{},
+		ipnet2pool: map[HashableIpNet]*Pool{},
+		interfaces: map[string]struct{}{},
 	}
 }
 
-func (a *App) InitPools(conf *Conf) error {
+func (a *App) InitConf(conf *Conf) error {
+
+	for _, iface := range conf.Interfaces {
+		a.interfaces[iface] = struct{}{}
+	}
+
+	if len(a.interfaces) == 0 {
+		return errors.New("No interfaces configured")
+	}
 
 	for _, pc := range conf.Pools {
 		pool, err := pc.ToPool()
@@ -37,9 +45,9 @@ func (a *App) InitPools(conf *Conf) error {
 		}
 
 		if count == 1 {
-			log.Printf("Loaded pool %v on interface %v with %v lease", pool.Name, pool.Interface, count)
+			log.Printf("Loaded pool %v with %v lease", pool.Name, count)
 		} else {
-			log.Printf("Loaded pool %v on interface %v with %v leases", pool.Name, pool.Interface, count)
+			log.Printf("Loaded pool %v with %v leases", pool.Name, count)
 		}
 
 		err = a.insertPool(pool)
@@ -52,50 +60,78 @@ func (a *App) InitPools(conf *Conf) error {
 }
 
 func (a *App) insertPool(p *Pool) error {
-	if _, ok := a.interface2Pool[p.Interface]; ok {
-		return errors.New("Interfaces may be used by only one pool")
+	ipnet := HashableIpNet{
+		IP:   IpToFixedV4(p.Network),
+		Mask: IpToFixedV4(p.Netmask),
+	}
+
+	if _, ok := a.ipnet2pool[ipnet]; ok {
+		return errors.New("Duplicate IP network between pools")
 	}
 
-	a.interface2Pool[p.Interface] = p
-	a.pools = append(a.pools, p)
+	a.ipnet2pool[ipnet] = p
 
 	return nil
 }
 
-func (a *App) oObToInterface(oob []byte) (string, error) {
+func (a *App) oObToInterface(oob []byte) (*net.Interface, error) {
 	cm := &ipv4.ControlMessage{}
 
 	if err := cm.Parse(oob); err != nil {
-		return "", err
+		return nil, err
 	}
 
-	Interface, err := net.InterfaceByIndex(cm.IfIndex)
+	iface, err := net.InterfaceByIndex(cm.IfIndex)
 
 	if err != nil {
-		return "", err
+		return nil, err
 	}
 
-	return Interface.Name, nil
+	return iface, nil
 }
 
-func (a *App) findPoolByInterface(Interface string) (*Pool, error) {
-	pool, ok := a.interface2Pool[Interface]
-	if !ok {
-		return nil, errors.New("Unconfigured")
+func (a *App) findPoolByInterface(iface *net.Interface) (*Pool, error) {
+	addrs, err := iface.Addrs()
+
+	if err != nil {
+		return nil, err
 	}
-	return pool, nil
+
+	for _, addr := range addrs {
+		// FIXME: should we verify addr.Network() is first "ip+net" ?
+		_, ipnet, err := net.ParseCIDR(addr.String())
+		if err != nil {
+			continue
+		}
+
+		hipnet, err := IpNet2HashableIpNet(ipnet)
+		if err != nil {
+			continue
+		}
+
+		if pool, ok := a.ipnet2pool[hipnet]; ok {
+			return pool, nil
+		}
+	}
+
+	return nil, errors.New("Not found")
 }
 
 func (a *App) DispatchMessage(myBuf, myOob []byte, remote *net.UDPAddr, localSocket *net.UDPConn) {
-	Interface, err := a.oObToInterface(myOob)
+	iface, err := a.oObToInterface(myOob)
 	if err != nil {
 		log.Printf("Failed parsing interface out of OOB: %v", err)
 		return
 	}
 
-	pool, err := a.findPoolByInterface(Interface)
+	if _, ok := a.interfaces[iface.Name]; !ok {
+		log.Printf("Ignoring DHCP traffic on unconfigured interface %v", iface.Name)
+		return
+	}
+
+	pool, err := a.findPoolByInterface(iface)
 	if err != nil {
-		log.Printf("Ignoring DHCP traffic on unconfigured interface %v", Interface)
+		log.Printf("Can't find pool based on IPs bound to %v", iface.Name)
 		return
 	}
 

conf.go

@@ -10,9 +10,8 @@ import (
 )
 
 type PoolConf struct {
-	Name      string `yaml:"name"`
-	Interface string `yaml:"interface"`
-	MyIp      string `yaml:"myip"`
+	Name string `yaml:"name"`
+	MyIp string `yaml:"myip"`
 
 	Network string `yaml:"network"`
 	Subnet  string `yaml:"subnet"`
@@ -43,7 +42,6 @@ func (pc PoolConf) ToPool() (*Pool, error) {
 	pool.End = net.ParseIP(pc.End)
 	pool.MyIp = IpToFixedV4(net.ParseIP(pc.MyIp))
 	pool.LeaseTime = time.Second * time.Duration(pc.LeaseTime)
-	pool.Interface = pc.Interface
 
 	pool.Broadcast = calcBroadcast(pool.Network, pool.Netmask)
 
@@ -65,8 +63,9 @@ type HostConf struct {
 }
 
 type Conf struct {
-	Pools    []PoolConf `yaml:"pools"`
-	Leasedir string     `yaml:"leasedir"`
+	Pools      []PoolConf `yaml:"pools"`
+	Leasedir   string     `yaml:"leasedir"`
+	Interfaces []string   `yaml:"interfaces`
 }
 
 func ParseConf(path string) (*Conf, error) {

conf.yaml

@@ -1,6 +1,5 @@
 pools:
   - name: vm testing
-    interface: eth1
     network: 172.17.0.0
     mask: 255.255.255.0
     start: 172.17.0.100
@@ -11,6 +10,7 @@ pools:
     dns: [ 1.1.1.1, 8.8.8.8 ]
 
 leasedir: .
+interfaces: [ eth1 ]
 
 # The following makes more sense
 #leasedir: /var/lib/godhcpd

header.go

@@ -6,79 +6,9 @@ package main
 import (
 	"bytes"
 	"encoding/binary"
-	"errors"
 	"fmt"
-	"net"
-	"strconv"
-	"strings"
 )
 
-//
-// Fixed-width big-endian integer to keep track of IPv4 IPs, as they appear over the wire
-//
-type FixedV4 uint32
-
-func (v4 FixedV4) String() string {
-	ip := long2ip(uint32(v4))
-	return fmt.Sprintf("%d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3])
-}
-
-func (v4 FixedV4) Bytes() []byte {
-	return long2bytes(uint32(v4))
-}
-
-func (v4 FixedV4) Long() uint32 {
-	return uint32(v4)
-}
-
-func IpToFixedV4(ip net.IP) FixedV4 {
-	b := ip.To4()
-	return FixedV4(binary.BigEndian.Uint32(b[0:4]))
-}
-
-func BytesToFixedV4(b []byte) (FixedV4, error) {
-	if len(b) != 4 {
-		return 0, errors.New("Incorrect length")
-	}
-	return FixedV4(binary.BigEndian.Uint32(b[0:4])), nil
-}
-
-//
-// Fixed-width byte array for mac addresses, as they appear over the wire
-//
-type MacAddress [6]byte
-
-func (m MacAddress) String() string {
-	return fmt.Sprintf("%x:%x:%x:%x:%x:%x", m[0], m[1], m[2], m[3], m[4], m[5])
-}
-
-func StrToMac(str string) MacAddress {
-	var m MacAddress
-
-	parts := strings.Split(str, ":")
-	if len(parts) != 6 {
-		return m
-	}
-
-	parsePart := func(s string) byte {
-		if n, err := strconv.ParseUint(s, 16, 8); err == nil {
-			return byte(n)
-		}
-		return 0
-	}
-
-	m = MacAddress{
-		parsePart(parts[0]),
-		parsePart(parts[1]),
-		parsePart(parts[2]),
-		parsePart(parts[3]),
-		parsePart(parts[4]),
-		parsePart(parts[5]),
-	}
-
-	return m
-}
-
 //
 // Header of a DHCP payload
 //

main.go

@@ -29,10 +29,10 @@ func main() {
 
 	app := NewApp()
 
-	err = app.InitPools(conf)
+	err = app.InitConf(conf)
 
 	if err != nil {
-		log.Fatalf("Failed initializing pools: %v", err)
+		log.Fatalf("Failed initializing: %v", err)
 	}
 
 	addr := net.UDPAddr{

pool.go

@@ -35,7 +35,6 @@ type Pool struct {
 	Router      []net.IP
 	Dns         []net.IP
 	LeaseTime   time.Duration
-	Interface   string
 	Persistence Persistence
 
 	leasesByMac map[MacAddress]*Lease