* gcc-interface/decl.c (warn_on_field_placement): Issue the warning

[official-gcc.git] / libgo / go / net / dnsclient_unix_test.go

// Copyright 2013 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// +build aix darwin dragonfly freebsd linux netbsd openbsd solaris

package net

import (
        "context"
        "fmt"
        "internal/testenv"
        "io/ioutil"
        "os"
        "path"
        "reflect"
        "strings"
        "sync"
        "testing"
        "time"
)

// Test address from 192.0.2.0/24 block, reserved by RFC 5737 for documentation.
const TestAddr uint32 = 0xc0000201

var dnsTransportFallbackTests = []struct {
        server  string
        name    string
        qtype   uint16
        timeout int
        rcode   int
}{
        // Querying "com." with qtype=255 usually makes an answer
        // which requires more than 512 bytes.
        {"8.8.8.8:53", "com.", dnsTypeALL, 2, dnsRcodeSuccess},
        {"8.8.4.4:53", "com.", dnsTypeALL, 4, dnsRcodeSuccess},
}

func TestDNSTransportFallback(t *testing.T) {
        testenv.MustHaveExternalNetwork(t)

        for _, tt := range dnsTransportFallbackTests {
                ctx, cancel := context.WithCancel(context.Background())
                defer cancel()
                msg, err := exchange(ctx, tt.server, tt.name, tt.qtype, time.Second)
                if err != nil {
                        t.Error(err)
                        continue
                }
                switch msg.rcode {
                case tt.rcode, dnsRcodeServerFailure:
                default:
                        t.Errorf("got %v from %v; want %v", msg.rcode, tt.server, tt.rcode)
                        continue
                }
        }
}

// See RFC 6761 for further information about the reserved, pseudo
// domain names.
var specialDomainNameTests = []struct {
        name  string
        qtype uint16
        rcode int
}{
        // Name resolution APIs and libraries should not recognize the
        // followings as special.
        {"1.0.168.192.in-addr.arpa.", dnsTypePTR, dnsRcodeNameError},
        {"test.", dnsTypeALL, dnsRcodeNameError},
        {"example.com.", dnsTypeALL, dnsRcodeSuccess},

        // Name resolution APIs and libraries should recognize the
        // followings as special and should not send any queries.
        // Though, we test those names here for verifying negative
        // answers at DNS query-response interaction level.
        {"localhost.", dnsTypeALL, dnsRcodeNameError},
        {"invalid.", dnsTypeALL, dnsRcodeNameError},
}

func TestSpecialDomainName(t *testing.T) {
        testenv.MustHaveExternalNetwork(t)

        server := "8.8.8.8:53"
        for _, tt := range specialDomainNameTests {
                ctx, cancel := context.WithCancel(context.Background())
                defer cancel()
                msg, err := exchange(ctx, server, tt.name, tt.qtype, 3*time.Second)
                if err != nil {
                        t.Error(err)
                        continue
                }
                switch msg.rcode {
                case tt.rcode, dnsRcodeServerFailure:
                default:
                        t.Errorf("got %v from %v; want %v", msg.rcode, server, tt.rcode)
                        continue
                }
        }
}

// Issue 13705: don't try to resolve onion addresses, etc
func TestAvoidDNSName(t *testing.T) {
        tests := []struct {
                name  string
                avoid bool
        }{
                {"foo.com", false},
                {"foo.com.", false},

                {"foo.onion.", true},
                {"foo.onion", true},
                {"foo.ONION", true},
                {"foo.ONION.", true},

                // But do resolve *.local address; Issue 16739
                {"foo.local.", false},
                {"foo.local", false},
                {"foo.LOCAL", false},
                {"foo.LOCAL.", false},

                {"", true}, // will be rejected earlier too

                // Without stuff before onion/local, they're fine to
                // use DNS. With a search path,
                // "onion.vegegtables.com" can use DNS. Without a
                // search path (or with a trailing dot), the queries
                // are just kinda useless, but don't reveal anything
                // private.
                {"local", false},
                {"onion", false},
                {"local.", false},
                {"onion.", false},
        }
        for _, tt := range tests {
                got := avoidDNS(tt.name)
                if got != tt.avoid {
                        t.Errorf("avoidDNS(%q) = %v; want %v", tt.name, got, tt.avoid)
                }
        }
}

