f-86: hostsvc: relais DNS et NTP par hôte, socket de contrôle #86
Signed-off-by: GnomeZworc <nicolas.boufidjeline@g3e.fr>
This commit is contained in:
parent
da6295baf1
commit
aa1cc58ae3
20 changed files with 2235 additions and 0 deletions
362
internal/hostsvc/service.go
Normal file
362
internal/hostsvc/service.go
Normal file
|
|
@ -0,0 +1,362 @@
|
|||
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
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue