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>
This commit is contained in:
ZeusinaandGPT-6 Bot committed 2026-10-13 15:02:41 +03:00
1 parent 367d956ae3
commit 721cad42ce
2 files changed
+158 -3

No files matched your search

+16 -3
View File
@@ -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)))
@@ -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)
}
}