Add support for custom IPs based on client mac address

Author: jrgp

README.md

@@ -33,6 +33,11 @@ pools:
     routers: [ 172.17.0.1 ]
     dns: [ 1.1.1.1, 8.8.8.8 ]
 
+    # Optional static IPs by mac address
+    hosts:
+      - ip: 172.17.0.5
+        hw: 0:1c:42:b4:6e:1d
+
 interfaces: [ eth1 ]
 leasedir: /var/lib/godhcpd
 ```
@@ -80,10 +85,10 @@ root@ubuntu2:~#
 - Bare minimum wire protocol for DHCPDISCOVER, DHCPOFFER, DHCPREQUEST, DHCPNAK, DHCPACK, and DHCPRELEASE to work
 - Supports relayed requests
 - Supports multiple IP Pools, sourced from configuration
+- Supports hosts in config with hardcoded IPs, based on mac address
 
 ## TODO
 
 - Support acting as a relay
 - Support arbitrary options
-- Support hosts in config with hardcoded IPs, based on mac address
 - More Tests

conf.go

@@ -9,6 +9,7 @@ import (
 	"time"
 )
 
+// Pool conf object
 type PoolConf struct {
 	Name string `yaml:"name"`
 	MyIp string `yaml:"myip"`
@@ -24,6 +25,10 @@ type PoolConf struct {
 	Dns    []string `yaml:"dns"`
 
 	LeaseTime uint32 `yaml:"leasetime"`
+
+	// TODO: add arbitrary options aside from just router/dns
+
+	ReservedHosts []HostConf `yaml:"hosts"`
 }
 
 func (pc PoolConf) ToPool() (*Pool, error) {
@@ -53,15 +58,30 @@ func (pc PoolConf) ToPool() (*Pool, error) {
 		pool.Dns = append(pool.Dns, net.ParseIP(ip))
 	}
 
+	for _, host := range pc.ReservedHosts {
+		if err := pool.AddReservedHost(host.ToHost()); err != nil {
+			return nil, err
+		}
+	}
+
 	return pool, nil
 }
 
 type HostConf struct {
-	Ip        string `yaml:"ip"`
-	Mac       string `yaml:"hw"`
-	MacParsed MacAddress
+	IP       string `yaml:"ip"`
+	Mac      string `yaml:"hw"`
+	Hostname string `yaml:"hostname"`
+	// TODO: add custom options scoped to host
+}
+
+func (hc *HostConf) ToHost() *ReservedHost {
+	return &ReservedHost{
+		Mac: StrToMac(hc.Mac),
+		IP:  IpToFixedV4(net.ParseIP(hc.IP)),
+	}
 }
 
+// Root yaml conf
 type Conf struct {
 	Pools      []PoolConf `yaml:"pools"`
 	Leasedir   string     `yaml:"leasedir"`

conf.yaml

@@ -9,6 +9,11 @@ pools:
     routers: [ 172.17.0.1 ]
     dns: [ 1.1.1.1, 8.8.8.8 ]
 
+    # Optional static IPs by mac address
+    hosts:
+      - ip: 172.17.0.5
+        hw: 0:1c:42:b4:6e:1d
+
   # Example pool acting as a relay, using a separate
   # net on eth2
   - name: other network

pool.go

@@ -24,6 +24,12 @@ func (l *Lease) Expired() bool {
 	return time.Now().After(l.Expiration)
 }
 
+type ReservedHost struct {
+	Mac      MacAddress
+	Hostname string
+	IP       FixedV4
+}
+
 type Pool struct {
 	Name        string
 	Network     net.IP
@@ -37,19 +43,32 @@ type Pool struct {
 	LeaseTime   time.Duration
 	Persistence Persistence
 
+	// Internal lease database
 	leasesByMac map[MacAddress]*Lease
 	leaseByIp   map[FixedV4]*Lease
-	m           sync.RWMutex
+
+	// Internal database of fixed mac addresses to IPs for hosts,
+	// sourced from configuration
+	reservedByMac map[MacAddress]*ReservedHost
+	reservedByIp  map[FixedV4]*ReservedHost
+
+	m sync.RWMutex
 }
 
 func NewPool() *Pool {
 	p := &Pool{}
 	p.clearLeases()
+	p.clearReservedHosts()
 	return p
 }
 
 // Hacky, terrible, naive impl. I want an ordered int set!
-func (p *Pool) getFreeIp() (FixedV4, error) {
+func (p *Pool) getFreeIp(mac MacAddress) (FixedV4, error) {
+
+	// If there is a reserved IP for this mac address, use that
+	if host, ok := p.reservedByMac[mac]; ok {
+		return host.IP, nil
+	}
 
 	// Try to find the next free IP within our range, while keeping
 	// track of the first expired lease we found, in case we have no
@@ -60,6 +79,10 @@ func (p *Pool) getFreeIp() (FixedV4, error) {
 	var foundExpired *Lease = nil
 
 	for ipLong := start; ipLong <= end; ipLong++ {
+		// Skip over any IPs in our range which are reserved
+		if _, ok := p.reservedByIp[ipLong]; ok {
+			continue
+		}
 		if lease, ok := p.leaseByIp[ipLong]; !ok {
 			return ipLong, nil
 		} else {
@@ -94,6 +117,27 @@ func (p *Pool) deleteLease(lease *Lease) {
 	delete(p.leaseByIp, lease.IP)
 }
 
+func (p *Pool) clearReservedHosts() {
+	p.reservedByMac = map[MacAddress]*ReservedHost{}
+	p.reservedByIp = map[FixedV4]*ReservedHost{}
+}
+
+func (p *Pool) insertReservedHost(host *ReservedHost) {
+	p.reservedByMac[host.Mac] = host
+	p.reservedByIp[host.IP] = host
+}
+
+func (p *Pool) AddReservedHost(host *ReservedHost) error {
+	if _, ok := p.reservedByIp[host.IP]; ok {
+		return errors.New("Reserved hosts with duplicate IPs")
+	}
+	if _, ok := p.reservedByMac[host.Mac]; ok {
+		return errors.New("Reserved hosts with duplicate mac addresses")
+	}
+	p.insertReservedHost(host)
+	return nil
+}
+
 func (p *Pool) TouchLeaseByMac(mac MacAddress) (*Lease, bool) {
 	p.m.Lock()
 	defer p.m.Unlock()
@@ -110,7 +154,7 @@ func (p *Pool) GetNextLease(mac MacAddress, hostname string) (*Lease, error) {
 	p.m.Lock()
 	defer p.m.Unlock()
 
-	ip, err := p.getFreeIp()
+	ip, err := p.getFreeIp(mac)
 	if err != nil {
 		return nil, err
 	}

pool_test.go

@@ -57,3 +57,39 @@ func TestIpAllocation(t *testing.T) {
 	require.Equal(t, "host3", lease3.Hostname)
 	require.Equal(t, IpToFixedV4(net.ParseIP("172.0.0.10")), lease3.IP)
 }
+
+// Test IP allocation with reserved mac addresses
+func TestIpReservedAllocation(t *testing.T) {
+	pool := NewPool()
+	pool.Start = net.ParseIP("172.0.0.10")
+	pool.End = net.ParseIP("172.0.0.12")
+	pool.Netmask = net.ParseIP("255.255.255.0")
+	pool.LeaseTime = time.Duration(1) * time.Hour
+
+	mac1 := MacAddress{0, 0, 0, 0, 0, 1}
+	mac2 := MacAddress{0, 0, 0, 0, 0, 2}
+
+	// Bind mac2 to 172.0.0.10. Deliberately choose an IP in our range to
+	// verify that overlaps are ignored
+	err := pool.AddReservedHost(&ReservedHost{
+		Mac: mac2,
+		IP:  IpToFixedV4(net.ParseIP("172.0.0.10")),
+	})
+	require.Nil(t, err)
+
+	// Verify initial IP lease acquisition chooses the IP after the reserved
+	lease1, err := pool.GetNextLease(mac1, "host1")
+	require.Nil(t, err)
+	require.Equal(t, IpToFixedV4(net.ParseIP("172.0.0.11")), lease1.IP)
+	require.Equal(t, mac1, lease1.Mac)
+	require.Equal(t, "host1", lease1.Hostname)
+	require.False(t, lease1.Expired())
+
+	// Verify custom allocation works
+	lease2, err := pool.GetNextLease(mac2, "host2")
+	require.Nil(t, err)
+	require.Equal(t, IpToFixedV4(net.ParseIP("172.0.0.10")), lease2.IP)
+	require.Equal(t, mac2, lease2.Mac)
+	require.Equal(t, "host2", lease2.Hostname)
+	require.False(t, lease2.Expired())
+}