1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
|
package server
import (
"context"
"log/slog"
"net"
"time"
"github.com/miekg/dns"
"sdns/internal/blocklist"
"sdns/internal/cache"
)
func (s *Server) handleQuery(w dns.ResponseWriter, req *dns.Msg) {
if len(req.Question) == 0 {
m := new(dns.Msg)
m.SetRcode(req, dns.RcodeFormatError)
_ = w.WriteMsg(m)
return
}
resp, blocked := s.buildResponse(req)
if err := w.WriteMsg(resp); err != nil {
slog.Error("write response failed",
"err", err,
"qname", req.Question[0].Name,
"qtype", dns.TypeToString[req.Question[0].Qtype],
)
return
}
slog.Info("query served",
"qname", req.Question[0].Name,
"qtype", dns.TypeToString[req.Question[0].Qtype],
"rcode", dns.RcodeToString[resp.Rcode],
"client", w.RemoteAddr().String(),
"blocked", blocked,
)
}
func (s *Server) buildResponse(req *dns.Msg) (*dns.Msg, bool) {
if len(req.Question) == 0 {
return new(dns.Msg).SetRcode(req, dns.RcodeFormatError), false
}
q := req.Question[0]
if s.cache != nil {
key := cache.Key{Name: q.Name, Qtype: q.Qtype, Class: q.Qclass}
if cached, ok := s.cache.Get(key); ok {
return cached, false
}
}
if s.blocklist != nil && s.blocklist.IsBlocked(q.Name) {
return s.blockedResponse(req), true
}
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
reply, err := s.resolver.Lookup(ctx, q.Name, q.Qtype)
if err != nil {
slog.Error("resolution failed",
"err", err,
"qname", q.Name,
"qtype", dns.TypeToString[q.Qtype],
)
m := new(dns.Msg)
m.SetRcode(req, dns.RcodeServerFailure)
return m, false
}
reply.Id = req.Id
if s.cache != nil && reply.Rcode != dns.RcodeServerFailure {
key := cache.Key{Name: q.Name, Qtype: q.Qtype, Class: q.Qclass}
s.cache.Set(key, reply, 0)
}
return reply, false
}
func (s *Server) blockedResponse(req *dns.Msg) *dns.Msg {
m := new(dns.Msg)
m.SetReply(req)
m.Authoritative = true
if s.blocklist.Response() == blocklist.ResponseNXDOMAIN {
m.Rcode = dns.RcodeNameError
return m
}
q := req.Question[0]
switch q.Qtype {
case dns.TypeA:
m.Answer = append(m.Answer, &dns.A{
Hdr: dns.RR_Header{Name: q.Name, Rrtype: dns.TypeA, Class: dns.ClassINET, Ttl: 60},
A: net.IPv4(0, 0, 0, 0),
})
case dns.TypeAAAA:
m.Answer = append(m.Answer, &dns.AAAA{
Hdr: dns.RR_Header{Name: q.Name, Rrtype: dns.TypeAAAA, Class: dns.ClassINET, Ttl: 60},
AAAA: net.IPv6zero,
})
}
return m
}
|
