two/internal/hostsvc/service.go
GnomeZworc d4b83bdb17
f-86: hostsvc: relais DNS et NTP par hôte, socket de contrôle #86
Signed-off-by: GnomeZworc <nicolas.boufidjeline@g3e.fr>
2026-10-26 23:25:04 +01:00

362 lines
8 KiB
Go

package hostsvc
import (
"errors"
"fmt"
"io"
"log/slog"
"net"
"sort"
"strings"
"sync"
"time"
"git.g3e.fr/syonad/two/pkg/db/statefile"
)
const (
ServiceIP = "169.254.169.253"
DefaultResolv = "/etc/resolv.conf"
DefaultTimeout = 2 * time.Second
tcpIdle = 10 * time.Second
maxTCPConns = 16
)
type Options struct {
DNS []string
NTP []string
Rate int
Resolv string
DNSListen string
NTPListen string
Timeout time.Duration
Clock Clock
Enter func(vpc string, fn func() error) error
Exists func(vpc string) bool
Logger *slog.Logger
}
func (o Options) withDefaults() Options {
if o.Resolv == "" {
o.Resolv = DefaultResolv
}
if o.DNSListen == "" {
o.DNSListen = net.JoinHostPort(ServiceIP, "53")
}
if o.NTPListen == "" {
o.NTPListen = net.JoinHostPort(ServiceIP, "123")
}
if o.Timeout == 0 {
o.Timeout = DefaultTimeout
}
if o.Clock == nil {
o.Clock = SystemClock{}
}
if o.Enter == nil {
o.Enter = enterNetns
}
if o.Exists == nil {
o.Exists = netnsExists
}
if o.Logger == nil {
o.Logger = slog.New(slog.NewTextHandler(io.Discard, nil))
}
return o
}
type State struct {
VPCs []string `json:"vpcs"`
}
type Service struct {
opts Options
state *statefile.File[State]
mu sync.Mutex
vpcs map[string]*instance
}
func New(opts Options, statePath string) (*Service, error) {
if opts.Rate <= 0 {
return nil, fmt.Errorf("rate limit %d must be a positive number of requests per second", opts.Rate)
}
return &Service{
opts: opts.withDefaults(),
state: statefile.New[State](statePath),
vpcs: map[string]*instance{},
}, nil
}
func validVPC(vpc string) error {
if vpc == "" || vpc == "." || vpc == ".." || strings.ContainsAny(vpc, "/\x00") {
return fmt.Errorf("invalid vpc name %q", vpc)
}
return nil
}
func (s *Service) Restore() error {
saved, err := s.state.Load()
if err != nil {
return err
}
s.mu.Lock()
defer s.mu.Unlock()
var errs []error
for _, vpc := range saved.VPCs {
if !s.opts.Exists(vpc) {
s.opts.Logger.Info("netns gone, vpc dropped from the state", "vpc", vpc)
continue
}
if err := s.open(vpc); err != nil {
errs = append(errs, err)
}
}
if err := s.save(); err != nil {
errs = append(errs, err)
}
return errors.Join(errs...)
}
func (s *Service) Open(vpc string) error {
if err := validVPC(vpc); err != nil {
return err
}
s.mu.Lock()
defer s.mu.Unlock()
if _, open := s.vpcs[vpc]; open {
return nil
}
if err := s.open(vpc); err != nil {
return err
}
return s.save()
}
func (s *Service) Close(vpc string) error {
if err := validVPC(vpc); err != nil {
return err
}
s.mu.Lock()
defer s.mu.Unlock()
inst, open := s.vpcs[vpc]
if !open {
return nil
}
delete(s.vpcs, vpc)
err := inst.close()
return errors.Join(err, s.save())
}
func (s *Service) List() []string {
s.mu.Lock()
defer s.mu.Unlock()
return s.names()
}
func (s *Service) Shutdown() error {
s.mu.Lock()
defer s.mu.Unlock()
var errs []error
for vpc, inst := range s.vpcs {
errs = append(errs, inst.close())
delete(s.vpcs, vpc)
}
return errors.Join(errs...)
}
func (s *Service) names() []string {
out := make([]string, 0, len(s.vpcs))
for vpc := range s.vpcs {
out = append(out, vpc)
}
sort.Strings(out)
return out
}
func (s *Service) save() error {
return s.state.Save(State{VPCs: s.names()})
}
func (s *Service) open(vpc string) error {
inst := &instance{
vpc: vpc,
svc: s,
limit: newLimiter(s.opts.Rate, time.Now),
conns: make(chan struct{}, maxTCPConns),
log: s.opts.Logger.With("vpc", vpc),
}
dns, ntp := s.opts.DNSListen, s.opts.NTPListen
err := s.opts.Enter(vpc, func() error {
var err error
if inst.udpDNS, err = net.ListenPacket("udp4", dns); err != nil {
return fmt.Errorf("listen udp %s: %w", dns, err)
}
if inst.tcpDNS, err = net.Listen("tcp4", dns); err != nil {
return fmt.Errorf("listen tcp %s: %w", dns, err)
}
if inst.udpNTP, err = net.ListenPacket("udp4", ntp); err != nil {
return fmt.Errorf("listen udp %s: %w", ntp, err)
}
return nil
})
if err != nil {
return errors.Join(fmt.Errorf("open vpc %s: %w", vpc, err), inst.close())
}
inst.serve()
s.vpcs[vpc] = inst
inst.log.Info("vpc served", "dns", dns, "ntp", ntp)
return nil
}
func (s *Service) dnsServers() []string {
servers := append([]string{}, s.opts.DNS...)
host, err := resolvers(s.opts.Resolv)
if err != nil {
s.opts.Logger.Warn("host resolver unreadable", "error", err)
}
return append(servers, host...)
}
func (s *Service) ntpAnswer(request []byte, received time.Time) []byte {
if len(s.opts.NTP) > 0 {
answer, err := exchangeNTP(s.opts.NTP, request, s.opts.Timeout)
if err == nil {
return answer
}
s.opts.Logger.Warn("ntp upstreams failed, answering from the host clock", "error", err)
}
synced, maxError, err := s.opts.Clock.Sync()
if err != nil {
s.opts.Logger.Warn("host clock status unreadable, answering as unsynchronized", "error", err)
synced = false
}
return hostReply(request, received, s.opts.Clock.Now(), synced, maxError)
}
type instance struct {
vpc string
svc *Service
limit *limiter
conns chan struct{}
log *slog.Logger
udpDNS net.PacketConn
tcpDNS net.Listener
udpNTP net.PacketConn
wg sync.WaitGroup
}
func (i *instance) serve() {
i.wg.Add(3)
go i.loopUDP(i.udpDNS, i.answerDNS)
go i.loopUDP(i.udpNTP, i.answerNTP)
go i.loopTCP()
}
func (i *instance) close() error {
var errs []error
for _, c := range []interface{ Close() error }{i.udpDNS, i.tcpDNS, i.udpNTP} {
if c == nil {
continue
}
if err := c.Close(); err != nil && !errors.Is(err, net.ErrClosed) {
errs = append(errs, err)
}
}
i.wg.Wait()
return errors.Join(errs...)
}
func (i *instance) loopUDP(conn net.PacketConn, answer func([]byte, time.Time) ([]byte, error)) {
defer i.wg.Done()
buf := make([]byte, maxDNSMessage)
for {
n, from, err := conn.ReadFrom(buf)
if err != nil {
if !errors.Is(err, net.ErrClosed) {
i.log.Error("udp socket stopped", "error", err)
}
return
}
received := i.svc.opts.Clock.Now()
if !i.limit.allow() {
i.log.Debug("rate limit reached, request dropped", "from", from)
continue
}
request := append([]byte{}, buf[:n]...)
go func() {
reply, err := answer(request, received)
if err != nil {
i.log.Debug("request dropped", "from", from, "error", err)
return
}
if _, err := conn.WriteTo(reply, from); err != nil && !errors.Is(err, net.ErrClosed) {
i.log.Debug("reply not sent", "to", from, "error", err)
}
}()
}
}
func (i *instance) answerDNS(query []byte, _ time.Time) ([]byte, error) {
if err := validQuery(query); err != nil {
return nil, err
}
return exchangeUDP(i.svc.dnsServers(), query, i.svc.opts.Timeout)
}
func (i *instance) answerNTP(request []byte, received time.Time) ([]byte, error) {
if err := validNTPRequest(request); err != nil {
return nil, err
}
return i.svc.ntpAnswer(request, received), nil
}
func (i *instance) loopTCP() {
defer i.wg.Done()
for {
conn, err := i.tcpDNS.Accept()
if err != nil {
if !errors.Is(err, net.ErrClosed) {
i.log.Error("tcp socket stopped", "error", err)
}
return
}
select {
case i.conns <- struct{}{}:
go func() {
defer func() { <-i.conns }()
i.serveTCP(conn)
}()
default:
i.log.Debug("too many tcp connections, connection refused", "from", conn.RemoteAddr())
conn.Close()
}
}
}
func (i *instance) serveTCP(conn net.Conn) {
defer conn.Close()
for {
if err := conn.SetDeadline(time.Now().Add(tcpIdle)); err != nil {
return
}
query, err := readTCPMessage(conn)
if err != nil {
return
}
if !i.limit.allow() {
i.log.Debug("rate limit reached, connection closed", "from", conn.RemoteAddr())
return
}
if err := validQuery(query); err != nil {
i.log.Debug("request dropped", "from", conn.RemoteAddr(), "error", err)
return
}
answer, err := exchangeTCP(i.svc.dnsServers(), query, i.svc.opts.Timeout)
if err != nil {
i.log.Debug("request dropped", "from", conn.RemoteAddr(), "error", err)
return
}
if err := writeTCPMessage(conn, answer); err != nil {
return
}
}
}