// Issue 13705: don't try to resolve onion addresses, etc
func TestLookupTorOnion(t *testing.T) {
        addrs, err := goLookupIP(context.Background(), "foo.onion")
        if len(addrs) > 0 {
                t.Errorf("unexpected addresses: %v", addrs)
        }
        if err != nil {
                t.Fatalf("lookup = %v; want nil", err)
        }
}

type resolvConfTest struct {
        dir  string
        path string
        *resolverConfig
}

func newResolvConfTest() (*resolvConfTest, error) {
        dir, err := ioutil.TempDir("", "go-resolvconftest")
        if err != nil {
                return nil, err
        }
        conf := &resolvConfTest{
                dir:            dir,
                path:           path.Join(dir, "resolv.conf"),
                resolverConfig: &resolvConf,
        }
        conf.initOnce.Do(conf.init)
        return conf, nil
}

func (conf *resolvConfTest) writeAndUpdate(lines []string) error {
        f, err := os.OpenFile(conf.path, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0600)
        if err != nil {
                return err
        }
        if _, err := f.WriteString(strings.Join(lines, "\n")); err != nil {
                f.Close()
                return err
        }
        f.Close()
        if err := conf.forceUpdate(conf.path, time.Now().Add(time.Hour)); err != nil {
                return err
        }
        return nil
}

func (conf *resolvConfTest) forceUpdate(name string, lastChecked time.Time) error {
        dnsConf := dnsReadConfig(name)
        conf.mu.Lock()
        conf.dnsConfig = dnsConf
        conf.mu.Unlock()
        for i := 0; i < 5; i++ {
                if conf.tryAcquireSema() {
                        conf.lastChecked = lastChecked
                        conf.releaseSema()
                        return nil
                }
        }
        return fmt.Errorf("tryAcquireSema for %s failed", name)
}

func (conf *resolvConfTest) servers() []string {
        conf.mu.RLock()
        servers := conf.dnsConfig.servers
        conf.mu.RUnlock()
        return servers
}

func (conf *resolvConfTest) teardown() error {
        err := conf.forceUpdate("/etc/resolv.conf", time.Time{})
        os.RemoveAll(conf.dir)
        return err
}

var updateResolvConfTests = []struct {
        name    string   // query name
        lines   []string // resolver configuration lines
        servers []string // expected name servers
}{
        {
                name:    "golang.org",
                lines:   []string{"nameserver 8.8.8.8"},
                servers: []string{"8.8.8.8:53"},
        },
        {
                name:    "",
                lines:   nil, // an empty resolv.conf should use defaultNS as name servers
                servers: defaultNS,
        },
        {
                name:    "www.example.com",
                lines:   []string{"nameserver 8.8.4.4"},
                servers: []string{"8.8.4.4:53"},
        },
}

func TestUpdateResolvConf(t *testing.T) {
        testenv.MustHaveExternalNetwork(t)

        conf, err := newResolvConfTest()
        if err != nil {
                t.Fatal(err)
        }
        defer conf.teardown()

        for i, tt := range updateResolvConfTests {
                if err := conf.writeAndUpdate(tt.lines); err != nil {
                        t.Error(err)
                        continue
                }
                if tt.name != "" {
                        var wg sync.WaitGroup
                        const N = 10
                        wg.Add(N)
                        for j := 0; j < N; j++ {
                                go func(name string) {
                                        defer wg.Done()
                                        ips, err := goLookupIP(context.Background(), name)
                                        if err != nil {
                                                t.Error(err)
                                                return
                                        }
                                        if len(ips) == 0 {
                                                t.Errorf("no records for %s", name)
                                                return
                                        }
                                }(tt.name)
                        }
                        wg.Wait()
                }
                servers := conf.servers()
                if !reflect.DeepEqual(servers, tt.servers) {
                        t.Errorf("#%d: got %v; want %v", i, servers, tt.servers)
                        continue
                }
        }
}

