Files
zapret-autotune/cmd/zapret-autotune/dns_forwarder_tcp_deadline_test.go
T
ZeusinaandGPT-6 Bot 721cad42ce fix: preserve DNS TCP replies after upstream timeout
Separate bounded TCP read, upstream and write phases while retaining the total connection lifetime. Add net.Pipe regressions for upstream timeout, partial reads, cancellation and lifetime limits.

Co-authored-by: GPT-6 <gpt-6@openai.com>
2026-10-13 15:02:41 +03:00

143 lines
3.9 KiB
Go

package main
import (
"bytes"
"context"
"encoding/binary"
"io"
"net"
"net/http"
"sync/atomic"
"testing"
"time"
)
func TestDNSTCPUpstreamTimeoutStillWritesServfail(t *testing.T) {
for _, slowRead := range []bool{false, true} {
name := "upstream-timeout"
if slowRead {
name = "partial-frame-then-upstream-timeout"
}
t.Run(name, func(t *testing.T) {
f := testDNSForwarder(t, func(r *http.Request) (*http.Response, error) {
<-r.Context().Done()
return nil, r.Context().Err()
})
f.cfg.Timeout = 80 * time.Millisecond
server, client := net.Pipe()
defer client.Close()
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
done := make(chan struct{})
go func() { defer close(done); f.tcpWorker(ctx, server) }()
client.SetDeadline(time.Now().Add(time.Second))
query := testDNSQuery()
var size [2]byte
binary.BigEndian.PutUint16(size[:], uint16(len(query)))
if _, err := client.Write(size[:]); err != nil {
t.Fatal(err)
}
if slowRead {
if _, err := client.Write(query[:1]); err != nil {
t.Fatal(err)
}
time.Sleep(20 * time.Millisecond)
query = query[1:]
}
if _, err := client.Write(query); err != nil {
t.Fatal(err)
}
if _, err := io.ReadFull(client, size[:]); err != nil {
t.Fatal("upstream timeout closed TCP instead of writing SERVFAIL", err)
}
reply := make([]byte, int(binary.BigEndian.Uint16(size[:])))
if _, err := io.ReadFull(client, reply); err != nil || !bytes.Equal(reply, dnsServfail(testDNSQuery())) {
t.Fatal("invalid framed SERVFAIL", reply, err)
}
cancel()
select {
case <-done:
case <-time.After(time.Second):
t.Fatal("worker did not join")
}
})
}
}
func TestDNSTCPCancellationDuringUpstream(t *testing.T) {
started := make(chan struct{})
f := testDNSForwarder(t, func(r *http.Request) (*http.Response, error) {
close(started)
<-r.Context().Done()
return nil, r.Context().Err()
})
server, client := net.Pipe()
defer client.Close()
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
done := make(chan struct{})
go func() { defer close(done); f.tcpWorker(ctx, server) }()
client.SetDeadline(time.Now().Add(time.Second))
query := testDNSQuery()
var size [2]byte
binary.BigEndian.PutUint16(size[:], uint16(len(query)))
if err := writeDNSFrame(client, size[:], query); err != nil {
t.Fatal(err)
}
<-started
cancel()
select {
case <-done:
case <-time.After(time.Second):
t.Fatal("upstream cancellation did not join TCP worker")
}
if _, err := client.Read(size[:]); err == nil {
t.Fatal("cancelled TCP connection remained open")
}
}
func TestDNSTCPTimeoutPhasesDoNotExtendLifetime(t *testing.T) {
var requests atomic.Int32
f := testDNSForwarder(t, func(r *http.Request) (*http.Response, error) {
requests.Add(1)
<-r.Context().Done()
return nil, r.Context().Err()
})
f.cfg.Timeout = 20 * time.Millisecond
server, client := net.Pipe()
defer client.Close()
done := make(chan struct{})
start := time.Now()
go func() { defer close(done); f.tcpWorker(context.Background(), server) }()
client.SetDeadline(start.Add(2 * time.Second))
query := testDNSQuery()
var size [2]byte
for frame := 0; frame < 17; frame++ {
binary.BigEndian.PutUint16(size[:], uint16(len(query)))
if err := writeDNSFrame(client, size[:], query); err != nil {
break
}
if _, err := io.ReadFull(client, size[:]); err != nil {
break
}
reply := make([]byte, int(binary.BigEndian.Uint16(size[:])))
if _, err := io.ReadFull(client, reply); err != nil {
break
}
if !bytes.Equal(reply, dnsServfail(query)) {
t.Fatal("invalid SERVFAIL")
}
}
select {
case <-done:
case <-time.After(time.Second):
t.Fatal("total lifetime not enforced")
}
if elapsed := time.Since(start); elapsed > 16*f.cfg.Timeout+200*time.Millisecond {
t.Fatal("phase deadlines extended total lifetime", elapsed)
}
if n := requests.Load(); n < 2 || n > 16 {
t.Fatal("unexpected request count", n)
}
}