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
108
109
110
111
112
113
114
115
116
117
118
|
package dnstap
import (
"errors"
"net"
"strings"
"testing"
"github.com/coredns/coredns/plugin"
"github.com/coredns/coredns/plugin/dnstap/test"
mwtest "github.com/coredns/coredns/plugin/test"
"context"
tap "github.com/dnstap/golang-dnstap"
"github.com/miekg/dns"
)
func testCase(t *testing.T, tapq, tapr *tap.Message, q, r *dns.Msg) {
w := writer{t: t}
w.queue = append(w.queue, tapq, tapr)
h := Dnstap{
Next: mwtest.HandlerFunc(func(_ context.Context,
w dns.ResponseWriter, _ *dns.Msg) (int, error) {
return 0, w.WriteMsg(r)
}),
IO: &w,
JoinRawMessage: false,
}
_, err := h.ServeDNS(context.TODO(), &mwtest.ResponseWriter{}, q)
if err != nil {
t.Fatal(err)
}
}
type writer struct {
t *testing.T
queue []*tap.Message
}
func (w *writer) Dnstap(e tap.Dnstap) {
if len(w.queue) == 0 {
w.t.Error("Message not expected.")
}
if !test.MsgEqual(w.queue[0], e.Message) {
w.t.Errorf("want: %v, have: %v", w.queue[0], e.Message)
}
w.queue = w.queue[1:]
}
func TestDnstap(t *testing.T) {
q := mwtest.Case{Qname: "example.org", Qtype: dns.TypeA}.Msg()
r := mwtest.Case{
Qname: "example.org.", Qtype: dns.TypeA,
Answer: []dns.RR{
mwtest.A("example.org. 3600 IN A 10.0.0.1"),
},
}.Msg()
tapq, _ := test.TestingData().ToClientQuery()
tapr, _ := test.TestingData().ToClientResponse()
testCase(t, tapq, tapr, q, r)
}
type noWriter struct {
}
func (n noWriter) Dnstap(d tap.Dnstap) {
}
func endWith(c int, err error) plugin.Handler {
return mwtest.HandlerFunc(func(_ context.Context, w dns.ResponseWriter, _ *dns.Msg) (int, error) {
w.WriteMsg(nil) // trigger plugin dnstap to log client query and response
// maybe dnstap should log the client query when no message is written...
return c, err
})
}
type badAddr struct {
}
func (bad badAddr) Network() string {
return "bad network"
}
func (bad badAddr) String() string {
return "bad address"
}
type badRW struct {
dns.ResponseWriter
}
func (bad *badRW) RemoteAddr() net.Addr {
return badAddr{}
}
func TestError(t *testing.T) {
h := Dnstap{
Next: endWith(0, nil),
IO: noWriter{},
JoinRawMessage: false,
}
rw := &badRW{&mwtest.ResponseWriter{}}
// the dnstap error will show only if there is no plugin error
_, err := h.ServeDNS(context.TODO(), rw, nil)
if err == nil || !strings.HasPrefix(err.Error(), "plugin/dnstap") {
t.Fatal("must return the dnstap error but have:", err)
}
// plugin errors will always overwrite dnstap errors
pluginErr := errors.New("plugin error")
h.Next = endWith(0, pluginErr)
_, err = h.ServeDNS(context.TODO(), rw, nil)
if err != pluginErr {
t.Fatal("must return the plugin error but have:", err)
}
}
|