var goLookupIPWithResolverConfigTests = []struct {
        name  string
        lines []string // resolver configuration lines
        error
        a, aaaa bool // whether response contains A, AAAA-record
}{
        // no records, transport timeout
        {
                "jgahvsekduiv9bw4b3qhn4ykdfgj0493iohkrjfhdvhjiu4j",
                []string{
                        "options timeout:1 attempts:1",
                        "nameserver 255.255.255.255", // please forgive us for abuse of limited broadcast address
                },
                &DNSError{Name: "jgahvsekduiv9bw4b3qhn4ykdfgj0493iohkrjfhdvhjiu4j", Server: "255.255.255.255:53", IsTimeout: true},
                false, false,
        },

        // no records, non-existent domain
        {
                "jgahvsekduiv9bw4b3qhn4ykdfgj0493iohkrjfhdvhjiu4j",
                []string{
                        "options timeout:3 attempts:1",
                        "nameserver 8.8.8.8",
                },
                &DNSError{Name: "jgahvsekduiv9bw4b3qhn4ykdfgj0493iohkrjfhdvhjiu4j", Server: "8.8.8.8:53", IsTimeout: false},
                false, false,
        },

        // a few A records, no AAAA records
        {
                "ipv4.google.com.",
                []string{
                        "nameserver 8.8.8.8",
                        "nameserver 2001:4860:4860::8888",
                },
                nil,
                true, false,
        },
        {
                "ipv4.google.com",
                []string{
                        "domain golang.org",
                        "nameserver 2001:4860:4860::8888",
                        "nameserver 8.8.8.8",
                },
                nil,
                true, false,
        },
        {
                "ipv4.google.com",
                []string{
                        "search x.golang.org y.golang.org",
                        "nameserver 2001:4860:4860::8888",
                        "nameserver 8.8.8.8",
                },
                nil,
                true, false,
        },

        // no A records, a few AAAA records
        {
                "ipv6.google.com.",
                []string{
                        "nameserver 2001:4860:4860::8888",
                        "nameserver 8.8.8.8",
                },
                nil,
                false, true,
        },
        {
                "ipv6.google.com",
                []string{
                        "domain golang.org",
                        "nameserver 8.8.8.8",
                        "nameserver 2001:4860:4860::8888",
                },
                nil,
                false, true,
        },
        {
                "ipv6.google.com",
                []string{
                        "search x.golang.org y.golang.org",
                        "nameserver 8.8.8.8",
                        "nameserver 2001:4860:4860::8888",
                },
                nil,
                false, true,
        },

        // both A and AAAA records
        {
                "hostname.as112.net", // see RFC 7534
                []string{
                        "domain golang.org",
                        "nameserver 2001:4860:4860::8888",
                        "nameserver 8.8.8.8",
                },
                nil,
                true, true,
        },
        {
                "hostname.as112.net", // see RFC 7534
                []string{
                        "search x.golang.org y.golang.org",
                        "nameserver 2001:4860:4860::8888",
                        "nameserver 8.8.8.8",
                },
                nil,
                true, true,
        },
}

func TestGoLookupIPWithResolverConfig(t *testing.T) {
        testenv.MustHaveExternalNetwork(t)

        conf, err := newResolvConfTest()
        if err != nil {
                t.Fatal(err)
        }
        defer conf.teardown()

        for _, tt := range goLookupIPWithResolverConfigTests {
                if err := conf.writeAndUpdate(tt.lines); err != nil {
                        t.Error(err)
                        continue
                }
                addrs, err := goLookupIP(context.Background(), tt.name)
                if err != nil {
                        // This test uses external network connectivity.
                        // We need to take care with errors on both
                        // DNS message exchange layer and DNS
                        // transport layer because goLookupIP may fail
                        // when the IP connectivity on node under test
                        // gets lost during its run.
                        if err, ok := err.(*DNSError); !ok || tt.error != nil && (err.Name != tt.error.(*DNSError).Name || err.Server != tt.error.(*DNSError).Server || err.IsTimeout != tt.error.(*DNSError).IsTimeout) {
                                t.Errorf("got %v; want %v", err, tt.error)
                        }
                        continue
                }
                if len(addrs) == 0 {
                        t.Errorf("no records for %s", tt.name)
                }
                if !tt.a && !tt.aaaa && len(addrs) > 0 {
                        t.Errorf("unexpected %v for %s", addrs, tt.name)
                }
                for _, addr := range addrs {
                        if !tt.a && addr.IP.To4() != nil {
                                t.Errorf("got %v; must not be IPv4 address", addr)
                        }
                        if !tt.aaaa && addr.IP.To16() != nil && addr.IP.To4() == nil {
                                t.Errorf("got %v; must not be IPv6 address", addr)
                        }
                }
        }
}

