two/internal/hostsvc/dns.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

162 lines
3.9 KiB
Go

package hostsvc
import (
"bufio"
"encoding/binary"
"errors"
"fmt"
"io"
"net"
"os"
"strings"
"time"
)
const (
dnsHeaderLen = 12
maxDNSMessage = 65535
)
func validQuery(b []byte) error {
if len(b) < dnsHeaderLen {
return fmt.Errorf("dns message of %d bytes is shorter than its header", len(b))
}
if b[2]&0x80 != 0 {
return errors.New("dns message is a response, not a query")
}
if op := (b[2] >> 3) & 0x0f; op != 0 {
return fmt.Errorf("dns opcode %d is not a standard query", op)
}
if n := binary.BigEndian.Uint16(b[4:6]); n != 1 {
return fmt.Errorf("dns query carries %d questions, want 1", n)
}
return nil
}
func validAnswer(query, answer []byte) error {
if len(answer) < dnsHeaderLen {
return fmt.Errorf("dns answer of %d bytes is shorter than its header", len(answer))
}
if answer[0] != query[0] || answer[1] != query[1] {
return errors.New("dns answer id does not match the query")
}
if answer[2]&0x80 == 0 {
return errors.New("dns answer is not flagged as a response")
}
return nil
}
func resolvers(path string) ([]string, error) {
f, err := os.Open(path)
if err != nil {
return nil, fmt.Errorf("open %s: %w", path, err)
}
defer f.Close()
var out []string
scanner := bufio.NewScanner(f)
for scanner.Scan() {
fields := strings.Fields(scanner.Text())
if len(fields) < 2 || fields[0] != "nameserver" || net.ParseIP(fields[1]) == nil {
continue
}
out = append(out, net.JoinHostPort(fields[1], "53"))
}
if err := scanner.Err(); err != nil {
return nil, fmt.Errorf("read %s: %w", path, err)
}
return out, nil
}
func exchangeUDP(servers []string, query []byte, timeout time.Duration) ([]byte, error) {
var errs []error
for _, server := range servers {
answer, err := exchangeUDPOne(server, query, timeout)
if err == nil {
return answer, nil
}
errs = append(errs, fmt.Errorf("%s: %w", server, err))
}
return nil, fmt.Errorf("no dns upstream answered: %w", errors.Join(errs...))
}
func exchangeUDPOne(server string, query []byte, timeout time.Duration) ([]byte, error) {
conn, err := net.DialTimeout("udp", server, timeout)
if err != nil {
return nil, err
}
defer conn.Close()
if err := conn.SetDeadline(time.Now().Add(timeout)); err != nil {
return nil, err
}
if _, err := conn.Write(query); err != nil {
return nil, err
}
buf := make([]byte, maxDNSMessage)
for {
n, err := conn.Read(buf)
if err != nil {
return nil, err
}
if validAnswer(query, buf[:n]) == nil {
return buf[:n], nil
}
}
}
func exchangeTCP(servers []string, query []byte, timeout time.Duration) ([]byte, error) {
var errs []error
for _, server := range servers {
answer, err := exchangeTCPOne(server, query, timeout)
if err == nil {
return answer, nil
}
errs = append(errs, fmt.Errorf("%s: %w", server, err))
}
return nil, fmt.Errorf("no dns upstream answered: %w", errors.Join(errs...))
}
func exchangeTCPOne(server string, query []byte, timeout time.Duration) ([]byte, error) {
conn, err := net.DialTimeout("tcp", server, timeout)
if err != nil {
return nil, err
}
defer conn.Close()
if err := conn.SetDeadline(time.Now().Add(timeout)); err != nil {
return nil, err
}
if err := writeTCPMessage(conn, query); err != nil {
return nil, err
}
answer, err := readTCPMessage(conn)
if err != nil {
return nil, err
}
if err := validAnswer(query, answer); err != nil {
return nil, err
}
return answer, nil
}
func readTCPMessage(r io.Reader) ([]byte, error) {
var size [2]byte
if _, err := io.ReadFull(r, size[:]); err != nil {
return nil, err
}
msg := make([]byte, binary.BigEndian.Uint16(size[:]))
if _, err := io.ReadFull(r, msg); err != nil {
return nil, err
}
return msg, nil
}
func writeTCPMessage(w io.Writer, msg []byte) error {
if len(msg) > maxDNSMessage {
return fmt.Errorf("dns message of %d bytes does not fit a tcp frame", len(msg))
}
frame := make([]byte, 2+len(msg))
binary.BigEndian.PutUint16(frame, uint16(len(msg)))
copy(frame[2:], msg)
_, err := w.Write(frame)
return err
}