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) + } +}