add all files from Hong

2025-06-30 09:23:28 +08:00
parent ceb1fe2640
commit 9b7d32fbd9
69 changed files with 7280 additions and 0 deletions
--- a/plugins/file/plugin.go
+++ b/plugins/file/plugin.go
@@ -0,0 +1,282 @@
+// Copyright 2018-present the CoreDHCP Authors. All rights reserved
+// This source code is licensed under the MIT license found in the
+// LICENSE file in the root directory of this source tree.
+
+// Package file enables static mapping of MAC <--> IP addresses.
+// The mapping is stored in a text file, where each mapping is described by one line containing
+// two fields separated by spaces: MAC address, and IP address. For example:
+//
+//  $ cat file_leases.txt
+//  00:11:22:33:44:55 10.0.0.1
+//  01:23:45:67:89:01 10.0.10.10
+//
+// To specify the plugin configuration in the server6/server4 sections of the config file, just
+// pass the leases file name as plugin argument, e.g.:
+//
+//  $ cat config.yml
+//
+//  server6:
+//     ...
+//     plugins:
+//       - file: "file_leases.txt" [autorefresh]
+//     ...
+//
+// If the file path is not absolute, it is relative to the cwd where coredhcp is run.
+//
+// Optionally, when the 'autorefresh' argument is given, the plugin will try to refresh
+// the lease mapping during runtime whenever the lease file is updated.
+package file
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"net"
+	"os"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/coredhcp/coredhcp/handler"
+	"github.com/coredhcp/coredhcp/logger"
+	"github.com/coredhcp/coredhcp/plugins"
+	"github.com/fsnotify/fsnotify"
+	"github.com/insomniacslk/dhcp/dhcpv4"
+	"github.com/insomniacslk/dhcp/dhcpv6"
+)
+
+const (
+	autoRefreshArg = "autorefresh"
+)
+
+var log = logger.GetLogger("plugins/file")
+
+// Plugin wraps plugin registration information
+var Plugin = plugins.Plugin{
+	Name:   "file",
+	Setup6: setup6,
+	Setup4: setup4,
+}
+
+var recLock sync.RWMutex
+
+// StaticRecords holds a MAC -> IP address mapping
+var StaticRecords map[string]net.IP
+
+// DHCPv6Records and DHCPv4Records are mappings between MAC addresses in
+// form of a string, to network configurations.
+var (
+	DHCPv6Records map[string]net.IP
+	DHCPv4Records map[string]net.IP
+)
+
+// LoadDHCPv4Records loads the DHCPv4Records global map with records stored on
+// the specified file. The records have to be one per line, a mac address and an
+// IPv4 address.
+func LoadDHCPv4Records(filename string) (map[string]net.IP, error) {
+	log.Infof("reading leases from %s", filename)
+	data, err := os.ReadFile(filename)
+	if err != nil {
+		return nil, err
+	}
+	records := make(map[string]net.IP)
+	for _, lineBytes := range bytes.Split(data, []byte{'\n'}) {
+		line := string(lineBytes)
+		if len(line) == 0 {
+			continue
+		}
+		if strings.HasPrefix(line, "#") {
+			continue
+		}
+		tokens := strings.Fields(line)
+		if len(tokens) != 2 {
+			return nil, fmt.Errorf("malformed line, want 2 fields, got %d: %s", len(tokens), line)
+		}
+		hwaddr, err := net.ParseMAC(tokens[0])
+		if err != nil {
+			return nil, fmt.Errorf("malformed hardware address: %s", tokens[0])
+		}
+		ipaddr := net.ParseIP(tokens[1])
+		if ipaddr.To4() == nil {
+			return nil, fmt.Errorf("expected an IPv4 address, got: %v", ipaddr)
+		}
+		records[hwaddr.String()] = ipaddr
+	}
+
+	return records, nil
+}
+
+// LoadDHCPv6Records loads the DHCPv6Records global map with records stored on
+// the specified file. The records have to be one per line, a mac address and an
+// IPv6 address.
+func LoadDHCPv6Records(filename string) (map[string]net.IP, error) {
+	log.Infof("reading leases from %s", filename)
+	data, err := os.ReadFile(filename)
+	if err != nil {
+		return nil, err
+	}
+	records := make(map[string]net.IP)
+	for _, lineBytes := range bytes.Split(data, []byte{'\n'}) {
+		line := string(lineBytes)
+		if len(line) == 0 {
+			continue
+		}
+		if strings.HasPrefix(line, "#") {
+			continue
+		}
+		tokens := strings.Fields(line)
+		if len(tokens) != 2 {
+			return nil, fmt.Errorf("malformed line, want 2 fields, got %d: %s", len(tokens), line)
+		}
+		hwaddr, err := net.ParseMAC(tokens[0])
+		if err != nil {
+			return nil, fmt.Errorf("malformed hardware address: %s", tokens[0])
+		}
+		ipaddr := net.ParseIP(tokens[1])
+		if ipaddr.To16() == nil || ipaddr.To4() != nil {
+			return nil, fmt.Errorf("expected an IPv6 address, got: %v", ipaddr)
+		}
+		records[hwaddr.String()] = ipaddr
+	}
+	return records, nil
+}
+
+// Handler6 handles DHCPv6 packets for the file plugin
+func Handler6(req, resp dhcpv6.DHCPv6) (dhcpv6.DHCPv6, bool) {
+	m, err := req.GetInnerMessage()
+	if err != nil {
+		log.Errorf("BUG: could not decapsulate: %v", err)
+		return nil, true
+	}
+
+	if m.Options.OneIANA() == nil {
+		log.Debug("No address requested")
+		return resp, false
+	}
+
+	mac, err := dhcpv6.ExtractMAC(req)
+	if err != nil {
+		log.Warningf("Could not find client MAC, passing")
+		return resp, false
+	}
+	log.Debugf("looking up an IP address for MAC %s", mac.String())
+
+	recLock.RLock()
+	defer recLock.RUnlock()
+
+	ipaddr, ok := StaticRecords[mac.String()]
+	if !ok {
+		log.Warningf("MAC address %s is unknown", mac.String())
+		return resp, false
+	}
+	log.Debugf("found IP address %s for MAC %s", ipaddr, mac.String())
+
+	resp.AddOption(&dhcpv6.OptIANA{
+		IaId: m.Options.OneIANA().IaId,
+		Options: dhcpv6.IdentityOptions{Options: []dhcpv6.Option{
+			&dhcpv6.OptIAAddress{
+				IPv6Addr:          ipaddr,
+				PreferredLifetime: 3600 * time.Second,
+				ValidLifetime:     3600 * time.Second,
+			},
+		}},
+	})
+	return resp, false
+}
+
+// Handler4 handles DHCPv4 packets for the file plugin
+func Handler4(req, resp *dhcpv4.DHCPv4) (*dhcpv4.DHCPv4, bool) {
+	recLock.RLock()
+	defer recLock.RUnlock()
+
+	ipaddr, ok := StaticRecords[req.ClientHWAddr.String()]
+	if !ok {
+		log.Warningf("MAC address %s is unknown", req.ClientHWAddr.String())
+		return resp, false
+	}
+	resp.YourIPAddr = ipaddr
+	log.Debugf("found IP address %s for MAC %s", ipaddr, req.ClientHWAddr.String())
+	return resp, true
+}
+
+func setup6(args ...string) (handler.Handler6, error) {
+	h6, _, err := setupFile(true, args...)
+	return h6, err
+}
+
+func setup4(args ...string) (handler.Handler4, error) {
+	_, h4, err := setupFile(false, args...)
+	return h4, err
+}
+
+func setupFile(v6 bool, args ...string) (handler.Handler6, handler.Handler4, error) {
+	var err error
+	if len(args) < 1 {
+		return nil, nil, errors.New("need a file name")
+	}
+	filename := args[0]
+	if filename == "" {
+		return nil, nil, errors.New("got empty file name")
+	}
+
+	// load initial database from lease file
+	if err = loadFromFile(v6, filename); err != nil {
+		return nil, nil, err
+	}
+
+	// when the 'autorefresh' argument was passed, watch the lease file for
+	// changes and reload the lease mapping on any event
+	if len(args) > 1 && args[1] == autoRefreshArg {
+		// creates a new file watcher
+		watcher, err := fsnotify.NewWatcher()
+		if err != nil {
+			return nil, nil, fmt.Errorf("failed to create watcher: %w", err)
+		}
+
+		// have file watcher watch over lease file
+		if err = watcher.Add(filename); err != nil {
+			return nil, nil, fmt.Errorf("failed to watch %s: %w", filename, err)
+		}
+
+		// very simple watcher on the lease file to trigger a refresh on any event
+		// on the file
+		go func() {
+			for range watcher.Events {
+				err := loadFromFile(v6, filename)
+				if err != nil {
+					log.Warningf("failed to refresh from %s: %s", filename, err)
+
+					continue
+				}
+
+				log.Infof("updated to %d leases from %s", len(StaticRecords), filename)
+			}
+		}()
+	}
+
+	log.Infof("loaded %d leases from %s", len(StaticRecords), filename)
+	return Handler6, Handler4, nil
+}
+
+func loadFromFile(v6 bool, filename string) error {
+	var err error
+	var records map[string]net.IP
+	var protver int
+	if v6 {
+		protver = 6
+		records, err = LoadDHCPv6Records(filename)
+	} else {
+		protver = 4
+		records, err = LoadDHCPv4Records(filename)
+	}
+	if err != nil {
+		return fmt.Errorf("failed to load DHCPv%d records: %w", protver, err)
+	}
+
+	recLock.Lock()
+	defer recLock.Unlock()
+
+	StaticRecords = records
+
+	return nil
+}
--- a/plugins/file/plugin_test.go
+++ b/plugins/file/plugin_test.go
@@ -0,0 +1,368 @@
+// Copyright 2018-present the CoreDHCP Authors. All rights reserved
+// This source code is licensed under the MIT license found in the
+// LICENSE file in the root directory of this source tree.
+
+package file
+
+import (
+	"net"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/insomniacslk/dhcp/dhcpv4"
+	"github.com/insomniacslk/dhcp/dhcpv6"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestLoadDHCPv4Records(t *testing.T) {
+	t.Run("valid leases", func(t *testing.T) {
+		// setup temp leases file
+		tmp, err := os.CreateTemp("", "test_plugin_file")
+		require.NoError(t, err)
+		defer func() {
+			tmp.Close()
+			os.Remove(tmp.Name())
+		}()
+
+		// fill temp file with valid lease lines and some comments
+		_, err = tmp.WriteString("00:11:22:33:44:55 192.0.2.100\n")
+		require.NoError(t, err)
+		_, err = tmp.WriteString("11:22:33:44:55:66 192.0.2.101\n")
+		require.NoError(t, err)
+		_, err = tmp.WriteString("# this is a comment\n")
+		require.NoError(t, err)
+
+		records, err := LoadDHCPv4Records(tmp.Name())
+		if !assert.NoError(t, err) {
+			return
+		}
+
+		if assert.Equal(t, 2, len(records)) {
+			if assert.Contains(t, records, "00:11:22:33:44:55") {
+				assert.Equal(t, net.ParseIP("192.0.2.100"), records["00:11:22:33:44:55"])
+			}
+			if assert.Contains(t, records, "11:22:33:44:55:66") {
+				assert.Equal(t, net.ParseIP("192.0.2.101"), records["11:22:33:44:55:66"])
+			}
+		}
+	})
+
+	t.Run("missing field", func(t *testing.T) {
+		// setup temp leases file
+		tmp, err := os.CreateTemp("", "test_plugin_file")
+		require.NoError(t, err)
+		defer func() {
+			tmp.Close()
+			os.Remove(tmp.Name())
+		}()
+
+		// add line with too few fields
+		_, err = tmp.WriteString("foo\n")
+		require.NoError(t, err)
+		_, err = LoadDHCPv4Records(tmp.Name())
+		assert.Error(t, err)
+	})
+
+	t.Run("invalid MAC", func(t *testing.T) {
+		// setup temp leases file
+		tmp, err := os.CreateTemp("", "test_plugin_file")
+		require.NoError(t, err)
+		defer func() {
+			tmp.Close()
+			os.Remove(tmp.Name())
+		}()
+
+		// add line with invalid MAC address to trigger an error
+		_, err = tmp.WriteString("abcd 192.0.2.102\n")
+		require.NoError(t, err)
+		_, err = LoadDHCPv4Records(tmp.Name())
+		assert.Error(t, err)
+	})
+
+	t.Run("invalid IP address", func(t *testing.T) {
+		// setup temp leases file
+		tmp, err := os.CreateTemp("", "test_plugin_file")
+		require.NoError(t, err)
+		defer func() {
+			tmp.Close()
+			os.Remove(tmp.Name())
+		}()
+
+		// add line with invalid MAC address to trigger an error
+		_, err = tmp.WriteString("22:33:44:55:66:77 bcde\n")
+		require.NoError(t, err)
+		_, err = LoadDHCPv4Records(tmp.Name())
+		assert.Error(t, err)
+	})
+
+	t.Run("lease with IPv6 address", func(t *testing.T) {
+		// setup temp leases file
+		tmp, err := os.CreateTemp("", "test_plugin_file")
+		require.NoError(t, err)
+		defer func() {
+			tmp.Close()
+			os.Remove(tmp.Name())
+		}()
+
+		// add line with IPv6 address instead to trigger an error
+		_, err = tmp.WriteString("00:11:22:33:44:55 2001:db8::10:1\n")
+		require.NoError(t, err)
+		_, err = LoadDHCPv4Records(tmp.Name())
+		assert.Error(t, err)
+	})
+}
+
+func TestLoadDHCPv6Records(t *testing.T) {
+	t.Run("valid leases", func(t *testing.T) {
+		// setup temp leases file
+		tmp, err := os.CreateTemp("", "test_plugin_file")
+		require.NoError(t, err)
+		defer func() {
+			tmp.Close()
+			os.Remove(tmp.Name())
+		}()
+
+		// fill temp file with valid lease lines and some comments
+		_, err = tmp.WriteString("00:11:22:33:44:55 2001:db8::10:1\n")
+		require.NoError(t, err)
+		_, err = tmp.WriteString("11:22:33:44:55:66 2001:db8::10:2\n")
+		require.NoError(t, err)
+		_, err = tmp.WriteString("# this is a comment\n")
+		require.NoError(t, err)
+
+		records, err := LoadDHCPv6Records(tmp.Name())
+		if !assert.NoError(t, err) {
+			return
+		}
+
+		if assert.Equal(t, 2, len(records)) {
+			if assert.Contains(t, records, "00:11:22:33:44:55") {
+				assert.Equal(t, net.ParseIP("2001:db8::10:1"), records["00:11:22:33:44:55"])
+			}
+			if assert.Contains(t, records, "11:22:33:44:55:66") {
+				assert.Equal(t, net.ParseIP("2001:db8::10:2"), records["11:22:33:44:55:66"])
+			}
+		}
+	})
+
+	t.Run("missing field", func(t *testing.T) {
+		// setup temp leases file
+		tmp, err := os.CreateTemp("", "test_plugin_file")
+		require.NoError(t, err)
+		defer func() {
+			tmp.Close()
+			os.Remove(tmp.Name())
+		}()
+
+		// add line with too few fields
+		_, err = tmp.WriteString("foo\n")
+		require.NoError(t, err)
+		_, err = LoadDHCPv6Records(tmp.Name())
+		assert.Error(t, err)
+	})
+
+	t.Run("invalid MAC", func(t *testing.T) {
+		// setup temp leases file
+		tmp, err := os.CreateTemp("", "test_plugin_file")
+		require.NoError(t, err)
+		defer func() {
+			tmp.Close()
+			os.Remove(tmp.Name())
+		}()
+
+		// add line with invalid MAC address to trigger an error
+		_, err = tmp.WriteString("abcd 2001:db8::10:3\n")
+		require.NoError(t, err)
+		_, err = LoadDHCPv6Records(tmp.Name())
+		assert.Error(t, err)
+	})
+
+	t.Run("invalid IP address", func(t *testing.T) {
+		// setup temp leases file
+		tmp, err := os.CreateTemp("", "test_plugin_file")
+		require.NoError(t, err)
+		defer func() {
+			tmp.Close()
+			os.Remove(tmp.Name())
+		}()
+
+		// add line with invalid MAC address to trigger an error
+		_, err = tmp.WriteString("22:33:44:55:66:77 bcde\n")
+		require.NoError(t, err)
+		_, err = LoadDHCPv6Records(tmp.Name())
+		assert.Error(t, err)
+	})
+
+	t.Run("lease with IPv4 address", func(t *testing.T) {
+		// setup temp leases file
+		tmp, err := os.CreateTemp("", "test_plugin_file")
+		require.NoError(t, err)
+		defer func() {
+			tmp.Close()
+			os.Remove(tmp.Name())
+		}()
+
+		// add line with IPv4 address instead to trigger an error
+		_, err = tmp.WriteString("00:11:22:33:44:55 192.0.2.100\n")
+		require.NoError(t, err)
+		_, err = LoadDHCPv6Records(tmp.Name())
+		assert.Error(t, err)
+	})
+}
+
+func TestHandler4(t *testing.T) {
+	t.Run("unknown MAC", func(t *testing.T) {
+		// prepare DHCPv4 request
+		mac := "00:11:22:33:44:55"
+		claddr, _ := net.ParseMAC(mac)
+		req := &dhcpv4.DHCPv4{
+			ClientHWAddr: claddr,
+		}
+		resp := &dhcpv4.DHCPv4{}
+		assert.Nil(t, resp.ClientIPAddr)
+
+		// if we handle this DHCP request, nothing should change since the lease is
+		// unknown
+		result, stop := Handler4(req, resp)
+		assert.Same(t, result, resp)
+		assert.False(t, stop)
+		assert.Nil(t, result.YourIPAddr)
+	})
+
+	t.Run("known MAC", func(t *testing.T) {
+		// prepare DHCPv4 request
+		mac := "00:11:22:33:44:55"
+		claddr, _ := net.ParseMAC(mac)
+		req := &dhcpv4.DHCPv4{
+			ClientHWAddr: claddr,
+		}
+		resp := &dhcpv4.DHCPv4{}
+		assert.Nil(t, resp.ClientIPAddr)
+
+		// add lease for the MAC in the lease map
+		clIPAddr := net.ParseIP("192.0.2.100")
+		StaticRecords = map[string]net.IP{
+			mac: clIPAddr,
+		}
+
+		// if we handle this DHCP request, the YourIPAddr field should be set
+		// in the result
+		result, stop := Handler4(req, resp)
+		assert.Same(t, result, resp)
+		assert.True(t, stop)
+		assert.Equal(t, clIPAddr, result.YourIPAddr)
+
+		// cleanup
+		StaticRecords = make(map[string]net.IP)
+	})
+}
+
+func TestHandler6(t *testing.T) {
+	t.Run("unknown MAC", func(t *testing.T) {
+		// prepare DHCPv6 request
+		mac := "11:22:33:44:55:66"
+		claddr, _ := net.ParseMAC(mac)
+		req, err := dhcpv6.NewSolicit(claddr)
+		require.NoError(t, err)
+		resp, err := dhcpv6.NewAdvertiseFromSolicit(req)
+		require.NoError(t, err)
+		assert.Equal(t, 0, len(resp.GetOption(dhcpv6.OptionIANA)))
+
+		// if we handle this DHCP request, nothing should change since the lease is
+		// unknown
+		result, stop := Handler6(req, resp)
+		assert.False(t, stop)
+		assert.Equal(t, 0, len(result.GetOption(dhcpv6.OptionIANA)))
+	})
+
+	t.Run("known MAC", func(t *testing.T) {
+		// prepare DHCPv6 request
+		mac := "11:22:33:44:55:66"
+		claddr, _ := net.ParseMAC(mac)
+		req, err := dhcpv6.NewSolicit(claddr)
+		require.NoError(t, err)
+		resp, err := dhcpv6.NewAdvertiseFromSolicit(req)
+		require.NoError(t, err)
+		assert.Equal(t, 0, len(resp.GetOption(dhcpv6.OptionIANA)))
+
+		// add lease for the MAC in the lease map
+		clIPAddr := net.ParseIP("2001:db8::10:1")
+		StaticRecords = map[string]net.IP{
+			mac: clIPAddr,
+		}
+
+		// if we handle this DHCP request, there should be a specific IANA option
+		// set in the resulting response
+		result, stop := Handler6(req, resp)
+		assert.False(t, stop)
+		if assert.Equal(t, 1, len(result.GetOption(dhcpv6.OptionIANA))) {
+			opt := result.GetOneOption(dhcpv6.OptionIANA)
+			assert.Contains(t, opt.String(), "IP=2001:db8::10:1")
+		}
+
+		// cleanup
+		StaticRecords = make(map[string]net.IP)
+	})
+}
+
+func TestSetupFile(t *testing.T) {
+	// too few arguments
+	_, _, err := setupFile(false)
+	assert.Error(t, err)
+
+	// empty file name
+	_, _, err = setupFile(false, "")
+	assert.Error(t, err)
+
+	// trigger error in LoadDHCPv*Records
+	_, _, err = setupFile(false, "/foo/bar")
+	assert.Error(t, err)
+
+	_, _, err = setupFile(true, "/foo/bar")
+	assert.Error(t, err)
+
+	// setup temp leases file
+	tmp, err := os.CreateTemp("", "test_plugin_file")
+	require.NoError(t, err)
+	defer func() {
+		tmp.Close()
+		os.Remove(tmp.Name())
+	}()
+
+	t.Run("typical case", func(t *testing.T) {
+		_, err = tmp.WriteString("00:11:22:33:44:55 2001:db8::10:1\n")
+		require.NoError(t, err)
+		_, err = tmp.WriteString("11:22:33:44:55:66 2001:db8::10:2\n")
+		require.NoError(t, err)
+
+		assert.Equal(t, 0, len(StaticRecords))
+
+		// leases should show up in StaticRecords
+		_, _, err = setupFile(true, tmp.Name())
+		if assert.NoError(t, err) {
+			assert.Equal(t, 2, len(StaticRecords))
+		}
+	})
+
+	t.Run("autorefresh enabled", func(t *testing.T) {
+		_, _, err = setupFile(true, tmp.Name(), autoRefreshArg)
+		if assert.NoError(t, err) {
+			assert.Equal(t, 2, len(StaticRecords))
+		}
+		// we add more leases to the file
+		// this should trigger an event to refresh the leases database
+		// without calling setupFile again
+		_, err = tmp.WriteString("22:33:44:55:66:77 2001:db8::10:3\n")
+		require.NoError(t, err)
+		// since the event is processed asynchronously, give it a little time
+		time.Sleep(time.Millisecond * 100)
+		// an additional record should show up in the database
+		// but we should respect the locking first
+		recLock.RLock()
+		defer recLock.RUnlock()
+
+		assert.Equal(t, 3, len(StaticRecords))
+	})
+}