WIP: Update to use ipv4.PacketConn:

ipv4.PacketConn allows us to have the interface
from which the packet was received. This is helpful
as we must listen to all interfaces in order to
get broadcast traffic.

Signed-off-by: Jacob Weinstock <[email protected]>

Author: jacobweinstock

.golangci.yml

@@ -102,7 +102,6 @@ linters:
     - asciicheck
     - bodyclose
     - cyclop
-    - deadcode
     - dogsled
     - dupl
     - durationcheck
@@ -124,7 +123,6 @@ linters:
     - goprintffuncname
     - gosimple
     - govet
-    - ifshort
     - importas
     - ineffassign
     - makezero
@@ -141,15 +139,13 @@ linters:
     - rowserrcheck
     - sqlclosecheck
     - staticcheck
-    - structcheck
     - stylecheck
     - thelper
     - tparallel
     - typecheck
     - unconvert
     - unparam
     - unused
-    - varcheck
     - wastedassign
     - whitespace
 

Makefile

@@ -51,7 +51,7 @@ LINTERS :=
 FIXERS :=
 
 GOLANGCI_LINT_CONFIG := $(LINT_ROOT)/.golangci.yml
-GOLANGCI_LINT_VERSION ?= v1.53.3
+GOLANGCI_LINT_VERSION ?= v1.54.2
 GOLANGCI_LINT_BIN := out/linters/golangci-lint-$(GOLANGCI_LINT_VERSION)-$(LINT_ARCH)
 $(GOLANGCI_LINT_BIN):
 	mkdir -p out/linters
@@ -61,11 +61,11 @@ $(GOLANGCI_LINT_BIN):
 
 LINTERS += golangci-lint-lint
 golangci-lint-lint: $(GOLANGCI_LINT_BIN)
-	find . -name go.mod -execdir sh -c '"$(GOLANGCI_LINT_BIN)" run -c "$(GOLINT_CONFIG)"' '{}' '+'
+	find . -name go.mod -execdir sh -c '"$(GOLANGCI_LINT_BIN)" run -c "$(GOLANGCI_LINT_CONFIG)"' '{}' '+'
 
 FIXERS += golangci-lint-fix
 golangci-lint-fix: $(GOLANGCI_LINT_BIN)
-	find . -name go.mod -execdir "$(GOLANGCI_LINT_BIN)" run -c "$(GOLINT_CONFIG)" --fix \;
+	find . -name go.mod -execdir "$(GOLANGCI_LINT_BIN)" run -c "$(GOLANGCI_LINT_CONFIG)" --fix \;
 
 .PHONY: _lint $(LINTERS)
 _lint: $(LINTERS)

backend/kube/error.go

@@ -0,0 +1,7 @@
+package kube
+
+type hardwareNotFoundError struct{}
+
+func (hardwareNotFoundError) NotFound() bool { return true }
+
+func (hardwareNotFoundError) Error() string { return "hardware not found" }

backend/kube/kube.go