// Test that goLookupIPOrder falls back to the host file when no DNS servers are available.
func TestGoLookupIPOrderFallbackToFile(t *testing.T) {
        testenv.MustHaveExternalNetwork(t)

        // Add a config that simulates no dns servers being available.
        conf, err := newResolvConfTest()
        if err != nil {
                t.Fatal(err)
        }
        if err := conf.writeAndUpdate([]string{}); err != nil {
                t.Fatal(err)
        }
        // Redirect host file lookups.
        defer func(orig string) { testHookHostsPath = orig }(testHookHostsPath)
        testHookHostsPath = "testdata/hosts"

        for _, order := range []hostLookupOrder{hostLookupFilesDNS, hostLookupDNSFiles} {
                name := fmt.Sprintf("order %v", order)

                // First ensure that we get an error when contacting a non-existent host.
                _, _, err := goLookupIPCNAMEOrder(context.Background(), "notarealhost", order)
                if err == nil {
                        t.Errorf("%s: expected error while looking up name not in hosts file", name)
                        continue
                }

                // Now check that we get an address when the name appears in the hosts file.
                addrs, _, err := goLookupIPCNAMEOrder(context.Background(), "thor", order) // entry is in "testdata/hosts"
                if err != nil {
                        t.Errorf("%s: expected to successfully lookup host entry", name)
                        continue
                }
                if len(addrs) != 1 {
                        t.Errorf("%s: expected exactly one result, but got %v", name, addrs)
                        continue
                }
                if got, want := addrs[0].String(), "127.1.1.1"; got != want {
                        t.Errorf("%s: address doesn't match expectation. got %v, want %v", name, got, want)
                }
        }
        defer conf.teardown()
}

// Issue 12712.
// When using search domains, return the error encountered
// querying the original name instead of an error encountered
// querying a generated name.
func TestErrorForOriginalNameWhenSearching(t *testing.T) {
        const fqdn = "doesnotexist.domain"

        origTestHookDNSDialer := testHookDNSDialer
        defer func() { testHookDNSDialer = origTestHookDNSDialer }()

        conf, err := newResolvConfTest()
        if err != nil {
                t.Fatal(err)
        }
        defer conf.teardown()

        if err := conf.writeAndUpdate([]string{"search servfail"}); err != nil {
                t.Fatal(err)
        }

        d := &fakeDNSDialer{}
        testHookDNSDialer = func() dnsDialer { return d }

        d.rh = func(s string, q *dnsMsg, _ time.Time) (*dnsMsg, error) {
                r := &dnsMsg{
                        dnsMsgHdr: dnsMsgHdr{
                                id: q.id,
                        },
                }

                switch q.question[0].Name {
                case fqdn + ".servfail.":
                        r.rcode = dnsRcodeServerFailure
                default:
                        r.rcode = dnsRcodeNameError
                }

                return r, nil
        }

        _, err = goLookupIP(context.Background(), fqdn)
        if err == nil {
                t.Fatal("expected an error")
        }

        want := &DNSError{Name: fqdn, Err: errNoSuchHost.Error()}
        if err, ok := err.(*DNSError); !ok || err.Name != want.Name || err.Err != want.Err {
                t.Errorf("got %v; want %v", err, want)
        }
}

// Issue 15434. If a name server gives a lame referral, continue to the next.
func TestIgnoreLameReferrals(t *testing.T) {
        origTestHookDNSDialer := testHookDNSDialer
        defer func() { testHookDNSDialer = origTestHookDNSDialer }()

        conf, err := newResolvConfTest()
        if err != nil {
                t.Fatal(err)
        }
        defer conf.teardown()

        if err := conf.writeAndUpdate([]string{"nameserver 192.0.2.1", // the one that will give a lame referral
                "nameserver 192.0.2.2"}); err != nil {
                t.Fatal(err)
        }

        d := &fakeDNSDialer{}
        testHookDNSDialer = func() dnsDialer { return d }

        d.rh = func(s string, q *dnsMsg, _ time.Time) (*dnsMsg, error) {
                t.Log(s, q)
                r := &dnsMsg{
                        dnsMsgHdr: dnsMsgHdr{
                                id:       q.id,
                                response: true,
                        },
                        question: q.question,
                }

                if s == "192.0.2.2:53" {
                        r.recursion_available = true
                        if q.question[0].Qtype == dnsTypeA {
                                r.answer = []dnsRR{
                                        &dnsRR_A{
                                                Hdr: dnsRR_Header{
                                                        Name:     q.question[0].Name,
                                                        Rrtype:   dnsTypeA,
                                                        Class:    dnsClassINET,
                                                        Rdlength: 4,
                                                },
                                                A: TestAddr,
                                        },
                                }
                        }
                }

                return r, nil
        }

        addrs, err := goLookupIP(context.Background(), "www.golang.org")
        if err != nil {
                t.Fatal(err)
        }

        if got := len(addrs); got != 1 {
                t.Fatalf("got %d addresses, want 1", got)
        }

        if got, want := addrs[0].String(), "192.0.2.1"; got != want {
                t.Fatalf("got address %v, want %v", got, want)
        }
}

