From 473acc61c8392dc7ae303d91568e179c4f105a76 Mon Sep 17 00:00:00 2001 From: Dimitri Sokolyuk Date: Tue, 2 Jul 2019 12:12:53 +0200 Subject: add black list --- .../x/net/dns/dnsmessage/message_test.go | 1451 -------------------- 1 file changed, 1451 deletions(-) delete mode 100644 vendor/golang.org/x/net/dns/dnsmessage/message_test.go (limited to 'vendor/golang.org/x/net/dns/dnsmessage/message_test.go') diff --git a/vendor/golang.org/x/net/dns/dnsmessage/message_test.go b/vendor/golang.org/x/net/dns/dnsmessage/message_test.go deleted file mode 100644 index 25ba8f0..0000000 --- a/vendor/golang.org/x/net/dns/dnsmessage/message_test.go +++ /dev/null @@ -1,1451 +0,0 @@ -// Copyright 2009 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. - -package dnsmessage - -import ( - "bytes" - "fmt" - "reflect" - "strings" - "testing" -) - -func TestPrintPaddedUint8(t *testing.T) { - tests := []struct { - num uint8 - want string - }{ - {0, "000"}, - {1, "001"}, - {9, "009"}, - {10, "010"}, - {99, "099"}, - {100, "100"}, - {124, "124"}, - {104, "104"}, - {120, "120"}, - {255, "255"}, - } - - for _, test := range tests { - if got := printPaddedUint8(test.num); got != test.want { - t.Errorf("got printPaddedUint8(%d) = %s, want = %s", test.num, got, test.want) - } - } -} - -func TestPrintUint8Bytes(t *testing.T) { - tests := []uint8{ - 0, - 1, - 9, - 10, - 99, - 100, - 124, - 104, - 120, - 255, - } - - for _, test := range tests { - if got, want := string(printUint8Bytes(nil, test)), fmt.Sprint(test); got != want { - t.Errorf("got printUint8Bytes(%d) = %s, want = %s", test, got, want) - } - } -} - -func TestPrintUint16(t *testing.T) { - tests := []uint16{ - 65535, - 0, - 1, - 10, - 100, - 1000, - 10000, - 324, - 304, - 320, - } - - for _, test := range tests { - if got, want := printUint16(test), fmt.Sprint(test); got != want { - t.Errorf("got printUint16(%d) = %s, want = %s", test, got, want) - } - } -} - -func TestPrintUint32(t *testing.T) { - tests := []uint32{ - 4294967295, - 65535, - 0, - 1, - 10, - 100, - 1000, - 10000, - 100000, - 1000000, - 10000000, - 100000000, - 1000000000, - 324, - 304, - 320, - } - - for _, test := range tests { - if got, want := printUint32(test), fmt.Sprint(test); got != want { - t.Errorf("got printUint32(%d) = %s, want = %s", test, got, want) - } - } -} - -func mustEDNS0ResourceHeader(l int, extrc RCode, do bool) ResourceHeader { - h := ResourceHeader{Class: ClassINET} - if err := h.SetEDNS0(l, extrc, do); err != nil { - panic(err) - } - return h -} - -func (m *Message) String() string { - s := fmt.Sprintf("Message: %#v\n", &m.Header) - if len(m.Questions) > 0 { - s += "-- Questions\n" - for _, q := range m.Questions { - s += fmt.Sprintf("%#v\n", q) - } - } - if len(m.Answers) > 0 { - s += "-- Answers\n" - for _, a := range m.Answers { - s += fmt.Sprintf("%#v\n", a) - } - } - if len(m.Authorities) > 0 { - s += "-- Authorities\n" - for _, ns := range m.Authorities { - s += fmt.Sprintf("%#v\n", ns) - } - } - if len(m.Additionals) > 0 { - s += "-- Additionals\n" - for _, e := range m.Additionals { - s += fmt.Sprintf("%#v\n", e) - } - } - return s -} - -func TestNameString(t *testing.T) { - want := "foo" - name := MustNewName(want) - if got := fmt.Sprint(name); got != want { - t.Errorf("got fmt.Sprint(%#v) = %s, want = %s", name, got, want) - } -} - -func TestQuestionPackUnpack(t *testing.T) { - want := Question{ - Name: MustNewName("."), - Type: TypeA, - Class: ClassINET, - } - buf, err := want.pack(make([]byte, 1, 50), map[string]int{}, 1) - if err != nil { - t.Fatal("Question.pack() =", err) - } - var p Parser - p.msg = buf - p.header.questions = 1 - p.section = sectionQuestions - p.off = 1 - got, err := p.Question() - if err != nil { - t.Fatalf("Parser{%q}.Question() = %v", string(buf[1:]), err) - } - if p.off != len(buf) { - t.Errorf("unpacked different amount than packed: got = %d, want = %d", p.off, len(buf)) - } - if !reflect.DeepEqual(got, want) { - t.Errorf("got from Parser.Question() = %+v, want = %+v", got, want) - } -} - -func TestName(t *testing.T) { - tests := []string{ - "", - ".", - "google..com", - "google.com", - "google..com.", - "google.com.", - ".google.com.", - "www..google.com.", - "www.google.com.", - } - - for _, test := range tests { - n, err := NewName(test) - if err != nil { - t.Errorf("NewName(%q) = %v", test, err) - continue - } - if ns := n.String(); ns != test { - t.Errorf("got %#v.String() = %q, want = %q", n, ns, test) - continue - } - } -} - -func TestNamePackUnpack(t *testing.T) { - tests := []struct { - in string - want string - err error - }{ - {"", "", errNonCanonicalName}, - {".", ".", nil}, - {"google..com", "", errNonCanonicalName}, - {"google.com", "", errNonCanonicalName}, - {"google..com.", "", errZeroSegLen}, - {"google.com.", "google.com.", nil}, - {".google.com.", "", errZeroSegLen}, - {"www..google.com.", "", errZeroSegLen}, - {"www.google.com.", "www.google.com.", nil}, - } - - for _, test := range tests { - in := MustNewName(test.in) - want := MustNewName(test.want) - buf, err := in.pack(make([]byte, 0, 30), map[string]int{}, 0) - if err != test.err { - t.Errorf("got %q.pack() = %v, want = %v", test.in, err, test.err) - continue - } - if test.err != nil { - continue - } - var got Name - n, err := got.unpack(buf, 0) - if err != nil { - t.Errorf("%q.unpack() = %v", test.in, err) - continue - } - if n != len(buf) { - t.Errorf( - "unpacked different amount than packed for %q: got = %d, want = %d", - test.in, - n, - len(buf), - ) - } - if got != want { - t.Errorf("unpacking packing of %q: got = %#v, want = %#v", test.in, got, want) - } - } -} - -func TestIncompressibleName(t *testing.T) { - name := MustNewName("example.com.") - compression := map[string]int{} - buf, err := name.pack(make([]byte, 0, 100), compression, 0) - if err != nil { - t.Fatal("first Name.pack() =", err) - } - buf, err = name.pack(buf, compression, 0) - if err != nil { - t.Fatal("second Name.pack() =", err) - } - var n1 Name - off, err := n1.unpackCompressed(buf, 0, false /* allowCompression */) - if err != nil { - t.Fatal("unpacking incompressible name without pointers failed:", err) - } - var n2 Name - if _, err := n2.unpackCompressed(buf, off, false /* allowCompression */); err != errCompressedSRV { - t.Errorf("unpacking compressed incompressible name with pointers: got %v, want = %v", err, errCompressedSRV) - } -} - -func checkErrorPrefix(err error, prefix string) bool { - e, ok := err.(*nestedError) - return ok && e.s == prefix -} - -func TestHeaderUnpackError(t *testing.T) { - wants := []string{ - "id", - "bits", - "questions", - "answers", - "authorities", - "additionals", - } - var buf []byte - var h header - for _, want := range wants { - n, err := h.unpack(buf, 0) - if n != 0 || !checkErrorPrefix(err, want) { - t.Errorf("got header.unpack([%d]byte, 0) = %d, %v, want = 0, %s", len(buf), n, err, want) - } - buf = append(buf, 0, 0) - } -} - -func TestParserStart(t *testing.T) { - const want = "unpacking header" - var p Parser - for i := 0; i <= 1; i++ { - _, err := p.Start([]byte{}) - if !checkErrorPrefix(err, want) { - t.Errorf("got Parser.Start(nil) = _, %v, want = _, %s", err, want) - } - } -} - -func TestResourceNotStarted(t *testing.T) { - tests := []struct { - name string - fn func(*Parser) error - }{ - {"CNAMEResource", func(p *Parser) error { _, err := p.CNAMEResource(); return err }}, - {"MXResource", func(p *Parser) error { _, err := p.MXResource(); return err }}, - {"NSResource", func(p *Parser) error { _, err := p.NSResource(); return err }}, - {"PTRResource", func(p *Parser) error { _, err := p.PTRResource(); return err }}, - {"SOAResource", func(p *Parser) error { _, err := p.SOAResource(); return err }}, - {"TXTResource", func(p *Parser) error { _, err := p.TXTResource(); return err }}, - {"SRVResource", func(p *Parser) error { _, err := p.SRVResource(); return err }}, - {"AResource", func(p *Parser) error { _, err := p.AResource(); return err }}, - {"AAAAResource", func(p *Parser) error { _, err := p.AAAAResource(); return err }}, - } - - for _, test := range tests { - if err := test.fn(&Parser{}); err != ErrNotStarted { - t.Errorf("got Parser.%s() = _ , %v, want = _, %v", test.name, err, ErrNotStarted) - } - } -} - -func TestDNSPackUnpack(t *testing.T) { - wants := []Message{ - { - Questions: []Question{ - { - Name: MustNewName("."), - Type: TypeAAAA, - Class: ClassINET, - }, - }, - Answers: []Resource{}, - Authorities: []Resource{}, - Additionals: []Resource{}, - }, - largeTestMsg(), - } - for i, want := range wants { - b, err := want.Pack() - if err != nil { - t.Fatalf("%d: Message.Pack() = %v", i, err) - } - var got Message - err = got.Unpack(b) - if err != nil { - t.Fatalf("%d: Message.Unapck() = %v", i, err) - } - if !reflect.DeepEqual(got, want) { - t.Errorf("%d: Message.Pack/Unpack() roundtrip: got = %+v, want = %+v", i, &got, &want) - } - } -} - -func TestDNSAppendPackUnpack(t *testing.T) { - wants := []Message{ - { - Questions: []Question{ - { - Name: MustNewName("."), - Type: TypeAAAA, - Class: ClassINET, - }, - }, - Answers: []Resource{}, - Authorities: []Resource{}, - Additionals: []Resource{}, - }, - largeTestMsg(), - } - for i, want := range wants { - b := make([]byte, 2, 514) - b, err := want.AppendPack(b) - if err != nil { - t.Fatalf("%d: Message.AppendPack() = %v", i, err) - } - b = b[2:] - var got Message - err = got.Unpack(b) - if err != nil { - t.Fatalf("%d: Message.Unapck() = %v", i, err) - } - if !reflect.DeepEqual(got, want) { - t.Errorf("%d: Message.AppendPack/Unpack() roundtrip: got = %+v, want = %+v", i, &got, &want) - } - } -} - -func TestSkipAll(t *testing.T) { - msg := largeTestMsg() - buf, err := msg.Pack() - if err != nil { - t.Fatal("Message.Pack() =", err) - } - var p Parser - if _, err := p.Start(buf); err != nil { - t.Fatal("Parser.Start(non-nil) =", err) - } - - tests := []struct { - name string - f func() error - }{ - {"SkipAllQuestions", p.SkipAllQuestions}, - {"SkipAllAnswers", p.SkipAllAnswers}, - {"SkipAllAuthorities", p.SkipAllAuthorities}, - {"SkipAllAdditionals", p.SkipAllAdditionals}, - } - for _, test := range tests { - for i := 1; i <= 3; i++ { - if err := test.f(); err != nil { - t.Errorf("%d: Parser.%s() = %v", i, test.name, err) - } - } - } -} - -func TestSkipEach(t *testing.T) { - msg := smallTestMsg() - - buf, err := msg.Pack() - if err != nil { - t.Fatal("Message.Pack() =", err) - } - var p Parser - if _, err := p.Start(buf); err != nil { - t.Fatal("Parser.Start(non-nil) =", err) - } - - tests := []struct { - name string - f func() error - }{ - {"SkipQuestion", p.SkipQuestion}, - {"SkipAnswer", p.SkipAnswer}, - {"SkipAuthority", p.SkipAuthority}, - {"SkipAdditional", p.SkipAdditional}, - } - for _, test := range tests { - if err := test.f(); err != nil { - t.Errorf("first Parser.%s() = %v, want = nil", test.name, err) - } - if err := test.f(); err != ErrSectionDone { - t.Errorf("second Parser.%s() = %v, want = %v", test.name, err, ErrSectionDone) - } - } -} - -func TestSkipAfterRead(t *testing.T) { - msg := smallTestMsg() - - buf, err := msg.Pack() - if err != nil { - t.Fatal("Message.Pack() =", err) - } - var p Parser - if _, err := p.Start(buf); err != nil { - t.Fatal("Parser.Srart(non-nil) =", err) - } - - tests := []struct { - name string - skip func() error - read func() error - }{ - {"Question", p.SkipQuestion, func() error { _, err := p.Question(); return err }}, - {"Answer", p.SkipAnswer, func() error { _, err := p.Answer(); return err }}, - {"Authority", p.SkipAuthority, func() error { _, err := p.Authority(); return err }}, - {"Additional", p.SkipAdditional, func() error { _, err := p.Additional(); return err }}, - } - for _, test := range tests { - if err := test.read(); err != nil { - t.Errorf("got Parser.%s() = _, %v, want = _, nil", test.name, err) - } - if err := test.skip(); err != ErrSectionDone { - t.Errorf("got Parser.Skip%s() = %v, want = %v", test.name, err, ErrSectionDone) - } - } -} - -func TestSkipNotStarted(t *testing.T) { - var p Parser - - tests := []struct { - name string - f func() error - }{ - {"SkipAllQuestions", p.SkipAllQuestions}, - {"SkipAllAnswers", p.SkipAllAnswers}, - {"SkipAllAuthorities", p.SkipAllAuthorities}, - {"SkipAllAdditionals", p.SkipAllAdditionals}, - } - for _, test := range tests { - if err := test.f(); err != ErrNotStarted { - t.Errorf("got Parser.%s() = %v, want = %v", test.name, err, ErrNotStarted) - } - } -} - -func TestTooManyRecords(t *testing.T) { - const recs = int(^uint16(0)) + 1 - tests := []struct { - name string - msg Message - want error - }{ - { - "Questions", - Message{ - Questions: make([]Question, recs), - }, - errTooManyQuestions, - }, - { - "Answers", - Message{ - Answers: make([]Resource, recs), - }, - errTooManyAnswers, - }, - { - "Authorities", - Message{ - Authorities: make([]Resource, recs), - }, - errTooManyAuthorities, - }, - { - "Additionals", - Message{ - Additionals: make([]Resource, recs), - }, - errTooManyAdditionals, - }, - } - - for _, test := range tests { - if _, got := test.msg.Pack(); got != test.want { - t.Errorf("got Message.Pack() for %d %s = %v, want = %v", recs, test.name, got, test.want) - } - } -} - -func TestVeryLongTxt(t *testing.T) { - want := Resource{ - ResourceHeader{ - Name: MustNewName("foo.bar.example.com."), - Type: TypeTXT, - Class: ClassINET, - }, - &TXTResource{[]string{ - "", - "", - "foo bar", - "", - "www.example.com", - "www.example.com.", - strings.Repeat(".", 255), - }}, - } - buf, err := want.pack(make([]byte, 0, 8000), map[string]int{}, 0) - if err != nil { - t.Fatal("Resource.pack() =", err) - } - var got Resource - off, err := got.Header.unpack(buf, 0) - if err != nil { - t.Fatal("ResourceHeader.unpack() =", err) - } - body, n, err := unpackResourceBody(buf, off, got.Header) - if err != nil { - t.Fatal("unpackResourceBody() =", err) - } - got.Body = body - if n != len(buf) { - t.Errorf("unpacked different amount than packed: got = %d, want = %d", n, len(buf)) - } - if !reflect.DeepEqual(got, want) { - t.Errorf("Resource.pack/unpack() roundtrip: got = %#v, want = %#v", got, want) - } -} - -func TestTooLongTxt(t *testing.T) { - rb := TXTResource{[]string{strings.Repeat(".", 256)}} - if _, err := rb.pack(make([]byte, 0, 8000), map[string]int{}, 0); err != errStringTooLong { - t.Errorf("packing TXTResource with 256 character string: got err = %v, want = %v", err, errStringTooLong) - } -} - -func TestStartAppends(t *testing.T) { - buf := make([]byte, 2, 514) - wantBuf := []byte{4, 44} - copy(buf, wantBuf) - - b := NewBuilder(buf, Header{}) - b.EnableCompression() - - buf, err := b.Finish() - if err != nil { - t.Fatal("Builder.Finish() =", err) - } - if got, want := len(buf), headerLen+2; got != want { - t.Errorf("got len(buf) = %d, want = %d", got, want) - } - if string(buf[:2]) != string(wantBuf) { - t.Errorf("original data not preserved, got = %#v, want = %#v", buf[:2], wantBuf) - } -} - -func TestStartError(t *testing.T) { - tests := []struct { - name string - fn func(*Builder) error - }{ - {"Questions", func(b *Builder) error { return b.StartQuestions() }}, - {"Answers", func(b *Builder) error { return b.StartAnswers() }}, - {"Authorities", func(b *Builder) error { return b.StartAuthorities() }}, - {"Additionals", func(b *Builder) error { return b.StartAdditionals() }}, - } - - envs := []struct { - name string - fn func() *Builder - want error - }{ - {"sectionNotStarted", func() *Builder { return &Builder{section: sectionNotStarted} }, ErrNotStarted}, - {"sectionDone", func() *Builder { return &Builder{section: sectionDone} }, ErrSectionDone}, - } - - for _, env := range envs { - for _, test := range tests { - if got := test.fn(env.fn()); got != env.want { - t.Errorf("got Builder{%s}.Start%s() = %v, want = %v", env.name, test.name, got, env.want) - } - } - } -} - -func TestBuilderResourceError(t *testing.T) { - tests := []struct { - name string - fn func(*Builder) error - }{ - {"CNAMEResource", func(b *Builder) error { return b.CNAMEResource(ResourceHeader{}, CNAMEResource{}) }}, - {"MXResource", func(b *Builder) error { return b.MXResource(ResourceHeader{}, MXResource{}) }}, - {"NSResource", func(b *Builder) error { return b.NSResource(ResourceHeader{}, NSResource{}) }}, - {"PTRResource", func(b *Builder) error { return b.PTRResource(ResourceHeader{}, PTRResource{}) }}, - {"SOAResource", func(b *Builder) error { return b.SOAResource(ResourceHeader{}, SOAResource{}) }}, - {"TXTResource", func(b *Builder) error { return b.TXTResource(ResourceHeader{}, TXTResource{}) }}, - {"SRVResource", func(b *Builder) error { return b.SRVResource(ResourceHeader{}, SRVResource{}) }}, - {"AResource", func(b *Builder) error { return b.AResource(ResourceHeader{}, AResource{}) }}, - {"AAAAResource", func(b *Builder) error { return b.AAAAResource(ResourceHeader{}, AAAAResource{}) }}, - {"OPTResource", func(b *Builder) error { return b.OPTResource(ResourceHeader{}, OPTResource{}) }}, - } - - envs := []struct { - name string - fn func() *Builder - want error - }{ - {"sectionNotStarted", func() *Builder { return &Builder{section: sectionNotStarted} }, ErrNotStarted}, - {"sectionHeader", func() *Builder { return &Builder{section: sectionHeader} }, ErrNotStarted}, - {"sectionQuestions", func() *Builder { return &Builder{section: sectionQuestions} }, ErrNotStarted}, - {"sectionDone", func() *Builder { return &Builder{section: sectionDone} }, ErrSectionDone}, - } - - for _, env := range envs { - for _, test := range tests { - if got := test.fn(env.fn()); got != env.want { - t.Errorf("got Builder{%s}.%s() = %v, want = %v", env.name, test.name, got, env.want) - } - } - } -} - -func TestFinishError(t *testing.T) { - var b Builder - want := ErrNotStarted - if _, got := b.Finish(); got != want { - t.Errorf("got Builder.Finish() = %v, want = %v", got, want) - } -} - -func TestBuilder(t *testing.T) { - msg := largeTestMsg() - want, err := msg.Pack() - if err != nil { - t.Fatal("Message.Pack() =", err) - } - - b := NewBuilder(nil, msg.Header) - b.EnableCompression() - - if err := b.StartQuestions(); err != nil { - t.Fatal("Builder.StartQuestions() =", err) - } - for _, q := range msg.Questions { - if err := b.Question(q); err != nil { - t.Fatalf("Builder.Question(%#v) = %v", q, err) - } - } - - if err := b.StartAnswers(); err != nil { - t.Fatal("Builder.StartAnswers() =", err) - } - for _, a := range msg.Answers { - switch a.Header.Type { - case TypeA: - if err := b.AResource(a.Header, *a.Body.(*AResource)); err != nil { - t.Fatalf("Builder.AResource(%#v) = %v", a, err) - } - case TypeNS: - if err := b.NSResource(a.Header, *a.Body.(*NSResource)); err != nil { - t.Fatalf("Builder.NSResource(%#v) = %v", a, err) - } - case TypeCNAME: - if err := b.CNAMEResource(a.Header, *a.Body.(*CNAMEResource)); err != nil { - t.Fatalf("Builder.CNAMEResource(%#v) = %v", a, err) - } - case TypeSOA: - if err := b.SOAResource(a.Header, *a.Body.(*SOAResource)); err != nil { - t.Fatalf("Builder.SOAResource(%#v) = %v", a, err) - } - case TypePTR: - if err := b.PTRResource(a.Header, *a.Body.(*PTRResource)); err != nil { - t.Fatalf("Builder.PTRResource(%#v) = %v", a, err) - } - case TypeMX: - if err := b.MXResource(a.Header, *a.Body.(*MXResource)); err != nil { - t.Fatalf("Builder.MXResource(%#v) = %v", a, err) - } - case TypeTXT: - if err := b.TXTResource(a.Header, *a.Body.(*TXTResource)); err != nil { - t.Fatalf("Builder.TXTResource(%#v) = %v", a, err) - } - case TypeAAAA: - if err := b.AAAAResource(a.Header, *a.Body.(*AAAAResource)); err != nil { - t.Fatalf("Builder.AAAAResource(%#v) = %v", a, err) - } - case TypeSRV: - if err := b.SRVResource(a.Header, *a.Body.(*SRVResource)); err != nil { - t.Fatalf("Builder.SRVResource(%#v) = %v", a, err) - } - } - } - - if err := b.StartAuthorities(); err != nil { - t.Fatal("Builder.StartAuthorities() =", err) - } - for _, a := range msg.Authorities { - if err := b.NSResource(a.Header, *a.Body.(*NSResource)); err != nil { - t.Fatalf("Builder.NSResource(%#v) = %v", a, err) - } - } - - if err := b.StartAdditionals(); err != nil { - t.Fatal("Builder.StartAdditionals() =", err) - } - for _, a := range msg.Additionals { - switch a.Body.(type) { - case *TXTResource: - if err := b.TXTResource(a.Header, *a.Body.(*TXTResource)); err != nil { - t.Fatalf("Builder.TXTResource(%#v) = %v", a, err) - } - case *OPTResource: - if err := b.OPTResource(a.Header, *a.Body.(*OPTResource)); err != nil { - t.Fatalf("Builder.OPTResource(%#v) = %v", a, err) - } - } - } - - got, err := b.Finish() - if err != nil { - t.Fatal("Builder.Finish() =", err) - } - if !bytes.Equal(got, want) { - t.Fatalf("got from Builder.Finish() = %#v\nwant = %#v", got, want) - } -} - -func TestResourcePack(t *testing.T) { - for _, tt := range []struct { - m Message - err error - }{ - { - Message{ - Questions: []Question{ - { - Name: MustNewName("."), - Type: TypeAAAA, - Class: ClassINET, - }, - }, - Answers: []Resource{{ResourceHeader{}, nil}}, - }, - &nestedError{"packing Answer", errNilResouceBody}, - }, - { - Message{ - Questions: []Question{ - { - Name: MustNewName("."), - Type: TypeAAAA, - Class: ClassINET, - }, - }, - Authorities: []Resource{{ResourceHeader{}, (*NSResource)(nil)}}, - }, - &nestedError{"packing Authority", - &nestedError{"ResourceHeader", - &nestedError{"Name", errNonCanonicalName}, - }, - }, - }, - { - Message{ - Questions: []Question{ - { - Name: MustNewName("."), - Type: TypeA, - Class: ClassINET, - }, - }, - Additionals: []Resource{{ResourceHeader{}, nil}}, - }, - &nestedError{"packing Additional", errNilResouceBody}, - }, - } { - _, err := tt.m.Pack() - if !reflect.DeepEqual(err, tt.err) { - t.Errorf("got Message{%v}.Pack() = %v, want %v", tt.m, err, tt.err) - } - } -} - -func TestResourcePackLength(t *testing.T) { - r := Resource{ - ResourceHeader{ - Name: MustNewName("."), - Type: TypeA, - Class: ClassINET, - }, - &AResource{[4]byte{127, 0, 0, 2}}, - } - - hb, _, err := r.Header.pack(nil, nil, 0) - if err != nil { - t.Fatal("ResourceHeader.pack() =", err) - } - buf := make([]byte, 0, len(hb)) - buf, err = r.pack(buf, nil, 0) - if err != nil { - t.Fatal("Resource.pack() =", err) - } - - var hdr ResourceHeader - if _, err := hdr.unpack(buf, 0); err != nil { - t.Fatal("ResourceHeader.unpack() =", err) - } - - if got, want := int(hdr.Length), len(buf)-len(hb); got != want { - t.Errorf("got hdr.Length = %d, want = %d", got, want) - } -} - -func TestOptionPackUnpack(t *testing.T) { - for _, tt := range []struct { - name string - w []byte // wire format of m.Additionals - m Message - dnssecOK bool - extRCode RCode - }{ - { - name: "without EDNS(0) options", - w: []byte{ - 0x00, 0x00, 0x29, 0x10, 0x00, 0xfe, 0x00, 0x80, - 0x00, 0x00, 0x00, - }, - m: Message{ - Header: Header{RCode: RCodeFormatError}, - Questions: []Question{ - { - Name: MustNewName("."), - Type: TypeA, - Class: ClassINET, - }, - }, - Additionals: []Resource{ - { - mustEDNS0ResourceHeader(4096, 0xfe0|RCodeFormatError, true), - &OPTResource{}, - }, - }, - }, - dnssecOK: true, - extRCode: 0xfe0 | RCodeFormatError, - }, - { - name: "with EDNS(0) options", - w: []byte{ - 0x00, 0x00, 0x29, 0x10, 0x00, 0xff, 0x00, 0x00, - 0x00, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0x02, 0x00, - 0x00, 0x00, 0x0b, 0x00, 0x02, 0x12, 0x34, - }, - m: Message{ - Header: Header{RCode: RCodeServerFailure}, - Questions: []Question{ - { - Name: MustNewName("."), - Type: TypeAAAA, - Class: ClassINET, - }, - }, - Additionals: []Resource{ - { - mustEDNS0ResourceHeader(4096, 0xff0|RCodeServerFailure, false), - &OPTResource{ - Options: []Option{ - { - Code: 12, // see RFC 7828 - Data: []byte{0x00, 0x00}, - }, - { - Code: 11, // see RFC 7830 - Data: []byte{0x12, 0x34}, - }, - }, - }, - }, - }, - }, - dnssecOK: false, - extRCode: 0xff0 | RCodeServerFailure, - }, - { - // Containing multiple OPT resources in a - // message is invalid, but it's necessary for - // protocol conformance testing. - name: "with multiple OPT resources", - w: []byte{ - 0x00, 0x00, 0x29, 0x10, 0x00, 0xff, 0x00, 0x00, - 0x00, 0x00, 0x06, 0x00, 0x0b, 0x00, 0x02, 0x12, - 0x34, 0x00, 0x00, 0x29, 0x10, 0x00, 0xff, 0x00, - 0x00, 0x00, 0x00, 0x06, 0x00, 0x0c, 0x00, 0x02, - 0x00, 0x00, - }, - m: Message{ - Header: Header{RCode: RCodeNameError}, - Questions: []Question{ - { - Name: MustNewName("."), - Type: TypeAAAA, - Class: ClassINET, - }, - }, - Additionals: []Resource{ - { - mustEDNS0ResourceHeader(4096, 0xff0|RCodeNameError, false), - &OPTResource{ - Options: []Option{ - { - Code: 11, // see RFC 7830 - Data: []byte{0x12, 0x34}, - }, - }, - }, - }, - { - mustEDNS0ResourceHeader(4096, 0xff0|RCodeNameError, false), - &OPTResource{ - Options: []Option{ - { - Code: 12, // see RFC 7828 - Data: []byte{0x00, 0x00}, - }, - }, - }, - }, - }, - }, - }, - } { - w, err := tt.m.Pack() - if err != nil { - t.Errorf("Message.Pack() for %s = %v", tt.name, err) - continue - } - if !bytes.Equal(w[len(w)-len(tt.w):], tt.w) { - t.Errorf("got Message.Pack() for %s = %#v, want %#v", tt.name, w[len(w)-len(tt.w):], tt.w) - continue - } - var m Message - if err := m.Unpack(w); err != nil { - t.Errorf("Message.Unpack() for %s = %v", tt.name, err) - continue - } - if !reflect.DeepEqual(m.Additionals, tt.m.Additionals) { - t.Errorf("got Message.Pack/Unpack() roundtrip for %s = %+v, want %+v", tt.name, m, tt.m) - continue - } - } -} - -// TestGoString tests that Message.GoString produces Go code that compiles to -// reproduce the Message. -// -// This test was produced as follows: -// 1. Run (*Message).GoString on largeTestMsg(). -// 2. Remove "dnsmessage." from the output. -// 3. Paste the result in the test to store it in msg. -// 4. Also put the original output in the test to store in want. -func TestGoString(t *testing.T) { - msg := Message{Header: Header{ID: 0, Response: true, OpCode: 0, Authoritative: true, Truncated: false, RecursionDesired: false, RecursionAvailable: false, RCode: RCodeSuccess}, Questions: []Question{{Name: MustNewName("foo.bar.example.com."), Type: TypeA, Class: ClassINET}}, Answers: []Resource{{Header: ResourceHeader{Name: MustNewName("foo.bar.example.com."), Type: TypeA, Class: ClassINET, TTL: 0, Length: 0}, Body: &AResource{A: [4]byte{127, 0, 0, 1}}}, {Header: ResourceHeader{Name: MustNewName("foo.bar.example.com."), Type: TypeA, Class: ClassINET, TTL: 0, Length: 0}, Body: &AResource{A: [4]byte{127, 0, 0, 2}}}, {Header: ResourceHeader{Name: MustNewName("foo.bar.example.com."), Type: TypeAAAA, Class: ClassINET, TTL: 0, Length: 0}, Body: &AAAAResource{AAAA: [16]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}}}, {Header: ResourceHeader{Name: MustNewName("foo.bar.example.com."), Type: TypeCNAME, Class: ClassINET, TTL: 0, Length: 0}, Body: &CNAMEResource{CNAME: MustNewName("alias.example.com.")}}, {Header: ResourceHeader{Name: MustNewName("foo.bar.example.com."), Type: TypeSOA, Class: ClassINET, TTL: 0, Length: 0}, Body: &SOAResource{NS: MustNewName("ns1.example.com."), MBox: MustNewName("mb.example.com."), Serial: 1, Refresh: 2, Retry: 3, Expire: 4, MinTTL: 5}}, {Header: ResourceHeader{Name: MustNewName("foo.bar.example.com."), Type: TypePTR, Class: ClassINET, TTL: 0, Length: 0}, Body: &PTRResource{PTR: MustNewName("ptr.example.com.")}}, {Header: ResourceHeader{Name: MustNewName("foo.bar.example.com."), Type: TypeMX, Class: ClassINET, TTL: 0, Length: 0}, Body: &MXResource{Pref: 7, MX: MustNewName("mx.example.com.")}}, {Header: ResourceHeader{Name: MustNewName("foo.bar.example.com."), Type: TypeSRV, Class: ClassINET, TTL: 0, Length: 0}, Body: &SRVResource{Priority: 8, Weight: 9, Port: 11, Target: MustNewName("srv.example.com.")}}}, Authorities: []Resource{{Header: ResourceHeader{Name: MustNewName("foo.bar.example.com."), Type: TypeNS, Class: ClassINET, TTL: 0, Length: 0}, Body: &NSResource{NS: MustNewName("ns1.example.com.")}}, {Header: ResourceHeader{Name: MustNewName("foo.bar.example.com."), Type: TypeNS, Class: ClassINET, TTL: 0, Length: 0}, Body: &NSResource{NS: MustNewName("ns2.example.com.")}}}, Additionals: []Resource{{Header: ResourceHeader{Name: MustNewName("foo.bar.example.com."), Type: TypeTXT, Class: ClassINET, TTL: 0, Length: 0}, Body: &TXTResource{TXT: []string{"So Long\x2c and Thanks for All the Fish"}}}, {Header: ResourceHeader{Name: MustNewName("foo.bar.example.com."), Type: TypeTXT, Class: ClassINET, TTL: 0, Length: 0}, Body: &TXTResource{TXT: []string{"Hamster Huey and the Gooey Kablooie"}}}, {Header: ResourceHeader{Name: MustNewName("."), Type: TypeOPT, Class: 4096, TTL: 4261412864, Length: 0}, Body: &OPTResource{Options: []Option{{Code: 10, Data: []byte{1, 35, 69, 103, 137, 171, 205, 239}}}}}}} - if !reflect.DeepEqual(msg, largeTestMsg()) { - t.Error("Message.GoString lost information or largeTestMsg changed: msg != largeTestMsg()") - } - got := msg.GoString() - want := `dnsmessage.Message{Header: dnsmessage.Header{ID: 0, Response: true, OpCode: 0, Authoritative: true, Truncated: false, RecursionDesired: false, RecursionAvailable: false, RCode: dnsmessage.RCodeSuccess}, Questions: []dnsmessage.Question{dnsmessage.Question{Name: dnsmessage.MustNewName("foo.bar.example.com."), Type: dnsmessage.TypeA, Class: dnsmessage.ClassINET}}, Answers: []dnsmessage.Resource{dnsmessage.Resource{Header: dnsmessage.ResourceHeader{Name: dnsmessage.MustNewName("foo.bar.example.com."), Type: dnsmessage.TypeA, Class: dnsmessage.ClassINET, TTL: 0, Length: 0}, Body: &dnsmessage.AResource{A: [4]byte{127, 0, 0, 1}}}, dnsmessage.Resource{Header: dnsmessage.ResourceHeader{Name: dnsmessage.MustNewName("foo.bar.example.com."), Type: dnsmessage.TypeA, Class: dnsmessage.ClassINET, TTL: 0, Length: 0}, Body: &dnsmessage.AResource{A: [4]byte{127, 0, 0, 2}}}, dnsmessage.Resource{Header: dnsmessage.ResourceHeader{Name: dnsmessage.MustNewName("foo.bar.example.com."), Type: dnsmessage.TypeAAAA, Class: dnsmessage.ClassINET, TTL: 0, Length: 0}, Body: &dnsmessage.AAAAResource{AAAA: [16]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}}}, dnsmessage.Resource{Header: dnsmessage.ResourceHeader{Name: dnsmessage.MustNewName("foo.bar.example.com."), Type: dnsmessage.TypeCNAME, Class: dnsmessage.ClassINET, TTL: 0, Length: 0}, Body: &dnsmessage.CNAMEResource{CNAME: dnsmessage.MustNewName("alias.example.com.")}}, dnsmessage.Resource{Header: dnsmessage.ResourceHeader{Name: dnsmessage.MustNewName("foo.bar.example.com."), Type: dnsmessage.TypeSOA, Class: dnsmessage.ClassINET, TTL: 0, Length: 0}, Body: &dnsmessage.SOAResource{NS: dnsmessage.MustNewName("ns1.example.com."), MBox: dnsmessage.MustNewName("mb.example.com."), Serial: 1, Refresh: 2, Retry: 3, Expire: 4, MinTTL: 5}}, dnsmessage.Resource{Header: dnsmessage.ResourceHeader{Name: dnsmessage.MustNewName("foo.bar.example.com."), Type: dnsmessage.TypePTR, Class: dnsmessage.ClassINET, TTL: 0, Length: 0}, Body: &dnsmessage.PTRResource{PTR: dnsmessage.MustNewName("ptr.example.com.")}}, dnsmessage.Resource{Header: dnsmessage.ResourceHeader{Name: dnsmessage.MustNewName("foo.bar.example.com."), Type: dnsmessage.TypeMX, Class: dnsmessage.ClassINET, TTL: 0, Length: 0}, Body: &dnsmessage.MXResource{Pref: 7, MX: dnsmessage.MustNewName("mx.example.com.")}}, dnsmessage.Resource{Header: dnsmessage.ResourceHeader{Name: dnsmessage.MustNewName("foo.bar.example.com."), Type: dnsmessage.TypeSRV, Class: dnsmessage.ClassINET, TTL: 0, Length: 0}, Body: &dnsmessage.SRVResource{Priority: 8, Weight: 9, Port: 11, Target: dnsmessage.MustNewName("srv.example.com.")}}}, Authorities: []dnsmessage.Resource{dnsmessage.Resource{Header: dnsmessage.ResourceHeader{Name: dnsmessage.MustNewName("foo.bar.example.com."), Type: dnsmessage.TypeNS, Class: dnsmessage.ClassINET, TTL: 0, Length: 0}, Body: &dnsmessage.NSResource{NS: dnsmessage.MustNewName("ns1.example.com.")}}, dnsmessage.Resource{Header: dnsmessage.ResourceHeader{Name: dnsmessage.MustNewName("foo.bar.example.com."), Type: dnsmessage.TypeNS, Class: dnsmessage.ClassINET, TTL: 0, Length: 0}, Body: &dnsmessage.NSResource{NS: dnsmessage.MustNewName("ns2.example.com.")}}}, Additionals: []dnsmessage.Resource{dnsmessage.Resource{Header: dnsmessage.ResourceHeader{Name: dnsmessage.MustNewName("foo.bar.example.com."), Type: dnsmessage.TypeTXT, Class: dnsmessage.ClassINET, TTL: 0, Length: 0}, Body: &dnsmessage.TXTResource{TXT: []string{"So Long\x2c and Thanks for All the Fish"}}}, dnsmessage.Resource{Header: dnsmessage.ResourceHeader{Name: dnsmessage.MustNewName("foo.bar.example.com."), Type: dnsmessage.TypeTXT, Class: dnsmessage.ClassINET, TTL: 0, Length: 0}, Body: &dnsmessage.TXTResource{TXT: []string{"Hamster Huey and the Gooey Kablooie"}}}, dnsmessage.Resource{Header: dnsmessage.ResourceHeader{Name: dnsmessage.MustNewName("."), Type: dnsmessage.TypeOPT, Class: 4096, TTL: 4261412864, Length: 0}, Body: &dnsmessage.OPTResource{Options: []dnsmessage.Option{dnsmessage.Option{Code: 10, Data: []byte{1, 35, 69, 103, 137, 171, 205, 239}}}}}}}` - if got != want { - t.Errorf("got msg1.GoString() = %s\nwant = %s", got, want) - } -} - -func benchmarkParsingSetup() ([]byte, error) { - name := MustNewName("foo.bar.example.com.") - msg := Message{ - Header: Header{Response: true, Authoritative: true}, - Questions: []Question{ - { - Name: name, - Type: TypeA, - Class: ClassINET, - }, - }, - Answers: []Resource{ - { - ResourceHeader{ - Name: name, - Class: ClassINET, - }, - &AResource{[4]byte{}}, - }, - { - ResourceHeader{ - Name: name, - Class: ClassINET, - }, - &AAAAResource{[16]byte{}}, - }, - { - ResourceHeader{ - Name: name, - Class: ClassINET, - }, - &CNAMEResource{name}, - }, - { - ResourceHeader{ - Name: name, - Class: ClassINET, - }, - &NSResource{name}, - }, - }, - } - - buf, err := msg.Pack() - if err != nil { - return nil, fmt.Errorf("Message.Pack() = %v", err) - } - return buf, nil -} - -func benchmarkParsing(tb testing.TB, buf []byte) { - var p Parser - if _, err := p.Start(buf); err != nil { - tb.Fatal("Parser.Start(non-nil) =", err) - } - - for { - _, err := p.Question() - if err == ErrSectionDone { - break - } - if err != nil { - tb.Fatal("Parser.Question() =", err) - } - } - - for { - h, err := p.AnswerHeader() - if err == ErrSectionDone { - break - } - if err != nil { - tb.Fatal("Parser.AnswerHeader() =", err) - } - - switch h.Type { - case TypeA: - if _, err := p.AResource(); err != nil { - tb.Fatal("Parser.AResource() =", err) - } - case TypeAAAA: - if _, err := p.AAAAResource(); err != nil { - tb.Fatal("Parser.AAAAResource() =", err) - } - case TypeCNAME: - if _, err := p.CNAMEResource(); err != nil { - tb.Fatal("Parser.CNAMEResource() =", err) - } - case TypeNS: - if _, err := p.NSResource(); err != nil { - tb.Fatal("Parser.NSResource() =", err) - } - case TypeOPT: - if _, err := p.OPTResource(); err != nil { - tb.Fatal("Parser.OPTResource() =", err) - } - default: - tb.Fatalf("got unknown type: %T", h) - } - } -} - -func BenchmarkParsing(b *testing.B) { - buf, err := benchmarkParsingSetup() - if err != nil { - b.Fatal(err) - } - - b.ReportAllocs() - for i := 0; i < b.N; i++ { - benchmarkParsing(b, buf) - } -} - -func TestParsingAllocs(t *testing.T) { - buf, err := benchmarkParsingSetup() - if err != nil { - t.Fatal(err) - } - - if allocs := testing.AllocsPerRun(100, func() { benchmarkParsing(t, buf) }); allocs > 0.5 { - t.Errorf("allocations during parsing: got = %f, want ~0", allocs) - } -} - -func benchmarkBuildingSetup() (Name, []byte) { - name := MustNewName("foo.bar.example.com.") - buf := make([]byte, 0, packStartingCap) - return name, buf -} - -func benchmarkBuilding(tb testing.TB, name Name, buf []byte) { - bld := NewBuilder(buf, Header{Response: true, Authoritative: true}) - - if err := bld.StartQuestions(); err != nil { - tb.Fatal("Builder.StartQuestions() =", err) - } - q := Question{ - Name: name, - Type: TypeA, - Class: ClassINET, - } - if err := bld.Question(q); err != nil { - tb.Fatalf("Builder.Question(%+v) = %v", q, err) - } - - hdr := ResourceHeader{ - Name: name, - Class: ClassINET, - } - if err := bld.StartAnswers(); err != nil { - tb.Fatal("Builder.StartQuestions() =", err) - } - - ar := AResource{[4]byte{}} - if err := bld.AResource(hdr, ar); err != nil { - tb.Fatalf("Builder.AResource(%+v, %+v) = %v", hdr, ar, err) - } - - aaar := AAAAResource{[16]byte{}} - if err := bld.AAAAResource(hdr, aaar); err != nil { - tb.Fatalf("Builder.AAAAResource(%+v, %+v) = %v", hdr, aaar, err) - } - - cnr := CNAMEResource{name} - if err := bld.CNAMEResource(hdr, cnr); err != nil { - tb.Fatalf("Builder.CNAMEResource(%+v, %+v) = %v", hdr, cnr, err) - } - - nsr := NSResource{name} - if err := bld.NSResource(hdr, nsr); err != nil { - tb.Fatalf("Builder.NSResource(%+v, %+v) = %v", hdr, nsr, err) - } - - extrc := 0xfe0 | RCodeNotImplemented - if err := (&hdr).SetEDNS0(4096, extrc, true); err != nil { - tb.Fatalf("ResourceHeader.SetEDNS0(4096, %#x, true) = %v", extrc, err) - } - optr := OPTResource{} - if err := bld.OPTResource(hdr, optr); err != nil { - tb.Fatalf("Builder.OPTResource(%+v, %+v) = %v", hdr, optr, err) - } - - if _, err := bld.Finish(); err != nil { - tb.Fatal("Builder.Finish() =", err) - } -} - -func BenchmarkBuilding(b *testing.B) { - name, buf := benchmarkBuildingSetup() - b.ReportAllocs() - for i := 0; i < b.N; i++ { - benchmarkBuilding(b, name, buf) - } -} - -func TestBuildingAllocs(t *testing.T) { - name, buf := benchmarkBuildingSetup() - if allocs := testing.AllocsPerRun(100, func() { benchmarkBuilding(t, name, buf) }); allocs > 0.5 { - t.Errorf("allocations during building: got = %f, want ~0", allocs) - } -} - -func smallTestMsg() Message { - name := MustNewName("example.com.") - return Message{ - Header: Header{Response: true, Authoritative: true}, - Questions: []Question{ - { - Name: name, - Type: TypeA, - Class: ClassINET, - }, - }, - Answers: []Resource{ - { - ResourceHeader{ - Name: name, - Type: TypeA, - Class: ClassINET, - }, - &AResource{[4]byte{127, 0, 0, 1}}, - }, - }, - Authorities: []Resource{ - { - ResourceHeader{ - Name: name, - Type: TypeA, - Class: ClassINET, - }, - &AResource{[4]byte{127, 0, 0, 1}}, - }, - }, - Additionals: []Resource{ - { - ResourceHeader{ - Name: name, - Type: TypeA, - Class: ClassINET, - }, - &AResource{[4]byte{127, 0, 0, 1}}, - }, - }, - } -} - -func BenchmarkPack(b *testing.B) { - msg := largeTestMsg() - - b.ReportAllocs() - - for i := 0; i < b.N; i++ { - if _, err := msg.Pack(); err != nil { - b.Fatal("Message.Pack() =", err) - } - } -} - -func BenchmarkAppendPack(b *testing.B) { - msg := largeTestMsg() - buf := make([]byte, 0, packStartingCap) - - b.ReportAllocs() - - for i := 0; i < b.N; i++ { - if _, err := msg.AppendPack(buf[:0]); err != nil { - b.Fatal("Message.AppendPack() = ", err) - } - } -} - -func largeTestMsg() Message { - name := MustNewName("foo.bar.example.com.") - return Message{ - Header: Header{Response: true, Authoritative: true}, - Questions: []Question{ - { - Name: name, - Type: TypeA, - Class: ClassINET, - }, - }, - Answers: []Resource{ - { - ResourceHeader{ - Name: name, - Type: TypeA, - Class: ClassINET, - }, - &AResource{[4]byte{127, 0, 0, 1}}, - }, - { - ResourceHeader{ - Name: name, - Type: TypeA, - Class: ClassINET, - }, - &AResource{[4]byte{127, 0, 0, 2}}, - }, - { - ResourceHeader{ - Name: name, - Type: TypeAAAA, - Class: ClassINET, - }, - &AAAAResource{[16]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}}, - }, - { - ResourceHeader{ - Name: name, - Type: TypeCNAME, - Class: ClassINET, - }, - &CNAMEResource{MustNewName("alias.example.com.")}, - }, - { - ResourceHeader{ - Name: name, - Type: TypeSOA, - Class: ClassINET, - }, - &SOAResource{ - NS: MustNewName("ns1.example.com."), - MBox: MustNewName("mb.example.com."), - Serial: 1, - Refresh: 2, - Retry: 3, - Expire: 4, - MinTTL: 5, - }, - }, - { - ResourceHeader{ - Name: name, - Type: TypePTR, - Class: ClassINET, - }, - &PTRResource{MustNewName("ptr.example.com.")}, - }, - { - ResourceHeader{ - Name: name, - Type: TypeMX, - Class: ClassINET, - }, - &MXResource{ - 7, - MustNewName("mx.example.com."), - }, - }, - { - ResourceHeader{ - Name: name, - Type: TypeSRV, - Class: ClassINET, - }, - &SRVResource{ - 8, - 9, - 11, - MustNewName("srv.example.com."), - }, - }, - }, - Authorities: []Resource{ - { - ResourceHeader{ - Name: name, - Type: TypeNS, - Class: ClassINET, - }, - &NSResource{MustNewName("ns1.example.com.")}, - }, - { - ResourceHeader{ - Name: name, - Type: TypeNS, - Class: ClassINET, - }, - &NSResource{MustNewName("ns2.example.com.")}, - }, - }, - Additionals: []Resource{ - { - ResourceHeader{ - Name: name, - Type: TypeTXT, - Class: ClassINET, - }, - &TXTResource{[]string{"So Long, and Thanks for All the Fish"}}, - }, - { - ResourceHeader{ - Name: name, - Type: TypeTXT, - Class: ClassINET, - }, - &TXTResource{[]string{"Hamster Huey and the Gooey Kablooie"}}, - }, - { - mustEDNS0ResourceHeader(4096, 0xfe0|RCodeSuccess, false), - &OPTResource{ - Options: []Option{ - { - Code: 10, // see RFC 7873 - Data: []byte{0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef}, - }, - }, - }, - }, - }, - } -} -- cgit v1.2.3