mirror/routedns
1
0
Fork 0
mirror of https://github.com/folbricht/routedns.git synced 2026-01-06 01:30:00 -06:00
Code Issues Packages Projects Releases Wiki Activity

Adjust log-level of transient errors during querying

Browse Source
This commit is contained in:
folbrich
2025-02-09 18:15:31 +01:00
parent 383193dd98
commit ca8a2377ca
13 changed files with 30 additions and 30 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
blocklist.go
View File

@@ -187,7 +187,7 @@ func (r *Blocklist) Resolve(q *dns.Msg, ci ClientInfo) (*dns.Msg, error) {
// Block the request with NXDOMAIN if there was a match but no valid spoofed IP is given
log.Debug("blocking request")
if err := r.EDNS0EDETemplate.Apply(answer, EDNS0EDEInput{q, match}); err != nil {
log.Error("failed to apply edns0ede template", "error", err)
log.Warn("failed to apply edns0ede template", "error", err)
}
answer.SetRcode(q, dns.RcodeNameError)
return answer, nil

2
dnslistener.go
View File

@@ -82,7 +82,7 @@ func listenHandler(id, protocol, addr string, r Resolver, allowedNet []*net.IPNe
a, err = r.Resolve(req, ci)
if err != nil {
metrics.err.Add("resolve", 1)
log.Error("failed to resolve", "error", err)
log.Warn("failed to resolve", "error", err)
a = servfail(req)
}
} else {

6
dohclient.go
View File

@@ -423,7 +423,7 @@ func quicRestart(s *quicConnection) error {
var earlyConn quic.EarlyConnection
earlyConn, s.udpConn, err = quicDial(context.TODO(), s.rAddr, s.lAddr, s.tlsConfig, s.config, s.Use0RTT)
if err != nil || s.udpConn == nil {
Log.Error("couldn't restart quic connection", slog.Group("details", slog.String("protocol", "quic"), slog.String("address", s.hostname), slog.String("local", s.lAddr.String())), "error", err)
Log.Warn("couldn't restart quic connection", slog.Group("details", slog.String("protocol", "quic"), slog.String("address", s.hostname), slog.String("local", s.lAddr.String())), "error", err)
return err
}
Log.Debug("restarted quic connection", slog.Group("details", slog.String("protocol", "quic"), slog.String("address", s.hostname), slog.String("local", s.lAddr.String()), slog.String("rAddr", s.rAddr)))
@@ -449,14 +449,14 @@ func quicDial(ctx context.Context, rAddr string, lAddr net.IP, tlsConfig *tls.Co
earlyConn, err = quic.DialEarly(ctx, udpConn, udpAddr, tlsConfig, config)
if err != nil {
_ = udpConn.Close()
Log.Error("couldn't dial quic early connection", "error", err)
Log.Warn("couldn't dial quic early connection", "error", err)
return nil, nil, err
}
} else {
conn, err := quic.Dial(ctx, udpConn, udpAddr, tlsConfig, config)
if err != nil {
_ = udpConn.Close()
Log.Error("couldn't dial quic connection", "error", err)
Log.Warn("couldn't dial quic connection", "error", err)
return nil, nil, err
}
earlyConn = &earlyConnWrapper{Connection: conn}

2
dohlistener.go
View File

@@ -276,7 +276,7 @@ func (s *DoHListener) parseAndRespond(b []byte, w http.ResponseWriter, r *http.R
log.With("resolver", s.r.String()).Debug("forwarding query to resolver")
a, err = s.r.Resolve(q, ci)
if err != nil {
log.Error("failed to resolve", "error", err)
log.Warn("failed to resolve", "error", err)
a = new(dns.Msg)
a.SetRcode(q, dns.RcodeServerFailure)
}

6
doqclient.go
View File

@@ -193,7 +193,7 @@ func (d *DoQClient) Resolve(q *dns.Msg, ci ClientInfo) (*dns.Msg, error) {
if edns0 != nil {
for _, opt := range edns0.Option {
if opt.Option() == dns.EDNS0TCPKEEPALIVE {
d.log.Error("received edns-tcp-keepalive from doq server, aborting")
d.log.Warn("received edns-tcp-keepalive from doq server, aborting")
d.metrics.err.Add("keepalive", 1)
return nil, errors.New("received edns-tcp-keepalive over doq server")
}
@@ -217,7 +217,7 @@ func (s *quicConnection) getStream(endpoint string, log *slog.Logger) (quic.Stre
var err error
s.EarlyConnection, s.udpConn, err = quicDial(context.TODO(), endpoint, s.lAddr, s.tlsConfig, s.config, s.Use0RTT)
if err != nil {
log.Error("failed to open connection",
log.Warn("failed to open connection",
"hostname", s.hostname,
"error", err,
)
@@ -238,7 +238,7 @@ func (s *quicConnection) getStream(endpoint string, log *slog.Logger) (quic.Stre
}
stream, err = s.EarlyConnection.OpenStream()
if err != nil {
log.Error("failed to open stream",
log.Warn("failed to open stream",
"error", err,
)
}

14
doqlistener.go
View File

@@ -148,7 +148,7 @@ func (s DoQListener) handleStream(stream quic.Stream, log *slog.Logger, ci Clien
var length uint16
if err := binary.Read(stream, binary.BigEndian, &length); err != nil {
s.metrics.err.Add("read", 1)
log.Error("failed to read query", "error", err)
log.Warn("failed to read query", "error", err)
return
}
@@ -157,7 +157,7 @@ func (s DoQListener) handleStream(stream quic.Stream, log *slog.Logger, ci Clien
_ = stream.SetReadDeadline(time.Now().Add(time.Second)) // TODO: configurable timeout
if _, err := io.ReadFull(stream, b); err != nil {
s.metrics.err.Add("read", 1)
log.Error("failed to read query", "error", err)
log.Warn("failed to read query", "error", err)
return
}
@@ -165,7 +165,7 @@ func (s DoQListener) handleStream(stream quic.Stream, log *slog.Logger, ci Clien
q := new(dns.Msg)
if err := q.Unpack(b); err != nil {
s.metrics.err.Add("unpack", 1)
log.Error("failed to decode query", "error", err)
log.Warn("failed to decode query", "error", err)
return
}
log = log.With("qname", qName(q))
@@ -177,7 +177,7 @@ func (s DoQListener) handleStream(stream quic.Stream, log *slog.Logger, ci Clien
if edns0 != nil {
for _, opt := range edns0.Option {
if opt.Option() == dns.EDNS0TCPKEEPALIVE {
log.Error("received edns-tcp-keepalive, aborting")
log.Warn("received edns-tcp-keepalive, aborting")
s.metrics.err.Add("keepalive", 1)
return
}
@@ -187,14 +187,14 @@ func (s DoQListener) handleStream(stream quic.Stream, log *slog.Logger, ci Clien
// Resolve the query using the next hop
a, err := s.r.Resolve(q, ci)
if err != nil {
log.Error("failed to resolve", "error", err)
log.Warn("failed to resolve", "error", err)
a = new(dns.Msg)
a.SetRcode(q, dns.RcodeServerFailure)
}
p, err := a.Pack()
if err != nil {
log.Error("failed to encode response", "error", err)
log.Warn("failed to encode response", "error", err)
s.metrics.err.Add("encode", 1)
return
}
@@ -208,7 +208,7 @@ func (s DoQListener) handleStream(stream quic.Stream, log *slog.Logger, ci Clien
_ = stream.SetWriteDeadline(time.Now().Add(time.Second)) // TODO: configurable timeout
if _, err = stream.Write(out); err != nil {
s.metrics.err.Add("send", 1)
log.Error("failed to send response", "error", err)
log.Warn("failed to send response", "error", err)
}
s.metrics.response.Add(rCode(a), 1)
}

2
odohlistener.go
View File

@@ -219,7 +219,7 @@ func (s *ODoHListener) ODoHqueryHandler(w http.ResponseWriter, r *http.Request)
a, err := s.r.Resolve(q, ClientInfo{Listener: s.id, TLSServerName: r.TLS.ServerName})
if err != nil {
Log.Error("failed to resolve", "error", err)
Log.Warn("failed to resolve", "error", err)
a = new(dns.Msg)
a.SetRcode(q, dns.RcodeServerFailure)
}

2
response-blocklist-ip.go
View File

@@ -125,7 +125,7 @@ func (r *ResponseBlocklistIP) blockIfMatch(query, answer *dns.Msg, ci ClientInfo
log.Debug("blocking response")
answer = nxdomain(query)
if err := r.EDNS0EDETemplate.Apply(answer, EDNS0EDEInput{query, match}); err != nil {
log.With(slog.String("error", err.Error())).Error("failed to apply edns0ede template")
log.Warn("failed to apply edns0ede template", "error", err)
}
return answer, nil
}

4
response-blocklist-name.go
View File

@@ -108,13 +108,13 @@ func (r *ResponseBlocklistName) blockIfMatch(query, answer *dns.Msg, ci ClientIn
if _, _, rule, ok := r.BlocklistDB.Match(msg); ok != r.Inverted {
log := logger(r.id, query, ci).With("rule", rule.GetRule())
if r.BlocklistResolver != nil {
log.With("resolver", r.BlocklistResolver).Debug("blocklist match, forwarding to blocklist-resolver")
log.Debug("blocklist match, forwarding to blocklist-resolver", "resolver", r.BlocklistResolver)
return r.BlocklistResolver.Resolve(query, ci)
}
log.Debug("blocking response")
answer = nxdomain(query)
if err := r.EDNS0EDETemplate.Apply(answer, EDNS0EDEInput{query, rule}); err != nil {
log.Error("failed to apply edns0ede template", "error", err)
log.Warn("failed to apply edns0ede template", "error", err)
}
return answer, nil
}

4
socks5.go
View File

@@ -72,12 +72,12 @@ func (d *Socks5Dialer) Dial(network string, address string) (net.Conn, error) {
defer cancel()
ips, err := net.DefaultResolver.LookupIP(ctx, "ip4", host)
if err != nil {
Log.Error("failed to lookup host locally", "error", err,
Log.Warn("failed to lookup host locally", "error", err,
"host", host)
return
}
if len(ips) == 0 {
Log.Error("failed to resolve dns server locally, forwarding to socks5 proxy", "error", err)
Log.Warn("failed to resolve dns server locally, forwarding to socks5 proxy", "error", err)
return
}
d.addr = net.JoinHostPort(ips[0].String(), port)

6
static-template.go
View File

@@ -64,7 +64,7 @@ func (r *StaticTemplateResolver) Resolve(q *dns.Msg, ci ClientInfo) (*dns.Msg, e
answer.Truncated = r.truncate
if err := r.opt.EDNS0EDETemplate.Apply(answer, EDNS0EDEInput{q, nil}); err != nil {
log.Error("failed to apply edns0ede template", "error", err)
log.Warn("failed to apply edns0ede template", "error", err)
}
logger(r.id, q, ci).With("truncated", r.truncate).Debug("responding")
@@ -93,13 +93,13 @@ func (r *StaticTemplateResolver) processRRTemplates(q *dns.Msg, ci ClientInfo, t
for _, tpl := range templates {
text, err := tpl.Apply(input)
if err != nil {
log.Error("failed to apply template", "error", err)
log.Warn("failed to apply template", "error", err)
continue
}
rr, err := dns.NewRR(text)
if err != nil {
log.Error("failed to parse template output", "error", err)
log.Warn("failed to parse template output", "error", err)
continue
}
// Update the name of every answer record to match that of the query

2
static.go
View File

@@ -82,7 +82,7 @@ func (r *StaticResolver) Resolve(q *dns.Msg, ci ClientInfo) (*dns.Msg, error) {
answer.Truncated = r.truncate
if err := r.opt.EDNS0EDETemplate.Apply(answer, EDNS0EDEInput{q, nil}); err != nil {
log.Error("failed to apply edns0ede template", "error", err)
log.Warn("failed to apply edns0ede template", "error", err)
}
logger(r.id, q, ci).With("truncated", r.truncate).Debug("responding")

8
syslog.go
View File

@@ -61,7 +61,7 @@ func (r *Syslog) Resolve(q *dns.Msg, ci ClientInfo) (*dns.Msg, error) {
if r.opt.LogRequest {
msg = fmt.Sprintf("id=%s qid=%d type=query client=%s qtype=%s qname=%s", r.id, q.Id, ci.SourceIP.String(), qType(q), qName(q))
if _, err := r.writer.Write([]byte(msg)); err != nil {
logger(r.id, q, ci).Error("failed to send syslog",
logger(r.id, q, ci).Warn("failed to send syslog",
"error", err)
}
}
@@ -85,7 +85,7 @@ func (r *Syslog) Resolve(q *dns.Msg, ci ClientInfo) (*dns.Msg, error) {
s := strings.ReplaceAll(rr.String(), "\t", " ")
msg = fmt.Sprintf("id=%s qid=%d type=answer answer-num=%d/%d qtype=%s qname=%s answer=%q", r.id, q.Id, i+1, len(answerRRs), qType(q), qName(q), s)
if _, err := r.writer.Write([]byte(msg)); err != nil {
logger(r.id, q, ci).Error("failed to send syslog",
logger(r.id, q, ci).Warn("failed to send syslog",
"error", err)
}
}
@@ -93,14 +93,14 @@ func (r *Syslog) Resolve(q *dns.Msg, ci ClientInfo) (*dns.Msg, error) {
if len(answerRRs) == 0 {
msg = fmt.Sprintf("id=%s qid=%d type=answer qtype=%s qname=%s rcode=NODATA", r.id, q.Id, qType(q), qName(q))
if _, err := r.writer.Write([]byte(msg)); err != nil {
logger(r.id, q, ci).Error("failed to send syslog",
logger(r.id, q, ci).Warn("failed to send syslog",
"error", err)
}
}
} else {
msg = fmt.Sprintf("id=%s qid=%d type=answer qtype=%s qname=%s rcode=%s", r.id, q.Id, qType(q), qName(q), dns.RcodeToString[a.Rcode])
if _, err := r.writer.Write([]byte(msg)); err != nil {
logger(r.id, q, ci).Error("failed to send syslog",
logger(r.id, q, ci).Warn("failed to send syslog",
"error", err)
}
}