func BenchmarkGoLookupIP(b *testing.B) {
        testHookUninstaller.Do(uninstallTestHooks)
        ctx := context.Background()

        for i := 0; i < b.N; i++ {
                goLookupIP(ctx, "www.example.com")
        }
}

func BenchmarkGoLookupIPNoSuchHost(b *testing.B) {
        testHookUninstaller.Do(uninstallTestHooks)
        ctx := context.Background()

        for i := 0; i < b.N; i++ {
                goLookupIP(ctx, "some.nonexistent")
        }
}

func BenchmarkGoLookupIPWithBrokenNameServer(b *testing.B) {
        testHookUninstaller.Do(uninstallTestHooks)

        conf, err := newResolvConfTest()
        if err != nil {
                b.Fatal(err)
        }
        defer conf.teardown()

        lines := []string{
                "nameserver 203.0.113.254", // use TEST-NET-3 block, see RFC 5737
                "nameserver 8.8.8.8",
        }
        if err := conf.writeAndUpdate(lines); err != nil {
                b.Fatal(err)
        }
        ctx := context.Background()

        for i := 0; i < b.N; i++ {
                goLookupIP(ctx, "www.example.com")
        }
}

type fakeDNSDialer struct {
        // reply handler
        rh func(s string, q *dnsMsg, t time.Time) (*dnsMsg, error)
}

func (f *fakeDNSDialer) dialDNS(_ context.Context, n, s string) (dnsConn, error) {
        return &fakeDNSConn{f.rh, s, time.Time{}}, nil
}

type fakeDNSConn struct {
        rh func(s string, q *dnsMsg, t time.Time) (*dnsMsg, error)
        s  string
        t  time.Time
}

func (f *fakeDNSConn) Close() error {
        return nil
}

func (f *fakeDNSConn) SetDeadline(t time.Time) error {
        f.t = t
        return nil
}

func (f *fakeDNSConn) dnsRoundTrip(q *dnsMsg) (*dnsMsg, error) {
        return f.rh(f.s, q, f.t)
}

// UDP round-tripper algorithm should ignore invalid DNS responses (issue 13281).
func TestIgnoreDNSForgeries(t *testing.T) {
        c, s := Pipe()
        go func() {
                b := make([]byte, 512)
                n, err := s.Read(b)
                if err != nil {
                        t.Error(err)
                        return
                }

                msg := &dnsMsg{}
                if !msg.Unpack(b[:n]) {
                        t.Error("invalid DNS query")
                        return
                }

                s.Write([]byte("garbage DNS response packet"))

                msg.response = true
                msg.id++ // make invalid ID
                b, ok := msg.Pack()
                if !ok {
                        t.Error("failed to pack DNS response")
                        return
                }
                s.Write(b)

                msg.id-- // restore original ID
                msg.answer = []dnsRR{
                        &dnsRR_A{
                                Hdr: dnsRR_Header{
                                        Name:     "www.example.com.",
                                        Rrtype:   dnsTypeA,
                                        Class:    dnsClassINET,
                                        Rdlength: 4,
                                },
                                A: TestAddr,
                        },
                }

                b, ok = msg.Pack()
                if !ok {
                        t.Error("failed to pack DNS response")
                        return
                }
                s.Write(b)
        }()

        msg := &dnsMsg{
                dnsMsgHdr: dnsMsgHdr{
                        id: 42,
                },
                question: []dnsQuestion{
                        {
                                Name:   "www.example.com.",
                                Qtype:  dnsTypeA,
                                Qclass: dnsClassINET,
                        },
                },
        }

        resp, err := dnsRoundTripUDP(c, msg)
        if err != nil {
                t.Fatalf("dnsRoundTripUDP failed: %v", err)
        }

        if got := resp.answer[0].(*dnsRR_A).A; got != TestAddr {
                t.Errorf("got address %v, want %v", got, TestAddr)
        }
}

