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