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>
143 lines
3.9 KiB
Go
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)
|
|
}
|
|
}
|