server_udp_linux.go

// File: server_udp_linux.go
// Version: 1.6.0
// Last Updated: 15-Oct-2026 18:55 CEST
// Description: Linux-only SO_REUSEPORT UDP listener pool.
// Changes:
//   1.6.0 - [SECURITY/FIX] Wrapped each SO_REUSEPORT UDP worker in `superviseListener`
//           and tied socket closure to `shutdownCh`. Previously, any transient runtime
//           error from `ActivateAndServe()` triggered `log.Fatalf`, killing the entire
//           daemon (including healthy TCP/DoT/DoH/DoQ listeners), and `Shutdown()` did
//           not close active UDP sockets.
//   1.5.0 - [SECURITY/FIX] handleUDPDirect performed a bare type assertion to
//           *net.UDPAddr and left the client IP empty on failure, producing an
//           unidentifiable origin. Combined with the fail-open admission gate
//           that existed prior to process_security.go 1.15.0, that meant such a
//           query bypassed both the ACL and the rate limiter. Now uses the
//           shared, type-agnostic remoteIPFromAddr() helper (server.go 1.36.0).
//   1.4.0 - [LOGGING] Bound port multiplexing allocations organically to `logSystem`.
//   1.3.0 - [PERF/SECURITY] Implemented dynamically scaling UDP ring-buffers 
//           (`SO_RCVBUF`, `SO_SNDBUF`) bounded natively to the configured 
//           system `memory_limit_mb`. Severely neutralizes embedded router 
//           Out-Of-Memory (OOM) killer crashes instigated by 8MB unswappable allocations.

//go:build linux

package main

import (
	"context"
	"fmt"
	"log"
	"net"
	"syscall"

	"github.com/miekg/dns"
	"golang.org/x/sys/unix"
)

func startUDPServers(addrs []string, workers int) {
	if len(addrs) == 0 {
		return
	}
	if workers <= 0 {
		workers = 10
	}
	for _, addr := range addrs {
		addr := addr
		for i := 0; i < workers; i++ {
			workerID := i
			protoLabel := fmt.Sprintf("UDP-worker-%d", workerID)
			go superviseListener(protoLabel, addr, func(attempt int) error {
				err := runReusePortWorker(addr, workerID, workers)
				if err != nil && attempt == 0 {
					log.Fatalf("[FATAL] UDP SO_REUSEPORT worker %d on %s: %v", workerID, addr, err)
				}
				return err
			})
		}
		if logSystem {
			log.Printf("[LISTEN] UDP on %s (%d SO_REUSEPORT workers)", addr, workers)
		}
	}
}

func runReusePortWorker(addr string, _ int, workers int) error {
	conn, err := newReusePortConn(addr, workers)
	if err != nil {
		return err
	}
	srv := &dns.Server{
		PacketConn: conn,
		Net:        "udp",
		Handler:    dns.HandlerFunc(handleUDPDirect),
	}

	served := make(chan struct{})
	defer close(served)
	go func() {
		select {
		case <-shutdownCh:
			_ = srv.Shutdown()
		case <-served:
		}
	}()

	return srv.ActivateAndServe()
}

func handleUDPDirect(w dns.ResponseWriter, r *dns.Msg) {
	// [SECURITY 1.5.0] Type-agnostic extraction.
	ip := remoteIPFromAddr(w.RemoteAddr())
	ProcessDNS(w, r, ip, "UDP", "", "")
}

func newReusePortConn(addr string, workers int) (net.PacketConn, error) {
	lc := net.ListenConfig{
		Control: func(network, address string, c syscall.RawConn) error {
			var setSockOptErr error
			err := c.Control(func(fd uintptr) {
				if err := unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_REUSEADDR, 1); err != nil {
					setSockOptErr = err
					return
				}
				if err := unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_REUSEPORT, 1); err != nil {
					setSockOptErr = err
					return
				}

				totalBudget := 8 * 1024 * 1024 // 8MB total default (unbounded or >=1024MB host)
				switch {
				case cfg.Server.MemoryLimitMB > 0 && cfg.Server.MemoryLimitMB < 128:
					totalBudget = 1024 * 1024
				case cfg.Server.MemoryLimitMB >= 128 && cfg.Server.MemoryLimitMB < 512:
					totalBudget = 2 * 1024 * 1024
				case cfg.Server.MemoryLimitMB >= 512 && cfg.Server.MemoryLimitMB < 1024:
					totalBudget = 4 * 1024 * 1024
				}

				w := workers
				if w <= 0 {
					w = 1
				}
				bufferSize := totalBudget / w
				const minBufferSize = 64 * 1024 // floor — below this, kernel buffering stops helping under burst load
				if bufferSize < minBufferSize {
					bufferSize = minBufferSize
				}

				_ = unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_RCVBUF, bufferSize)
				_ = unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_SNDBUF, bufferSize)
			})
			if err != nil {
				return err
			}
			return setSockOptErr
		},
	}
	return lc.ListenPacket(context.Background(), "udp", addr)
}