Files
zapret-autotune/cmd/zapret-autotune/dns_forwarder_test.go
T
ZeusinaandGPT-6 Bot 367d956ae3 feat: add configurable PID1-owned DoH forwarding
Default managed SOCKS hostname DNS to verified HTTPS with literal-IP bootstrap and no plaintext fallback. Supervise the loopback forwarder with private anchored readiness and preserve foreign markers. Include configuration, deployment, documentation and offline checks.

Co-authored-by: GPT-6 <gpt-6@openai.com>
2026-10-13 14:32:58 +03:00

665 lines
21 KiB
Go

package main
import (
"bufio"
"bytes"
"context"
"crypto/rand"
"crypto/rsa"
"crypto/tls"
"crypto/x509"
"crypto/x509/pkix"
"encoding/binary"
"errors"
"fmt"
"io"
"math/big"
"net"
"net/http"
"os"
"path/filepath"
"strconv"
"sync"
"sync/atomic"
"syscall"
"testing"
"time"
)
type dnsRoundTripFunc func(*http.Request) (*http.Response, error)
func (f dnsRoundTripFunc) RoundTrip(r *http.Request) (*http.Response, error) { return f(r) }
func testDNSQuery() []byte {
return []byte{0x12, 0x34, 1, 0x20, 0, 1, 0, 0, 0, 0, 0, 0, 3, 'w', 'w', 'w', 7, 'e', 'x', 'a', 'm', 'p', 'l', 'e', 0, 0, 1, 0, 1}
}
func testDNSResponse(query []byte) []byte {
response := append([]byte(nil), query...)
response[2] |= 0x80
response[3] |= 0x80
return response
}
func testDNSForwarder(t *testing.T, roundTrip dnsRoundTripFunc) *dnsForwarder {
t.Helper()
return &dnsForwarder{cfg: dnsConfigForTest(t, nil), client: &http.Client{Transport: roundTrip}, slots: make(chan struct{}, dnsConcurrency)}
}
func dnsHTTPResponse(body []byte) *http.Response {
return &http.Response{StatusCode: 200, Header: http.Header{"Content-Type": {"application/dns-message"}}, Body: io.NopCloser(bytes.NewReader(body)), ContentLength: int64(len(body))}
}
func TestDNSWireValidation(t *testing.T) {
query := testDNSQuery()
if !validDNSQuery(query) || !validDNSResponse(query, testDNSResponse(query)) {
t.Fatal("valid wire rejected")
}
edns := append([]byte(nil), query...)
edns[11] = 1
edns = append(edns, 0, 0, 41, 0x10, 0, 0, 0, 0x80, 0, 0, 0)
if !validDNSQuery(edns) {
t.Fatal("EDNS/DNSSEC query rejected")
}
failure := dnsServfail(edns)
if len(failure) != len(query) || !bytes.Equal(failure[:2], query[:2]) || failure[2] != 0x81 || failure[3] != 2 || !bytes.Equal(failure[12:], query[12:]) || !bytes.Equal(failure[6:12], make([]byte, 6)) {
t.Fatal(failure)
}
for _, mutate := range []func([]byte) []byte{
func(q []byte) []byte { return q[:11] },
func(q []byte) []byte { q[2] |= 0x80; return q },
func(q []byte) []byte { q[2] |= 0x08; return q },
func(q []byte) []byte { q[2] |= 0x04; return q },
func(q []byte) []byte { q[3] |= 0x40; return q },
func(q []byte) []byte { q[5] = 2; return q },
func(q []byte) []byte { q[7] = 1; return q },
func(q []byte) []byte { q[11] = 255; return q },
func(q []byte) []byte { q[12] = 64; return q },
func(q []byte) []byte { q[12] = 0xc0; q[13] = 12; return q },
func(q []byte) []byte { q[12] = 0xc0; q[13] = 255; return q },
func(q []byte) []byte { return q[:len(q)-1] },
func(q []byte) []byte { return append(q, 0) },
func(q []byte) []byte { return append(q, make([]byte, 4096)...) },
} {
bad := mutate(append([]byte(nil), query...))
if validDNSQuery(bad) || dnsServfail(bad) != nil {
t.Fatal("malformed query accepted")
}
}
// A backwards compression reference is legal; a self-reference is not.
if end, ok := dnsNameEnd(append(query, 0xc0, 12), len(query)); !ok || end != len(query)+2 {
t.Fatal(end, ok)
}
}
func TestDNSExchangePassThroughAndRejects(t *testing.T) {
query := testDNSQuery()
response := testDNSResponse(query)
// Opaque record bytes (including DNSSEC and TTL) must remain untouched.
response[7] = 1
response = append(response, 0xc0, 12, 0, 1, 0, 1, 0, 0, 0, 37, 0, 4, 1, 2, 3, 4)
f := testDNSForwarder(t, func(r *http.Request) (*http.Response, error) {
body, _ := io.ReadAll(r.Body)
if r.Method != "POST" || r.URL.String() != defaultDoHURL || r.Header.Get("Content-Type") != "application/dns-message" || r.Header.Get("Accept") != "application/dns-message" || !bytes.Equal(body, query) {
t.Error("incorrect DoH request")
}
return dnsHTTPResponse(response), nil
})
if actual := f.exchange(context.Background(), query); !bytes.Equal(actual, response) {
t.Fatal(actual)
}
for name, change := range map[string]func(*http.Response){
"status": func(r *http.Response) { r.StatusCode = 503 },
"type": func(r *http.Response) { r.Header.Set("Content-Type", "text/plain") },
"encoding": func(r *http.Response) { r.Header.Set("Content-Encoding", "gzip") },
"length": func(r *http.Response) { r.ContentLength++ },
"overflow": func(r *http.Response) {
r.Body = io.NopCloser(bytes.NewReader(make([]byte, 65536)))
r.ContentLength = 65536
},
"short": func(r *http.Response) { r.Body = io.NopCloser(bytes.NewReader(response[:11])); r.ContentLength = 11 },
"id": func(r *http.Response) {
b := append([]byte(nil), response...)
b[0]++
r.Body = io.NopCloser(bytes.NewReader(b))
},
"qr": func(r *http.Response) {
b := append([]byte(nil), response...)
b[2] &= 0x7f
r.Body = io.NopCloser(bytes.NewReader(b))
},
"opcode": func(r *http.Response) {
b := append([]byte(nil), response...)
b[2] |= 0x08
r.Body = io.NopCloser(bytes.NewReader(b))
},
"question": func(r *http.Response) {
b := append([]byte(nil), response...)
b[13] = 'x'
r.Body = io.NopCloser(bytes.NewReader(b))
},
"qdcount": func(r *http.Response) {
b := append([]byte(nil), response...)
b[5] = 0
r.Body = io.NopCloser(bytes.NewReader(b))
},
"record-count": func(r *http.Response) {
b := append([]byte(nil), response...)
b[7] = 2
r.Body = io.NopCloser(bytes.NewReader(b))
},
"record-length": func(r *http.Response) {
b := append([]byte(nil), response...)
b[len(query)+11] = 255
r.Body = io.NopCloser(bytes.NewReader(b))
},
"truncated": func(r *http.Response) { r.Body = io.NopCloser(dnsBrokenReader{}) },
} {
t.Run(name, func(t *testing.T) {
f := testDNSForwarder(t, func(*http.Request) (*http.Response, error) { r := dnsHTTPResponse(response); change(r); return r, nil })
if actual := f.exchange(context.Background(), query); !bytes.Equal(actual, dnsServfail(query)) {
t.Fatal(actual)
}
})
}
f = testDNSForwarder(t, func(*http.Request) (*http.Response, error) { return nil, errors.New("secret upstream") })
if !bytes.Equal(f.exchange(context.Background(), query), dnsServfail(query)) {
t.Fatal("outage not SERVFAIL")
}
}
type dnsBrokenReader struct{}
func (dnsBrokenReader) Read([]byte) (int, error) { return 0, io.ErrUnexpectedEOF }
func TestDNSBootstrapAndHTTPPolicy(t *testing.T) {
cfg := dnsConfigForTest(t, nil)
var addresses []string
dial := dnsBootstrapDial(cfg, func(ctx context.Context, network, address string) (net.Conn, error) {
if network != "tcp" {
t.Fatal(network)
}
if _, ok := ctx.Deadline(); !ok {
t.Fatal("no bounded deadline")
}
addresses = append(addresses, address)
return nil, errDNSForwarder
})
for i := 0; i < 2; i++ {
dial(context.Background(), "tcp", "dns.google:443")
}
if len(addresses) != 4 || addresses[0] != "8.8.8.8:443" || addresses[2] != "8.8.4.4:443" {
t.Fatal(addresses)
}
for _, addr := range []string{"other:443", "dns.google:80", "8.8.8.8:443"} {
dial(context.Background(), "tcp", addr)
}
if len(addresses) != 4 {
t.Fatal("unexpected endpoint dialed")
}
cfg.BootstrapIPs = []net.IP{net.ParseIP("2001:db8::1")}
dnsBootstrapDial(cfg, func(_ context.Context, _, addr string) (net.Conn, error) {
if addr != "[2001:db8::1]:443" {
t.Fatal(addr)
}
return nil, errDNSForwarder
})(context.Background(), "tcp", "dns.google:443")
client, transport := newDNSHTTPClient(cfg, markDNSSocket)
defer transport.CloseIdleConnections()
if transport.Proxy != nil || transport.TLSClientConfig.InsecureSkipVerify || transport.TLSClientConfig.ServerName != "dns.google" || transport.TLSClientConfig.MinVersion != tls.VersionTLS12 || !transport.DisableCompression || transport.MaxConnsPerHost != 16 {
t.Fatal("unsafe transport policy")
}
if client.CheckRedirect(&http.Request{}, nil) == nil {
t.Fatal("redirect allowed")
}
}
type dnsFakeRaw struct{ err error }
func (r dnsFakeRaw) Control(f func(uintptr)) error {
if r.err == nil {
f(42)
}
return r.err
}
func (dnsFakeRaw) Read(func(uintptr) bool) error { return nil }
func (dnsFakeRaw) Write(func(uintptr) bool) error { return nil }
func TestDNSSocketMarkStrict(t *testing.T) {
called := false
if err := setDNSSocketMark(dnsFakeRaw{}, func(fd, level, opt, mark int) error {
called = true
if fd != 42 || level != syscall.SOL_SOCKET || opt != syscall.SO_MARK || mark != 0x50000000 || mark&0x40000000 == 0 || mark&0x10000000 == 0 {
t.Fatal(fd, level, opt, mark)
}
return nil
}); err != nil || !called {
t.Fatal(err, called)
}
failure := errors.New("mark denied")
if err := setDNSSocketMark(dnsFakeRaw{}, func(int, int, int, int) error { return failure }); err != failure {
t.Fatal(err)
}
if err := setDNSSocketMark(dnsFakeRaw{err: failure}, func(int, int, int, int) error { t.Fatal("called on raw failure"); return nil }); err != failure {
t.Fatal(err)
}
}
func TestDNSTCPFramesAndCancellation(t *testing.T) {
f := testDNSForwarder(t, func(r *http.Request) (*http.Response, error) {
q, _ := io.ReadAll(r.Body)
return dnsHTTPResponse(testDNSResponse(q)), nil
})
server, client := net.Pipe()
ctx, cancel := context.WithCancel(context.Background())
done := make(chan struct{})
go func() { defer close(done); f.tcpWorker(ctx, server) }()
defer client.Close()
client.SetDeadline(time.Now().Add(3 * time.Second))
q := testDNSQuery()
for i := 0; i < 2; i++ {
q[1] = byte(i)
var size [2]byte
binary.BigEndian.PutUint16(size[:], uint16(len(q)))
if err := writeDNSFrame(client, size[:], q); err != nil {
t.Fatal(err)
}
if _, err := io.ReadFull(client, size[:]); err != nil {
t.Fatal(err)
}
b := make([]byte, int(binary.BigEndian.Uint16(size[:])))
if _, err := io.ReadFull(client, b); err != nil || !bytes.Equal(b, testDNSResponse(q)) {
t.Fatal(err, b)
}
}
cancel()
select {
case <-done:
case <-time.After(time.Second):
t.Fatal("idle TCP worker did not join")
}
}
func TestDNSTCPLimits(t *testing.T) {
for _, n := range []int{11, 4097, 65535} {
t.Run(fmt.Sprint(n), func(t *testing.T) {
f := testDNSForwarder(t, func(*http.Request) (*http.Response, error) {
t.Error("invalid frame forwarded")
return nil, errDNSForwarder
})
server, client := net.Pipe()
done := make(chan struct{})
go func() { defer close(done); f.tcpWorker(context.Background(), server) }()
client.SetDeadline(time.Now().Add(time.Second))
var size [2]byte
binary.BigEndian.PutUint16(size[:], uint16(n))
client.Write(size[:])
select {
case <-done:
case <-time.After(time.Second):
t.Fatal("invalid frame not closed")
}
client.Close()
})
}
f := testDNSForwarder(t, func(r *http.Request) (*http.Response, error) {
q, _ := io.ReadAll(r.Body)
return dnsHTTPResponse(testDNSResponse(q)), nil
})
server, client := net.Pipe()
defer client.Close()
client.SetDeadline(time.Now().Add(3 * time.Second))
done := make(chan struct{})
go func() { defer close(done); f.tcpWorker(context.Background(), server) }()
q := testDNSQuery()
var size [2]byte
for i := 0; i < 16; i++ {
binary.BigEndian.PutUint16(size[:], uint16(len(q)))
if err := writeDNSFrame(client, size[:], q); err != nil {
t.Fatal(err)
}
if _, err := io.ReadFull(client, size[:]); err != nil {
t.Fatal(err)
}
if _, err := io.CopyN(io.Discard, client, int64(binary.BigEndian.Uint16(size[:]))); err != nil {
t.Fatal(err)
}
}
select {
case <-done:
case <-time.After(time.Second):
t.Fatal("frame lifetime cap not enforced")
}
}
func TestDNSRedirectNeverFollowed(t *testing.T) {
cfg := dnsConfigForTest(t, nil)
client, transport := newDNSHTTPClient(cfg, markDNSSocket)
defer transport.CloseIdleConnections()
var calls int
client.Transport = dnsRoundTripFunc(func(*http.Request) (*http.Response, error) {
calls++
return &http.Response{StatusCode: 302, Header: http.Header{"Location": {"https://secret.example/dns-query"}}, Body: io.NopCloser(bytes.NewReader(nil))}, nil
})
f := &dnsForwarder{cfg: cfg, client: client}
if !bytes.Equal(f.exchange(context.Background(), testDNSQuery()), dnsServfail(testDNSQuery())) || calls != 1 {
t.Fatal("redirect followed", calls)
}
}
func TestDNSReadinessFailureClosesListeners(t *testing.T) {
f := testDNSForwarder(t, func(*http.Request) (*http.Response, error) {
t.Error("request before ready")
return nil, errDNSForwarder
})
p := &dnsFakePacketConn{closed: make(chan struct{})}
l := &dnsIdleListener{closed: make(chan struct{})}
if err := f.run(context.Background(), p, l, func() (func(), error) { return nil, errDNSForwarder }); err == nil {
t.Fatal("readiness error ignored")
}
select {
case <-p.closed:
default:
t.Fatal("UDP not closed")
}
select {
case <-l.closed:
default:
t.Fatal("TCP not closed")
}
}
func TestDNSReadyOwnership(t *testing.T) {
dir := t.TempDir()
os.Chmod(dir, 0700)
path := filepath.Join(dir, "dns-ready")
cleanup, err := createDNSReady(path)
if err != nil {
t.Fatal(err)
}
info, _ := os.Stat(path)
body, _ := os.ReadFile(path)
if info.Mode().Perm() != 0600 || string(body) != fmt.Sprintf("%d\n", os.Getpid()) {
t.Fatal(info, string(body))
}
if _, err := createDNSReady(path); err == nil {
t.Fatal("existing readiness overwritten")
}
if entries, err := os.ReadDir(dir); err != nil || len(entries) != 1 || entries[0].Name() != "dns-ready" {
t.Fatal("readiness publication/failure left a temporary link", entries, err)
}
// The forwarder itself must hold both descriptors, not the test, so an
// unlinked readiness inode cannot be recycled for a foreign replacement.
fileFD := dnsHeldFD(t, info)
parentInfo, _ := os.Stat(dir)
parentFD := dnsHeldFD(t, parentInfo)
os.Remove(path)
var held syscall.Stat_t
if err := syscall.Fstat(fileFD, &held); err != nil || held.Nlink != 0 {
t.Fatal("readiness inode not held after unlink", err, held.Nlink)
}
os.WriteFile(path, []byte("replacement"), 0600)
cleanup()
cleanup() // Idempotent even after its descriptors have been closed.
for _, fd := range []int{fileFD, parentFD} {
if err := syscall.Fstat(fd, &held); err != syscall.EBADF {
t.Fatal("cleanup leaked descriptor", fd, err)
}
}
if b, err := os.ReadFile(path); err != nil || string(b) != "replacement" {
t.Fatal("foreign readiness removed", err)
}
os.Remove(path)
cleanup, err = createDNSReady(path)
if err != nil {
t.Fatal(err)
}
cleanup()
if _, err := os.Lstat(path); !os.IsNotExist(err) {
t.Fatal(err)
}
os.Symlink("missing", path)
if _, err := createDNSReady(path); err == nil {
t.Fatal("symlink accepted")
}
os.Remove(path)
os.Chmod(dir, 0755)
if _, err := createDNSReady(path); err == nil {
t.Fatal("public parent accepted")
}
}
func dnsHeldFD(t *testing.T, info os.FileInfo) int {
t.Helper()
entries, err := os.ReadDir("/proc/self/fd")
if err != nil {
t.Fatal(err)
}
want := info.Sys().(*syscall.Stat_t)
for _, entry := range entries {
fd, err := strconv.Atoi(entry.Name())
if err != nil {
continue
}
var stat syscall.Stat_t
if syscall.Fstat(fd, &stat) == nil && stat.Ino == want.Ino && stat.Dev == want.Dev {
return fd
}
}
t.Fatal("owned inode has no held descriptor")
return -1
}
func TestDNSReadyAtomicPublication(t *testing.T) {
dir := t.TempDir()
file, err := os.CreateTemp(dir, ".dns-ready-")
if err != nil {
t.Fatal(err)
}
defer file.Close()
path := filepath.Join(dir, "dns-ready")
if _, err := os.Lstat(path); !os.IsNotExist(err) {
t.Fatal("readiness published before PID", err)
}
if err := publishDNSReady(file, path); err != nil {
t.Fatal(err)
}
if body, err := os.ReadFile(path); err != nil || string(body) != fmt.Sprintf("%d\n", os.Getpid()) {
t.Fatal("partial PID published", string(body), err)
}
other, err := os.CreateTemp(dir, "foreign-")
if err != nil {
t.Fatal(err)
}
defer other.Close()
if err := publishDNSReady(other, path); !os.IsExist(err) {
t.Fatal("publication overwrote existing inode", err)
}
if body, _ := os.ReadFile(path); string(body) != fmt.Sprintf("%d\n", os.Getpid()) {
t.Fatal("original PID changed")
}
}
// Verify actual certificate validation over net.Pipe, never a TCP network listener.
func TestDNSVerifiedTLSOverPipe(t *testing.T) {
key, err := rsa.GenerateKey(rand.Reader, 2048)
if err != nil {
t.Fatal(err)
}
template := &x509.Certificate{SerialNumber: big.NewInt(1), Subject: pkix.Name{CommonName: "dns.google"}, DNSNames: []string{"dns.google"}, NotBefore: time.Now().Add(-time.Hour), NotAfter: time.Now().Add(time.Hour), KeyUsage: x509.KeyUsageDigitalSignature | x509.KeyUsageCertSign, ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth}, IsCA: true, BasicConstraintsValid: true}
der, err := x509.CreateCertificate(rand.Reader, template, template, &key.PublicKey, key)
if err != nil {
t.Fatal(err)
}
cert, err := x509.ParseCertificate(der)
if err != nil {
t.Fatal(err)
}
for _, name := range []string{"trusted", "untrusted", "wrong-name"} {
t.Run(name, func(t *testing.T) {
cfg := dnsConfigForTest(t, nil)
client, transport := newDNSHTTPClient(cfg, markDNSSocket)
defer transport.CloseIdleConnections()
if name != "untrusted" {
roots := x509.NewCertPool()
roots.AddCert(cert)
transport.TLSClientConfig.RootCAs = roots
}
if name == "wrong-name" {
transport.TLSClientConfig.ServerName = "wrong.example"
}
var servers sync.WaitGroup
transport.DialContext = dnsBootstrapDial(cfg, func(ctx context.Context, _, addr string) (net.Conn, error) {
if addr != "8.8.8.8:443" && addr != "8.8.4.4:443" {
t.Error(addr)
}
a, b := net.Pipe()
servers.Add(1)
go func() {
defer servers.Done()
defer b.Close()
b.SetDeadline(time.Now().Add(3 * time.Second))
tlsConn := tls.Server(b, &tls.Config{Certificates: []tls.Certificate{{Certificate: [][]byte{der}, PrivateKey: key}}, MinVersion: tls.VersionTLS12})
if err := tlsConn.Handshake(); err != nil {
return
}
if tlsConn.ConnectionState().ServerName != "dns.google" {
t.Error("SNI changed")
}
request, err := http.ReadRequest(bufio.NewReader(tlsConn))
if err != nil {
return
}
q, _ := io.ReadAll(request.Body)
request.Body.Close()
response := dnsHTTPResponse(testDNSResponse(q))
response.Close = true
response.Write(tlsConn)
}()
return a, nil
})
f := &dnsForwarder{cfg: cfg, client: client}
actual := f.exchange(context.Background(), testDNSQuery())
want := dnsServfail(testDNSQuery())
if name == "trusted" {
want = testDNSResponse(testDNSQuery())
}
if !bytes.Equal(actual, want) {
t.Fatal(actual)
}
transport.CloseIdleConnections()
servers.Wait()
})
}
}
type dnsTestPacket struct {
data []byte
addr net.Addr
}
type dnsFakePacketConn struct {
incoming chan dnsTestPacket
outgoing chan dnsTestPacket
closed chan struct{}
once sync.Once
}
func (p *dnsFakePacketConn) ReadFrom(b []byte) (int, net.Addr, error) {
select {
case q := <-p.incoming:
return copy(b, q.data), q.addr, nil
case <-p.closed:
return 0, nil, net.ErrClosed
}
}
func (p *dnsFakePacketConn) WriteTo(b []byte, a net.Addr) (int, error) {
select {
case p.outgoing <- dnsTestPacket{append([]byte(nil), b...), a}:
return len(b), nil
case <-p.closed:
return 0, net.ErrClosed
}
}
func (p *dnsFakePacketConn) Close() error { p.once.Do(func() { close(p.closed) }); return nil }
func (p *dnsFakePacketConn) LocalAddr() net.Addr { return &net.UDPAddr{} }
func (p *dnsFakePacketConn) SetDeadline(time.Time) error { return nil }
func (p *dnsFakePacketConn) SetReadDeadline(time.Time) error { return nil }
func (p *dnsFakePacketConn) SetWriteDeadline(time.Time) error { return nil }
type dnsIdleListener struct {
closed chan struct{}
once sync.Once
}
func (l *dnsIdleListener) Accept() (net.Conn, error) { <-l.closed; return nil, net.ErrClosed }
func (l *dnsIdleListener) Close() error { l.once.Do(func() { close(l.closed) }); return nil }
func (l *dnsIdleListener) Addr() net.Addr { return &net.TCPAddr{} }
func TestDNSUDPBoundedCopiesAndJoins(t *testing.T) {
var active, maximum atomic.Int32
started := make(chan struct{}, dnsConcurrency)
f := testDNSForwarder(t, func(r *http.Request) (*http.Response, error) {
n := active.Add(1)
defer active.Add(-1)
for old := maximum.Load(); n > old; old = maximum.Load() {
if maximum.CompareAndSwap(old, n) {
break
}
}
q, _ := io.ReadAll(r.Body)
started <- struct{}{}
<-r.Context().Done()
if q[1] >= dnsConcurrency {
t.Error("UDP buffer was reused")
}
return nil, r.Context().Err()
})
p := &dnsFakePacketConn{incoming: make(chan dnsTestPacket, 32), outgoing: make(chan dnsTestPacket, 32), closed: make(chan struct{})}
l := &dnsIdleListener{closed: make(chan struct{})}
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
ready := make(chan struct{})
cleaned := make(chan struct{})
done := make(chan error, 1)
go func() {
done <- f.run(ctx, p, l, func() (func(), error) { close(ready); return func() { close(cleaned) }, nil })
}()
<-ready
for i := 0; i < dnsConcurrency; i++ {
q := testDNSQuery()
q[1] = byte(i)
p.incoming <- dnsTestPacket{q, &net.UDPAddr{}}
}
for i := 0; i < dnsConcurrency; i++ {
select {
case <-started:
case <-time.After(time.Second):
t.Fatal("worker not started")
}
}
q := testDNSQuery()
q[1] = 99
p.incoming <- dnsTestPacket{q, &net.UDPAddr{}}
select {
case response := <-p.outgoing:
if !bytes.Equal(response.data, dnsServfail(q)) {
t.Fatal(response)
}
case <-time.After(time.Second):
t.Fatal("saturation not SERVFAIL")
}
cancel()
select {
case err := <-done:
if err != nil {
t.Fatal(err)
}
case <-time.After(time.Second):
t.Fatal("workers not joined")
}
<-cleaned
if maximum.Load() != dnsConcurrency || active.Load() != 0 || len(f.slots) != 0 {
t.Fatal(maximum.Load(), active.Load(), len(f.slots))
}
}