613 lines
17 KiB
Go
613 lines
17 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"math/rand"
|
|
"net"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"sync"
|
|
"sync/atomic"
|
|
"time"
|
|
|
|
"codeberg.org/miekg/dns"
|
|
"github.com/jedisct1/dlog"
|
|
"github.com/lifenjoiner/dhcpdns"
|
|
netproxy "golang.org/x/net/proxy"
|
|
)
|
|
|
|
type SearchSequenceItemType int
|
|
|
|
const (
|
|
Explicit SearchSequenceItemType = iota
|
|
Bootstrap
|
|
DHCP
|
|
Resolvconf
|
|
)
|
|
|
|
type SearchSequenceItem struct {
|
|
typ SearchSequenceItemType
|
|
servers []string
|
|
resolvconf string
|
|
rcLastFail atomic.Int64 // unix timestamp of last failed resolv.conf read
|
|
}
|
|
|
|
type PluginForwardEntry struct {
|
|
domain string
|
|
sequence []SearchSequenceItem
|
|
viaProxy bool
|
|
}
|
|
|
|
type PluginForward struct {
|
|
forwardMap []PluginForwardEntry
|
|
bootstrapResolvers []string
|
|
dhcpdns []*dhcpdns.Detector
|
|
proxyDialer netproxy.Dialer
|
|
forceTCP bool
|
|
|
|
// Hot-reloading support
|
|
rwLock sync.RWMutex
|
|
configFile string
|
|
configWatcher *ConfigWatcher
|
|
stagingMap []PluginForwardEntry
|
|
}
|
|
|
|
func (plugin *PluginForward) Name() string {
|
|
return "forward"
|
|
}
|
|
|
|
func (plugin *PluginForward) Description() string {
|
|
return "Route queries matching specific domains to a dedicated set of servers"
|
|
}
|
|
|
|
func (plugin *PluginForward) Init(proxy *Proxy) error {
|
|
plugin.configFile = proxy.forwardFile
|
|
dlog.Noticef("Loading the set of forwarding rules from [%s]", plugin.configFile)
|
|
|
|
plugin.forceTCP = proxy.forceTCP
|
|
if proxy.xTransport != nil {
|
|
plugin.bootstrapResolvers = proxy.xTransport.bootstrapResolvers
|
|
if proxy.xTransport.proxyDialer != nil {
|
|
plugin.proxyDialer = *proxy.xTransport.proxyDialer
|
|
}
|
|
}
|
|
|
|
lines, err := ReadTextFile(plugin.configFile)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
requiresDHCP, forwardMap, err := plugin.parseForwardFile(lines)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
plugin.forwardMap = forwardMap
|
|
|
|
if requiresDHCP {
|
|
if len(proxy.userName) > 0 {
|
|
dlog.Warn("DHCP/DNS detection may not work when 'user_name' is set or when starting as a non-root user")
|
|
}
|
|
if proxy.SourceIPv6 {
|
|
dlog.Notice("Starting a DHCP/DNS detector for IPv6")
|
|
d6 := &dhcpdns.Detector{RemoteIPPort: "[2001:DB8::53]:80"}
|
|
go d6.Serve(9, 10)
|
|
plugin.dhcpdns = append(plugin.dhcpdns, d6)
|
|
}
|
|
if proxy.SourceIPv4 {
|
|
dlog.Notice("Starting a DHCP/DNS detector for IPv4")
|
|
d4 := &dhcpdns.Detector{RemoteIPPort: "192.0.2.53:80"}
|
|
go d4.Serve(9, 10)
|
|
plugin.dhcpdns = append(plugin.dhcpdns, d4)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// parseForwardFile parses forward rules from text
|
|
func (plugin *PluginForward) parseForwardFile(lines string) (bool, []PluginForwardEntry, error) {
|
|
requiresDHCP := false
|
|
forwardMap := []PluginForwardEntry{}
|
|
|
|
for lineNo, line := range strings.Split(lines, "\n") {
|
|
line = TrimAndStripInlineComments(line)
|
|
if len(line) == 0 {
|
|
continue
|
|
}
|
|
domain, serversStr, ok := StringTwoFields(line)
|
|
domain = strings.TrimPrefix(domain, "*.")
|
|
if strings.Contains(domain, "*") {
|
|
ok = false
|
|
}
|
|
if !ok {
|
|
return false, nil, fmt.Errorf(
|
|
"Syntax error for a forwarding rule at line %d. Expected syntax: example.com 9.9.9.9,8.8.8.8",
|
|
1+lineNo,
|
|
)
|
|
}
|
|
domain = strings.ToLower(domain)
|
|
viaProxy := false
|
|
if strings.HasPrefix(serversStr, "$PROXY:") {
|
|
viaProxy = true
|
|
serversStr = strings.TrimSpace(serversStr[len("$PROXY:"):])
|
|
if plugin.proxyDialer == nil {
|
|
return false, nil, fmt.Errorf(
|
|
"Forwarding rule at line %d uses $PROXY:, but no proxy is available. The `proxy` option must be configured in the main configuration file",
|
|
1+lineNo,
|
|
)
|
|
}
|
|
}
|
|
var sequence []SearchSequenceItem
|
|
for server := range strings.SplitSeq(serversStr, ",") {
|
|
server = strings.TrimSpace(server)
|
|
switch server {
|
|
case "$BOOTSTRAP":
|
|
if len(plugin.bootstrapResolvers) == 0 {
|
|
return false, nil, fmt.Errorf(
|
|
"Syntax error for a forwarding rule at line %d. No bootstrap resolvers available",
|
|
1+lineNo,
|
|
)
|
|
}
|
|
if len(sequence) > 0 && sequence[len(sequence)-1].typ == Bootstrap {
|
|
// Ignore repetitions
|
|
} else {
|
|
sequence = append(sequence, SearchSequenceItem{typ: Bootstrap})
|
|
dlog.Infof("Forwarding [%s] to the bootstrap servers", domain)
|
|
}
|
|
case "$DHCP":
|
|
if len(sequence) > 0 && sequence[len(sequence)-1].typ == DHCP {
|
|
// Ignore repetitions
|
|
} else {
|
|
sequence = append(sequence, SearchSequenceItem{typ: DHCP})
|
|
dlog.Infof("Forwarding [%s] to the DHCP servers", domain)
|
|
}
|
|
requiresDHCP = true
|
|
default:
|
|
const resolvconfPrefix = "$RESOLVCONF:"
|
|
if strings.HasPrefix(server, resolvconfPrefix) {
|
|
file := server[len(resolvconfPrefix):]
|
|
if len(file) == 0 {
|
|
dlog.Criticalf(
|
|
"File needs to be specified for $RESOLVCONF in line %d",
|
|
1+lineNo,
|
|
)
|
|
continue
|
|
}
|
|
file = filepath.Clean(file)
|
|
if !filepath.IsAbs(file) {
|
|
dlog.Warnf(
|
|
"$RESOLVCONF path '%s' at line %d is not absolute; "+
|
|
"this may not resolve as expected", file, 1+lineNo,
|
|
)
|
|
}
|
|
sequence = append(sequence, SearchSequenceItem{
|
|
typ: Resolvconf,
|
|
resolvconf: file,
|
|
})
|
|
dlog.Infof("Forwarding [%s] to the servers specified in '%s'", domain, file)
|
|
continue
|
|
}
|
|
if strings.HasPrefix(server, "$") {
|
|
dlog.Criticalf("Unknown keyword [%s] at line %d", server, 1+lineNo)
|
|
continue
|
|
}
|
|
if server, err := normalizeIPAndOptionalPort(server, "53"); err != nil {
|
|
dlog.Criticalf("Syntax error for a forwarding rule at line %d: %s", 1+lineNo, err)
|
|
continue
|
|
} else {
|
|
idxServers := -1
|
|
for i := range sequence {
|
|
if sequence[i].typ == Explicit {
|
|
idxServers = i
|
|
}
|
|
}
|
|
if idxServers == -1 {
|
|
sequence = append(sequence, SearchSequenceItem{typ: Explicit, servers: []string{server}})
|
|
} else {
|
|
sequence[idxServers].servers = append(sequence[idxServers].servers, server)
|
|
}
|
|
dlog.Infof("Forwarding [%s] to [%s]", domain, server)
|
|
}
|
|
}
|
|
}
|
|
if viaProxy {
|
|
if len(sequence) == 0 {
|
|
return false, nil, fmt.Errorf(
|
|
"Syntax error for a forwarding rule at line %d. $PROXY: requires at least one valid server address",
|
|
1+lineNo,
|
|
)
|
|
}
|
|
for i := range sequence {
|
|
if sequence[i].typ != Explicit {
|
|
return false, nil, fmt.Errorf(
|
|
"Syntax error for a forwarding rule at line %d. $PROXY: can only be combined with explicit server IP addresses",
|
|
1+lineNo,
|
|
)
|
|
}
|
|
}
|
|
}
|
|
forwardMap = append(forwardMap, PluginForwardEntry{
|
|
domain: domain,
|
|
sequence: sequence,
|
|
viaProxy: viaProxy,
|
|
})
|
|
}
|
|
|
|
return requiresDHCP, forwardMap, nil
|
|
}
|
|
|
|
func (plugin *PluginForward) Drop() error {
|
|
if plugin.configWatcher != nil {
|
|
plugin.configWatcher.RemoveFile(plugin.configFile)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// PrepareReload loads new rules into staging structure but doesn't apply them yet
|
|
func (plugin *PluginForward) PrepareReload() error {
|
|
// Read the configuration file
|
|
lines, err := SafeReadTextFile(plugin.configFile)
|
|
if err != nil {
|
|
return fmt.Errorf("error reading config file during reload preparation: %w", err)
|
|
}
|
|
|
|
// Parse the forward file
|
|
_, stagingMap, err := plugin.parseForwardFile(lines)
|
|
if err != nil {
|
|
return fmt.Errorf("error parsing config during reload preparation: %w", err)
|
|
}
|
|
|
|
// Store in staging area
|
|
plugin.rwLock.Lock()
|
|
plugin.stagingMap = stagingMap
|
|
plugin.rwLock.Unlock()
|
|
|
|
return nil
|
|
}
|
|
|
|
// ApplyReload atomically replaces the active rules with the staging ones
|
|
func (plugin *PluginForward) ApplyReload() error {
|
|
plugin.rwLock.Lock()
|
|
defer plugin.rwLock.Unlock()
|
|
|
|
if plugin.stagingMap == nil {
|
|
return errors.New("no staged configuration to apply")
|
|
}
|
|
|
|
plugin.forwardMap = plugin.stagingMap
|
|
plugin.stagingMap = nil
|
|
|
|
dlog.Noticef("Applied new configuration for plugin [%s]", plugin.Name())
|
|
return nil
|
|
}
|
|
|
|
// CancelReload cleans up any staging resources
|
|
func (plugin *PluginForward) CancelReload() {
|
|
plugin.rwLock.Lock()
|
|
plugin.stagingMap = nil
|
|
plugin.rwLock.Unlock()
|
|
}
|
|
|
|
// Reload implements hot-reloading for the plugin
|
|
func (plugin *PluginForward) Reload() error {
|
|
return StandardReloadPattern(plugin.Name(), func() error {
|
|
if err := plugin.PrepareReload(); err != nil {
|
|
plugin.CancelReload()
|
|
return err
|
|
}
|
|
return plugin.ApplyReload()
|
|
})
|
|
}
|
|
|
|
// GetConfigPath returns the path to the plugin's configuration file
|
|
func (plugin *PluginForward) GetConfigPath() string {
|
|
return plugin.configFile
|
|
}
|
|
|
|
// SetConfigWatcher sets the config watcher for this plugin
|
|
func (plugin *PluginForward) SetConfigWatcher(watcher *ConfigWatcher) {
|
|
plugin.configWatcher = watcher
|
|
}
|
|
|
|
func (plugin *PluginForward) Eval(pluginsState *PluginsState, msg *dns.Msg) error {
|
|
qName := pluginsState.qName
|
|
qNameLen := len(qName)
|
|
|
|
// Use read lock for thread-safe access to forwardMap
|
|
plugin.rwLock.RLock()
|
|
var sequence []SearchSequenceItem
|
|
viaProxy := false
|
|
for _, candidate := range plugin.forwardMap {
|
|
candidateLen := len(candidate.domain)
|
|
if candidateLen > qNameLen {
|
|
continue
|
|
}
|
|
if (qName[qNameLen-candidateLen:] == candidate.domain &&
|
|
(candidateLen == qNameLen || (qName[qNameLen-candidateLen-1] == '.'))) ||
|
|
(candidate.domain == ".") {
|
|
sequence = candidate.sequence
|
|
viaProxy = candidate.viaProxy
|
|
break
|
|
}
|
|
}
|
|
plugin.rwLock.RUnlock()
|
|
|
|
if len(sequence) == 0 {
|
|
return nil
|
|
}
|
|
var err error
|
|
var respMsg *dns.Msg
|
|
tries := 4
|
|
const resolvconfRetryInterval int64 = 30 // seconds
|
|
|
|
for i := range sequence {
|
|
var server string
|
|
switch sequence[i].typ {
|
|
case Explicit:
|
|
server = sequence[i].servers[rand.Intn(len(sequence[i].servers))]
|
|
case Bootstrap:
|
|
server = plugin.bootstrapResolvers[rand.Intn(len(plugin.bootstrapResolvers))]
|
|
case DHCP:
|
|
const maxInconsistency = 9
|
|
for _, dhcpdns := range plugin.dhcpdns {
|
|
inconsistency, ip, dhcpDNS, err := dhcpdns.Status()
|
|
if err != nil && ip != "" && inconsistency > maxInconsistency {
|
|
dlog.Infof("No response from the DHCP server while resolving [%s]: %v", qName, err)
|
|
continue
|
|
}
|
|
if len(dhcpDNS) > 0 {
|
|
server = net.JoinHostPort(dhcpDNS[rand.Intn(len(dhcpDNS))].String(), "53")
|
|
break
|
|
}
|
|
}
|
|
if len(server) == 0 {
|
|
dlog.Infof("DHCP didn't provide any DNS server to forward [%s]", qName)
|
|
continue
|
|
}
|
|
case Resolvconf:
|
|
if lastFail := sequence[i].rcLastFail.Load(); lastFail != 0 &&
|
|
time.Now().Unix()-lastFail < resolvconfRetryInterval {
|
|
continue
|
|
}
|
|
servers, warnings, err := parseResolvConf(sequence[i].resolvconf)
|
|
if err != nil {
|
|
dlog.Warnf(
|
|
"Failed to open '%s' while resolving [%s]: %v",
|
|
sequence[i].resolvconf, qName, err,
|
|
)
|
|
sequence[i].rcLastFail.Store(time.Now().Unix())
|
|
continue
|
|
}
|
|
if len(servers) == 0 {
|
|
for _, w := range warnings {
|
|
dlog.Warn(w)
|
|
}
|
|
dlog.Warnf(
|
|
"No valid nameservers in '%s' while resolving [%s]",
|
|
sequence[i].resolvconf, qName,
|
|
)
|
|
sequence[i].rcLastFail.Store(time.Now().Unix())
|
|
continue
|
|
}
|
|
sequence[i].rcLastFail.Store(0) // clear failure state on successful read
|
|
nameserver := servers[rand.Intn(len(servers))]
|
|
server, err = normalizeIPAndOptionalPort(nameserver, "53")
|
|
if err != nil {
|
|
dlog.Warnf(
|
|
"Syntax error in address '%s' while resolving [%s]: %v",
|
|
nameserver, qName, err,
|
|
)
|
|
continue
|
|
}
|
|
}
|
|
pluginsState.serverName = server
|
|
if len(server) == 0 {
|
|
continue
|
|
}
|
|
|
|
if tries == 0 {
|
|
break
|
|
}
|
|
tries--
|
|
|
|
// Create a clean copy of the message without Extra section for forwarding
|
|
forwardMsg := msg.Copy()
|
|
forwardMsg.Extra = nil
|
|
forwardMsg.Data = nil // Clear packed data so Exchange will re-pack without Extra
|
|
|
|
if viaProxy {
|
|
dlog.Debugf("Forwarding [%s] to [%s] using DNS-over-TCP through the configured proxy", qName, server)
|
|
respMsg, err = plugin.exchangeViaProxy(forwardMsg, server, pluginsState.timeout)
|
|
} else {
|
|
proto := "udp"
|
|
if sequence[i].typ == Bootstrap && plugin.forceTCP {
|
|
proto = "tcp"
|
|
}
|
|
dlog.Debugf("Forwarding [%s] to [%s]", qName, server)
|
|
respMsg, err = plugin.exchangeDirect(forwardMsg, proto, server, pluginsState.timeout)
|
|
}
|
|
if err != nil {
|
|
continue
|
|
}
|
|
if err := validateResponseQuestion(forwardMsg, respMsg); err != nil {
|
|
continue
|
|
}
|
|
if !respMsg.Security {
|
|
respMsg.AuthenticatedData = false
|
|
}
|
|
respMsg.ID = msg.ID
|
|
pluginsState.synthResponse = respMsg
|
|
pluginsState.action = PluginsActionSynth
|
|
pluginsState.returnCode = PluginsReturnCodeForward
|
|
if len(sequence) > 0 {
|
|
switch respMsg.Rcode {
|
|
case dns.RcodeNameError, dns.RcodeRefused, dns.RcodeNotAuth:
|
|
continue
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
return err
|
|
}
|
|
|
|
// exchangeDirect sends a query to the selected upstream server, starting with
|
|
// the given protocol and retrying a truncated UDP response over TCP.
|
|
func (plugin *PluginForward) exchangeDirect(
|
|
forwardMsg *dns.Msg,
|
|
proto string,
|
|
server string,
|
|
timeout time.Duration,
|
|
) (*dns.Msg, error) {
|
|
client := dns.Client{}
|
|
ctx, cancel := context.WithTimeout(context.Background(), timeout)
|
|
respMsg, _, err := client.Exchange(ctx, forwardMsg, proto, server)
|
|
cancel()
|
|
if err != nil && (respMsg == nil || !respMsg.Truncated) {
|
|
return nil, err
|
|
}
|
|
if respMsg != nil && respMsg.Truncated {
|
|
ctx, cancel = context.WithTimeout(context.Background(), timeout)
|
|
respMsg, _, err = client.Exchange(ctx, forwardMsg, "tcp", server)
|
|
cancel()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return respMsg, nil
|
|
}
|
|
|
|
// deadlineCappedConn caps every deadline set on the underlying connection, so helpers
|
|
// that reset deadlines cannot extend I/O beyond the query timeout.
|
|
type deadlineCappedConn struct {
|
|
net.Conn
|
|
deadline time.Time
|
|
}
|
|
|
|
func (c *deadlineCappedConn) capped(t time.Time) time.Time {
|
|
if t.IsZero() || t.After(c.deadline) {
|
|
return c.deadline
|
|
}
|
|
return t
|
|
}
|
|
|
|
func (c *deadlineCappedConn) SetDeadline(t time.Time) error {
|
|
return c.Conn.SetDeadline(c.capped(t))
|
|
}
|
|
|
|
func (c *deadlineCappedConn) SetReadDeadline(t time.Time) error {
|
|
return c.Conn.SetReadDeadline(c.capped(t))
|
|
}
|
|
|
|
func (c *deadlineCappedConn) SetWriteDeadline(t time.Time) error {
|
|
return c.Conn.SetWriteDeadline(c.capped(t))
|
|
}
|
|
|
|
// exchangeViaProxy performs a DNS-over-TCP exchange through the proxy configured with the
|
|
// top-level `proxy` option. The connection is created per query and always closed here.
|
|
func (plugin *PluginForward) exchangeViaProxy(
|
|
forwardMsg *dns.Msg,
|
|
server string,
|
|
timeout time.Duration,
|
|
) (*dns.Msg, error) {
|
|
if plugin.proxyDialer == nil {
|
|
return nil, errors.New("proxied forwarding requires the `proxy` option to be configured")
|
|
}
|
|
ctx, cancel := context.WithTimeout(context.Background(), timeout)
|
|
defer cancel()
|
|
var conn net.Conn
|
|
var err error
|
|
if contextDialer, ok := plugin.proxyDialer.(netproxy.ContextDialer); ok {
|
|
conn, err = contextDialer.DialContext(ctx, "tcp", server)
|
|
} else {
|
|
conn, err = plugin.proxyDialer.Dial("tcp", server)
|
|
}
|
|
if err != nil {
|
|
return nil, fmt.Errorf("unable to reach [%s] through the proxy: %w", server, err)
|
|
}
|
|
defer conn.Close()
|
|
deadline, _ := ctx.Deadline()
|
|
remaining := time.Until(deadline)
|
|
if remaining <= 0 {
|
|
return nil, fmt.Errorf("timeout while connecting to [%s] through the proxy", server)
|
|
}
|
|
// ExchangeWithConn dereferences the client transport and replaces the connection's
|
|
// read and write deadlines with its own timeouts, so the transport must be non-nil
|
|
// and the wrapper is what keeps the query timeout an end-to-end bound.
|
|
conn = &deadlineCappedConn{Conn: conn, deadline: deadline}
|
|
if err := conn.SetDeadline(deadline); err != nil {
|
|
return nil, err
|
|
}
|
|
client := dns.Client{Transport: &dns.Transport{ReadTimeout: remaining, WriteTimeout: remaining}}
|
|
respMsg, _, err := client.ExchangeWithConn(ctx, forwardMsg, conn)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("proxied exchange with [%s] failed: %w", server, err)
|
|
}
|
|
return respMsg, nil
|
|
}
|
|
|
|
func parseResolvConf(filename string) (servers []string, warnings []string, err error) {
|
|
data, err := os.ReadFile(filename)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
for line := range strings.SplitSeq(string(data), "\n") {
|
|
line = strings.TrimSpace(line)
|
|
if !strings.HasPrefix(line, "nameserver") {
|
|
continue
|
|
}
|
|
fields := strings.Fields(line)
|
|
if len(fields) < 2 {
|
|
continue
|
|
}
|
|
addr := fields[1]
|
|
host := addr
|
|
if h, _, err := net.SplitHostPort(addr); err == nil {
|
|
host = h
|
|
}
|
|
if net.ParseIP(host) == nil {
|
|
warnings = append(warnings, fmt.Sprintf(
|
|
"Ignoring invalid nameserver address '%s' in [%s]", addr, filename,
|
|
))
|
|
continue
|
|
}
|
|
servers = append(servers, addr)
|
|
}
|
|
return
|
|
}
|
|
|
|
func normalizeIPAndOptionalPort(addr string, defaultPort string) (string, error) {
|
|
var host, port string
|
|
var err error
|
|
|
|
if strings.HasPrefix(addr, "[") {
|
|
if !strings.Contains(addr, "]:") {
|
|
if addr[len(addr)-1] != ']' {
|
|
return "", fmt.Errorf("invalid IPv6 format: missing closing ']'")
|
|
}
|
|
host = addr[1 : len(addr)-1]
|
|
port = defaultPort
|
|
} else {
|
|
host, port, err = net.SplitHostPort(addr)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
}
|
|
} else {
|
|
host, port, err = net.SplitHostPort(addr)
|
|
if err != nil {
|
|
host = addr
|
|
port = defaultPort
|
|
}
|
|
}
|
|
ip := net.ParseIP(host)
|
|
if ip == nil {
|
|
return "", fmt.Errorf("invalid IP address: [%s]", host)
|
|
}
|
|
if ip.To4() != nil {
|
|
return fmt.Sprintf("%s:%s", ip.String(), port), nil
|
|
}
|
|
return fmt.Sprintf("[%s]:%s", ip.String(), port), nil
|
|
}
|