362 lines
8 KiB
Go
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
|
|
}
|
|
}
|
|
}
|