// Issue 16865. If a name server times out, continue to the next.
func TestRetryTimeout(t *testing.T) {
        origTestHookDNSDialer := testHookDNSDialer
        defer func() { testHookDNSDialer = origTestHookDNSDialer }()

        conf, err := newResolvConfTest()
        if err != nil {
                t.Fatal(err)
        }
        defer conf.teardown()

        testConf := []string{
                "nameserver 192.0.2.1", // the one that will timeout
                "nameserver 192.0.2.2",
        }
        if err := conf.writeAndUpdate(testConf); err != nil {
                t.Fatal(err)
        }

        d := &fakeDNSDialer{}
        testHookDNSDialer = func() dnsDialer { return d }

        var deadline0 time.Time

        d.rh = func(s string, q *dnsMsg, deadline time.Time) (*dnsMsg, error) {
                t.Log(s, q, deadline)

                if deadline.IsZero() {
                        t.Error("zero deadline")
                }

                if s == "192.0.2.1:53" {
                        deadline0 = deadline
                        time.Sleep(10 * time.Millisecond)
                        return nil, errTimeout
                }

                if deadline == deadline0 {
                        t.Error("deadline didn't change")
                }

                return mockTXTResponse(q), nil
        }

        _, err = LookupTXT("www.golang.org")
        if err != nil {
                t.Fatal(err)
        }

        if deadline0.IsZero() {
                t.Error("deadline0 still zero", deadline0)
        }
}

func TestRotate(t *testing.T) {
        // without rotation, always uses the first server
        testRotate(t, false, []string{"192.0.2.1", "192.0.2.2"}, []string{"192.0.2.1:53", "192.0.2.1:53", "192.0.2.1:53"})

        // with rotation, rotates through back to first
        testRotate(t, true, []string{"192.0.2.1", "192.0.2.2"}, []string{"192.0.2.1:53", "192.0.2.2:53", "192.0.2.1:53"})
}

func testRotate(t *testing.T, rotate bool, nameservers, wantServers []string) {
        origTestHookDNSDialer := testHookDNSDialer
        defer func() { testHookDNSDialer = origTestHookDNSDialer }()

        conf, err := newResolvConfTest()
        if err != nil {
                t.Fatal(err)
        }
        defer conf.teardown()

        var confLines []string
        for _, ns := range nameservers {
                confLines = append(confLines, "nameserver "+ns)
        }
        if rotate {
                confLines = append(confLines, "options rotate")
        }

        if err := conf.writeAndUpdate(confLines); err != nil {
                t.Fatal(err)
        }

        d := &fakeDNSDialer{}
        testHookDNSDialer = func() dnsDialer { return d }

        var usedServers []string
        d.rh = func(s string, q *dnsMsg, _ time.Time) (*dnsMsg, error) {
                usedServers = append(usedServers, s)
                return mockTXTResponse(q), nil
        }

        // len(nameservers) + 1 to allow rotation to get back to start
        for i := 0; i < len(nameservers)+1; i++ {
                if _, err := LookupTXT("www.golang.org"); err != nil {
                        t.Fatal(err)
                }
        }

        if !reflect.DeepEqual(usedServers, wantServers) {
                t.Errorf("rotate=%t got used servers:\n%v\nwant:\n%v", rotate, usedServers, wantServers)
        }
}

func mockTXTResponse(q *dnsMsg) *dnsMsg {
        r := &dnsMsg{
                dnsMsgHdr: dnsMsgHdr{
                        id:                  q.id,
                        response:            true,
                        recursion_available: true,
                },
                question: q.question,
                answer: []dnsRR{
                        &dnsRR_TXT{
                                Hdr: dnsRR_Header{
                                        Name:   q.question[0].Name,
                                        Rrtype: dnsTypeTXT,
                                        Class:  dnsClassINET,
                                },
                                Txt: "ok",
                        },
                },
        }

        return r
}