@@ -82,7 +82,7 @@ func (b *Backend) GetByMac(ctx context.Context, mac net.HardwareAddr) (*data.DHC
 	}
 
 	if len(hardwareList.Items) == 0 {
-		err := errors.New("no hardware found")
+		err := hardwareNotFoundError{}
 		span.SetStatus(codes.Error, err.Error())
 
 		return nil, nil, err
@@ -139,7 +139,7 @@ func (b *Backend) GetByIP(ctx context.Context, ip net.IP) (*data.DHCP, *data.Net
 	}
 
 	if len(hardwareList.Items) == 0 {
-		err := errors.New("no hardware found")
+		err := hardwareNotFoundError{}
 		span.SetStatus(codes.Error, err.Error())
 
 		return nil, nil, err

data/data.go

@@ -7,9 +7,28 @@ import (
 	"net/url"
 	"strings"
 
+	"github.com/insomniacslk/dhcp/dhcpv4"
 	"go.opentelemetry.io/otel/attribute"
 )
 
+// Packet holds the data that is passed to a DHCP handler.
+type Packet struct {
+	// Peer is the address of the client that sent the DHCP message.
+	Peer net.Addr
+	// Pkt is the DHCP message.
+	Pkt *dhcpv4.DHCPv4
+	// Md is the metadata that was passed to the DHCP server.
+	Md *Metadata
+}
+
+// Metadata holds metadata about the DHCP packet that was received.
+type Metadata struct {
+	// IfName is the name of the interface that the DHCP message was received on.
+	IfName string
+	// IfIndex is the index of the interface that the DHCP message was received on.
+	IfIndex int
+}
+
 // DHCP holds the DHCP headers and options to be set in a DHCP handler response.
 // This is the API between a DHCP handler and a backend.
 type DHCP struct {

dhcp.go

@@ -2,18 +2,14 @@
 package dhcp
 
 import (
-	"context"
-	"errors"
 	"fmt"
 	"net"
 	"net/netip"
 
-	"dario.cat/mergo"
-	"github.com/insomniacslk/dhcp/dhcpv4"
 	"github.com/insomniacslk/dhcp/dhcpv4/server4"
-	"github.com/tinkerbell/dhcp/handler/noop"
 )
 
+/*
 // ErrNoConn is an error im still not sure i want to use.
 var ErrNoConn = &noConnError{}
 
@@ -23,25 +19,28 @@ func (e *noConnError) Error() string {
 	return "no connection specified"
 }
 
+
+
 // Listener is a DHCPv4 server.
 type Listener struct {
 	Addr     netip.AddrPort
-	srv      *server4.Server
+	Log      logr.Logger
+	srv      *Server
 	handlers []Handler
 }
 
 // Handler is the interface is responsible for responding to DHCP messages.
-type Handler interface {
-	// Handle is used for how to respond to DHCP messages.
-	Handle(net.PacketConn, net.Addr, *dhcpv4.DHCPv4)
-}
+//type Handler interface {
+// Handle is used for how to respond to DHCP messages.
+//	Handle(net.PacketConn, net.Addr, *dhcpv4.DHCPv4)
+//}
 
 // Handler is the main handler passed to the server4 function.
 // Internally it allows for multiple handlers to be defined.
 // Each handler in l.handlers then executed for every received packet.
-func (l *Listener) Handler(conn net.PacketConn, peer net.Addr, pkt *dhcpv4.DHCPv4) {
-	for _, h := range l.handlers {
-		h.Handle(conn, peer, pkt)
+func (l *Listener) Handler(ctx context.Context, conn net.PacketConn, data data.Packet) {
+	for _, handle := range l.handlers {
+		handle(ctx, conn, data)
 	}
 }
 
@@ -56,19 +55,20 @@ func Serve(ctx context.Context, c net.PacketConn, h ...Handler) error {
 // If no handler is specified, a Noop handler will be used.
 func (l *Listener) Serve(ctx context.Context, c net.PacketConn) error {
 	if len(l.handlers) == 0 {
-		l.handlers = append(l.handlers, &noop.Handler{})
+		nop := &noop.Handler{}
+		l.handlers = append(l.handlers, nop.Handle)
 	}
 	if c == nil {
 		return ErrNoConn
 	}
-	dhcp, err := server4.NewServer("", nil, l.Handler, server4.WithConn(c))
+	dhcp, err := NewServer("", nil, l.handlers, WithConn(c), WithLogger(l.Log))
 	if err != nil {
 		return fmt.Errorf("failed to create dhcpv4 server: %w", err)
 	}
 
 	errCh := make(chan error, 1)
 	go func() {
-		err = dhcp.Serve()
+		err = dhcp.Serve(ctx)
 		if err != nil {
 			errCh <- err
 		}
@@ -85,7 +85,8 @@ func (l *Listener) Serve(ctx context.Context, c net.PacketConn) error {
 // ListenAndServe will listen for DHCP messages and call the given handler for each.
 func (l *Listener) ListenAndServe(ctx context.Context, h ...Handler) error {
 	if len(h) == 0 {
-		l.handlers = append(l.handlers, &noop.Handler{})
+		nop := &noop.Handler{}
+		l.handlers = append(l.handlers, nop.Handle)
 	}
 	l.handlers = h
 	defaults := &Listener{
@@ -98,6 +99,8 @@ func (l *Listener) ListenAndServe(ctx context.Context, h ...Handler) error {
 	addr := &net.UDPAddr{
 		IP:   l.Addr.Addr().AsSlice(),
 		Port: int(l.Addr.Port()),
+		//IP:   defaults.Addr.Addr().AsSlice(),
+		//Port: int(defaults.Addr.Port()),
 	}
 	conn, err := server4.NewIPv4UDPConn("", addr)
 	if err != nil {
@@ -115,3 +118,14 @@ func (l *Listener) Shutdown() error {
 
 	return l.srv.Close()
 }
+*/
+
+// NewConn creates a new UDP connection.
+func NewConn(addr netip.AddrPort) (net.PacketConn, error) {
+	conn, err := server4.NewIPv4UDPConn("", &net.UDPAddr{IP: addr.Addr().AsSlice(), Port: int(addr.Port())})
+	if err != nil {
+		return nil, fmt.Errorf("failed to create udp connection: %w", err)
+	}
+
+	return conn, nil
+}

dhcp_test.go

@@ -1,21 +1,6 @@
 package dhcp
 
-import (
-	"context"
-	"errors"
-	"net"
-	"net/netip"
-	"testing"
-	"time"
-
-	"github.com/go-logr/logr"
-	"github.com/google/go-cmp/cmp"
-	"github.com/insomniacslk/dhcp/dhcpv4"
-	"github.com/insomniacslk/dhcp/dhcpv4/nclient4"
-	"github.com/tinkerbell/dhcp/handler/noop"
-	"golang.org/x/net/nettest"
-)
-
+/*
 type mock struct {
 	Log         logr.Logger
 	ServerIP    net.IP
@@ -26,13 +11,13 @@ type mock struct {
 	Router      net.IP
 }
 
-func (m *mock) Handle(conn net.PacketConn, peer net.Addr, pkt *dhcpv4.DHCPv4) {
+func (m *mock) Handle(ctx context.Context, conn net.PacketConn, d data.Packet) {
 	if m.Log.GetSink() == nil {
 		m.Log = logr.Discard()
 	}
 
 	mods := m.setOpts()
-	switch mt := pkt.MessageType(); mt {
+	switch mt := d.Pkt.MessageType(); mt {
 	case dhcpv4.MessageTypeDiscover:
 		mods = append(mods, dhcpv4.WithMessageType(dhcpv4.MessageTypeOffer))
 	case dhcpv4.MessageTypeRequest:
@@ -43,12 +28,12 @@ func (m *mock) Handle(conn net.PacketConn, peer net.Addr, pkt *dhcpv4.DHCPv4) {
 		m.Log.Info("unsupported message type", "type", mt.String())
 		return
 	}
-	reply, err := dhcpv4.NewReplyFromRequest(pkt, mods...)
+	reply, err := dhcpv4.NewReplyFromRequest(d.Pkt, mods...)
 	if err != nil {
 		m.Log.Error(err, "error creating reply")
 		return
 	}
-	if _, err := conn.WriteTo(reply.ToBytes(), peer); err != nil {
+	if _, err := conn.WriteTo(reply.ToBytes(), d.Peer); err != nil {
 		m.Log.Error(err, "failed to send reply")
 		return
 	}
@@ -69,6 +54,8 @@ func (m *mock) setOpts() []dhcpv4.Modifier {
 	return mods
 }
 
+
+
 func dhcp(ctx context.Context) (*dhcpv4.DHCPv4, error) {
 	rifs, err := nettest.RoutedInterface("ip", net.FlagUp|net.FlagBroadcast)
 	if err != nil {
@@ -86,24 +73,22 @@ func dhcp(ctx context.Context) (*dhcpv4.DHCPv4, error) {
 	return c.DiscoverOffer(ctx)
 }
 
+
 func TestListenAndServe(t *testing.T) {
 	// test if the server is listening on the correct address and port
 	tests := map[string]struct {
 		h            Handler
 		addr         netip.AddrPort
 		wantListener *Listener
 	}{
-		"success": {addr: netip.MustParseAddrPort("127.0.0.1:7676"), h: &mock{}},
+		"success": {addr: netip.MustParseAddrPort("127.0.0.1:7676"), h: func() Handler { m := &mock{}; return m.Handle }()},
 	}
 	for name, tt := range tests {
 		t.Run(name, func(t *testing.T) {
 			s := &Listener{Addr: tt.addr}
 			t.Logf("before: %+v", s)
 			ctx, done := context.WithCancel(context.Background())
 			defer done()
-			go func() {
-				<-ctx.Done()
-			}()
 
 			go s.ListenAndServe(ctx, tt.h)
 
@@ -125,10 +110,10 @@ func TestListenerAndServe(t *testing.T) {
 		addr netip.AddrPort
 		err  error
 	}{
-		"noop handler":             {h: &noop.Handler{}, addr: netip.MustParseAddrPort("0.0.0.0:7678")},
+		"noop handler":             {h: func() Handler { m := &noop.Handler{}; return m.Handle }(), addr: netip.MustParseAddrPort("0.0.0.0:7678")},
 		"no handler":               {addr: netip.MustParseAddrPort("0.0.0.0:7678")},
-		"mock handler":             {h: &mock{}, addr: netip.MustParseAddrPort("0.0.0.0:7678")},
-		"success use default addr": {h: &mock{}},
+		"mock handler":             {h: func() Handler { m := &mock{}; return m.Handle }(), addr: netip.MustParseAddrPort("0.0.0.0:7678")},
+		"success use default addr": {h: func() Handler { m := &mock{}; return m.Handle }()},
 	}
 	for name, tt := range tests {
 		t.Run(name, func(t *testing.T) {
@@ -139,21 +124,30 @@ func TestListenerAndServe(t *testing.T) {
 			defer done()
 
 			err := s.ListenAndServe(ctx, tt.h)
-			if err != tt.err && err.Error() != "failed to create udp connection: cannot bind to port 67: permission denied" && !errors.Is(err, ErrNoConn) { //nolint:errorlint // nil pointer dereference without this.
+			if err != tt.err && err.Error() != "failed to create udp connection: cannot bind to port 67: permission denied" && !errors.Is(err, ErrNoConn) && !closeConnErr(err) { //nolint:errorlint // nil pointer dereference without this.
 				t.Log(err)
 				t.Fatalf("got: %T, wanted: %T or ErrNoConn", err, &net.OpError{})
 			}
 		})
 	}
 }
 
+func closeConnErr(err error) bool {
+	l, ok := err.(*net.OpError)
+	if !ok {
+		return false
+	}
+
+	return l.Op == "close"
+}
+
 func TestServe(t *testing.T) {
 	tests := map[string]struct {
 		h    Handler
 		addr netip.AddrPort
 		err  error
 	}{
-		"noop handler": {addr: netip.MustParseAddrPort("0.0.0.0:7676"), h: &noop.Handler{}},
+		"noop handler": {addr: netip.MustParseAddrPort("0.0.0.0:7676"), h: func() Handler { m := &noop.Handler{}; return m.Handle }()},
 		"no handler":   {addr: netip.MustParseAddrPort("0.0.0.0:7678")},
 	}
 	for name, tt := range tests {
@@ -183,3 +177,4 @@ func TestNoConnError(t *testing.T) {
 		t.Fatal(diff)
 	}
 }
+*/

example/fileBackend/main.go

@@ -47,9 +47,17 @@ func main() {
 		OTELEnabled: true,
 		Backend:     backend,
 	}
-	listener := &dhcp.Listener{}
+	conn, err := dhcp.NewConn(netip.MustParseAddrPort("0.0.0.0:67"))
+	if err != nil {
+		panic(err)
+	}
+
+	defer func() {
+		_ = conn.Close()
+	}()
+	server := &dhcp.Server{Logger: l, Conn: conn, Handlers: []dhcp.Handler{h}}
 	l.Info("starting server", "addr", h.IPAddr)
-	l.Error(listener.ListenAndServe(ctx, h), "done")
+	l.Error(server.Serve(ctx), "done")
 	l.Info("done")
 }