From 721cad42ceecceec24200286b81eba52ab330d90 Mon Sep 17 00:00:00 2001 From: Zeusina Date: Tue, 13 Oct 2026 15:02:41 +0300 Subject: [PATCH] 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 --- cmd/zapret-autotune/dns_forwarder.go | 19 ++- .../dns_forwarder_tcp_deadline_test.go | 142 ++++++++++++++++++ 2 files changed, 158 insertions(+), 3 deletions(-) create mode 100644 cmd/zapret-autotune/dns_forwarder_tcp_deadline_test.go diff --git a/cmd/zapret-autotune/dns_forwarder.go b/cmd/zapret-autotune/dns_forwarder.go index 40b896f..78f42d3 100644 --- a/cmd/zapret-autotune/dns_forwarder.go +++ b/cmd/zapret-autotune/dns_forwarder.go @@ -332,7 +332,7 @@ func (f *dnsForwarder) tcpWorker(ctx context.Context, conn net.Conn) { if lifetime.Before(deadline) { deadline = lifetime } - if err := conn.SetDeadline(deadline); err != nil { + if err := conn.SetReadDeadline(deadline); err != nil { return } var size [2]byte @@ -347,8 +347,21 @@ func (f *dnsForwarder) tcpWorker(ctx context.Context, conn net.Conn) { if _, err := io.ReadFull(conn, query); err != nil { return } - reply := f.exchange(ctx, query) - if reply == nil { + if !time.Now().Before(lifetime) { + return + } + requestCtx, cancel := context.WithDeadline(ctx, lifetime) + reply := f.exchange(requestCtx, query) + cancel() + if reply == nil || !time.Now().Before(lifetime) { + return + } + // An upstream timeout must still leave a bounded window to send SERVFAIL. + deadline = time.Now().Add(f.cfg.Timeout) + if lifetime.Before(deadline) { + deadline = lifetime + } + if err := conn.SetWriteDeadline(deadline); err != nil { return } binary.BigEndian.PutUint16(size[:], uint16(len(reply))) diff --git a/cmd/zapret-autotune/dns_forwarder_tcp_deadline_test.go b/cmd/zapret-autotune/dns_forwarder_tcp_deadline_test.go new file mode 100644 index 0000000..04bea93 --- /dev/null +++ b/cmd/zapret-autotune/dns_forwarder_tcp_deadline_test.go @@ -0,0 +1,142 @@ +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) + } +}