| // 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" |
| "os" |
| "path/filepath" |
| "reflect" |
| "strings" |
| "testing" |
| ) |
| |
| const ( |
| // This type was selected randomly from the IANA-assigned private use |
| // range of RR TYPEs. |
| privateUseType Type = 65362 |
| ) |
| |
| 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]uint16{}, 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 TestNameWithDotsUnpack(t *testing.T) { |
| name := []byte{3, 'w', '.', 'w', 2, 'g', 'o', 3, 'd', 'e', 'v', 0} |
| var n Name |
| _, err := n.unpack(name, 0) |
| if err != errInvalidName { |
| t.Fatalf("expected %v, got %v", errInvalidName, err) |
| } |
| } |
| |
| func TestNamePackUnpack(t *testing.T) { |
| const suffix = ".go.dev." |
| var longDNSPrefix = strings.Repeat("verylongdomainlabel.", 20) |
| |
| tests := []struct { |
| in string |
| err error |
| }{ |
| {"", errNonCanonicalName}, |
| {".", nil}, |
| {"google..com", errNonCanonicalName}, |
| {"google.com", errNonCanonicalName}, |
| {"google..com.", errZeroSegLen}, |
| {"google.com.", nil}, |
| {".google.com.", errZeroSegLen}, |
| {"www..google.com.", errZeroSegLen}, |
| {"www.google.com.", nil}, |
| {in: longDNSPrefix[:254-len(suffix)] + suffix}, // 254B name, with ending dot. |
| {in: longDNSPrefix[:255-len(suffix)] + suffix, err: errNameTooLong}, // 255B name, with ending dot. |
| } |
| |
| for _, test := range tests { |
| in := MustNewName(test.in) |
| buf, err := in.pack(make([]byte, 0, 30), map[string]uint16{}, 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 != in { |
| t.Errorf("unpacking packing of %q: got = %#v, want = %#v", test.in, got, in) |
| } |
| } |
| } |
| |
| func TestNameUnpackTooLongName(t *testing.T) { |
| var suffix = []byte{2, 'g', 'o', 3, 'd', 'e', 'v', 0} |
| |
| const label = "longdnslabel" |
| labelBinary := append([]byte{byte(len(label))}, []byte(label)...) |
| var longDNSPrefix = bytes.Repeat(labelBinary, 18) |
| longDNSPrefix = longDNSPrefix[:len(longDNSPrefix):len(longDNSPrefix)] |
| |
| prepName := func(length int) []byte { |
| missing := length - (len(longDNSPrefix) + len(suffix) + 1) |
| name := append(longDNSPrefix, byte(missing)) |
| name = append(name, bytes.Repeat([]byte{'a'}, missing)...) |
| return append(name, suffix...) |
| } |
| |
| tests := []struct { |
| name []byte |
| err error |
| }{ |
| {name: prepName(255)}, |
| {name: prepName(256), err: errNameTooLong}, |
| } |
| |
| for i, test := range tests { |
| var got Name |
| _, err := got.unpack(test.name, 0) |
| if err != test.err { |
| t.Errorf("%v: %v: expected error: %v, got %v", i, test.name, test.err, err) |
| } |
| } |
| } |
| |
| 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 }}, |
| {"UnknownResource", func(p *Parser) error { _, err := p.UnknownResource(); 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]uint16{}, 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]uint16{}, 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{}) }}, |
| {"UnknownResource", func(b *Builder) error { return b.UnknownResource(ResourceHeader{}, UnknownResource{}) }}, |
| } |
| |
| 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) |
| } |
| case privateUseType: |
| if err := b.UnknownResource(a.Header, *a.Body.(*UnknownResource)); err != nil { |
| t.Fatalf("Builder.UnknownResource(%#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 |
| } |
| } |
| } |
| |
| func smallTestMsgWithUnknownResource() Message { |
| return Message{ |
| Questions: []Question{}, |
| Answers: []Resource{ |
| { |
| Header: ResourceHeader{ |
| Name: MustNewName("."), |
| Type: privateUseType, |
| Class: ClassINET, |
| TTL: uint32(123), |
| }, |
| Body: &UnknownResource{ |
| // The realType() method is called, when |
| // packing, so Type must match the type |
| // claimed by the Header above. |
| Type: privateUseType, |
| Data: []byte{42, 42, 42, 42}, |
| }, |
| }, |
| }, |
| } |
| } |
| |
| func TestUnknownPackUnpack(t *testing.T) { |
| msg := smallTestMsgWithUnknownResource() |
| packed, err := msg.Pack() |
| if err != nil { |
| t.Fatalf("Failed to pack UnknownResource: %v", err) |
| } |
| |
| var receivedMsg Message |
| err = receivedMsg.Unpack(packed) |
| if err != nil { |
| t.Fatalf("Failed to unpack UnknownResource: %v", err) |
| } |
| |
| if len(receivedMsg.Answers) != 1 { |
| t.Fatalf("Got %d answers, wanted 1", len(receivedMsg.Answers)) |
| } |
| |
| unknownResource, ok := receivedMsg.Answers[0].Body.(*UnknownResource) |
| if !ok { |
| t.Fatalf("Parsed a %T, wanted an UnknownResource", receivedMsg.Answers[0].Body) |
| } |
| |
| wantBody := msg.Answers[0].Body |
| if !reflect.DeepEqual(wantBody, unknownResource) { |
| t.Fatalf("Unpacked resource does not match: %v vs %v", wantBody, unknownResource) |
| } |
| } |
| |
| func TestParseUnknownResource(t *testing.T) { |
| msg := smallTestMsgWithUnknownResource() |
| packed, err := msg.Pack() |
| if err != nil { |
| t.Fatalf("Failed to pack UnknownResource: %v", err) |
| } |
| |
| var p Parser |
| if _, err = p.Start(packed); err != nil { |
| t.Fatalf("Parser failed to start: %s", err) |
| } |
| if _, err = p.AllQuestions(); err != nil { |
| t.Fatalf("Failed to parse questions: %s", err) |
| } |
| |
| parsedHeader, err := p.AnswerHeader() |
| if err != nil { |
| t.Fatalf("Error reading answer header: %s", err) |
| } |
| wantHeader := msg.Answers[0].Header |
| if !reflect.DeepEqual(wantHeader, parsedHeader) { |
| t.Fatalf("Parsed header does not match: %v vs %v", wantHeader, wantHeader) |
| } |
| |
| parsedUnknownResource, err := p.UnknownResource() |
| if err != nil { |
| t.Fatalf("Failed to parse UnknownResource: %s", err) |
| } |
| wantBody := msg.Answers[0].Body |
| if !reflect.DeepEqual(wantBody, &parsedUnknownResource) { |
| t.Fatalf("Parsed resource does not match: %v vs %v", wantBody, &parsedUnknownResource) |
| } |
| |
| // Finish parsing the rest of the message to ensure that |
| // (*Parser).UnknownResource() leaves the parser in a consistent state. |
| if _, err = p.AnswerHeader(); err != ErrSectionDone { |
| t.Fatalf("Answer section should be fully parsed") |
| } |
| if _, err = p.AllAuthorities(); err != nil { |
| t.Fatalf("Failed to parse authorities: %s", err) |
| } |
| if _, err = p.AllAdditionals(); err != nil { |
| t.Fatalf("Failed to parse additionals: %s", err) |
| } |
| } |
| |
| // 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{Question{Name: MustNewName("foo.bar.example.com."), Type: TypeA, Class: ClassINET}}, Answers: []Resource{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}}}, 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, 2}}}, Resource{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}}}, Resource{Header: ResourceHeader{Name: MustNewName("foo.bar.example.com."), Type: TypeCNAME, Class: ClassINET, TTL: 0, Length: 0}, Body: &CNAMEResource{CNAME: MustNewName("alias.example.com.")}}, Resource{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}}, Resource{Header: ResourceHeader{Name: MustNewName("foo.bar.example.com."), Type: TypePTR, Class: ClassINET, TTL: 0, Length: 0}, Body: &PTRResource{PTR: MustNewName("ptr.example.com.")}}, Resource{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.")}}, Resource{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.")}}, Resource{Header: ResourceHeader{Name: MustNewName("foo.bar.example.com."), Type: 65362, Class: ClassINET, TTL: 0, Length: 0}, Body: &UnknownResource{Type: 65362, Data: []byte{42, 0, 43, 44}}}}, Authorities: []Resource{Resource{Header: ResourceHeader{Name: MustNewName("foo.bar.example.com."), Type: TypeNS, Class: ClassINET, TTL: 0, Length: 0}, Body: &NSResource{NS: MustNewName("ns1.example.com.")}}, Resource{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{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"}}}, Resource{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"}}}, Resource{Header: ResourceHeader{Name: MustNewName("."), Type: TypeOPT, Class: 4096, TTL: 4261412864, Length: 0}, Body: &OPTResource{Options: []Option{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, AuthenticData: false, CheckingDisabled: 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.")}}, dnsmessage.Resource{Header: dnsmessage.ResourceHeader{Name: dnsmessage.MustNewName("foo.bar.example.com."), Type: 65362, Class: dnsmessage.ClassINET, TTL: 0, Length: 0}, Body: &dnsmessage.UnknownResource{Type: 65362, Data: []byte{42, 0, 43, 44}}}}, 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."), |
| }, |
| }, |
| { |
| ResourceHeader{ |
| Name: name, |
| Type: privateUseType, |
| Class: ClassINET, |
| }, |
| &UnknownResource{ |
| Type: privateUseType, |
| Data: []byte{42, 0, 43, 44}, |
| }, |
| }, |
| }, |
| 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}, |
| }, |
| }, |
| }, |
| }, |
| }, |
| } |
| } |
| |
| // This package is imported by the standard library net package |
| // and therefore must not use fmt. We'll catch a mistake when vendored |
| // into the standard library, but this test catches the mistake earlier. |
| func TestNoFmt(t *testing.T) { |
| files, err := filepath.Glob("*.go") |
| if err != nil { |
| t.Fatal(err) |
| } |
| for _, file := range files { |
| if strings.HasSuffix(file, "_test.go") { |
| continue |
| } |
| // Could use something complex like go/build or x/tools/go/packages, |
| // but there's no reason for "fmt" to appear (in quotes) in the source |
| // otherwise, so just use a simple substring search. |
| data, err := os.ReadFile(file) |
| if err != nil { |
| t.Fatal(err) |
| } |
| if bytes.Contains(data, []byte(`"fmt"`)) { |
| t.Errorf(`%s: cannot import "fmt"`, file) |
| } |
| } |
| } |
| |
| func FuzzUnpackPack(f *testing.F) { |
| for _, msg := range []Message{smallTestMsg(), largeTestMsg()} { |
| bytes, _ := msg.Pack() |
| f.Add(bytes) |
| } |
| |
| f.Fuzz(func(t *testing.T, msg []byte) { |
| var m Message |
| if err := m.Unpack(msg); err != nil { |
| return |
| } |
| |
| msgPacked, err := m.Pack() |
| if err != nil { |
| t.Fatalf("failed to pack message that was successfully unpacked: %v", err) |
| } |
| |
| var m2 Message |
| if err := m2.Unpack(msgPacked); err != nil { |
| t.Fatalf("failed to unpack message that was succesfully packed: %v", err) |
| } |
| |
| if !reflect.DeepEqual(m, m2) { |
| t.Fatal("unpack(msg) is not deep equal to unpack(pack(unpack(msg)))") |
| } |
| }) |
| } |
| |
| func TestParseResourceHeaderMultipleTimes(t *testing.T) { |
| msg := Message{ |
| Header: Header{Response: true, Authoritative: true}, |
| Answers: []Resource{ |
| { |
| ResourceHeader{ |
| Name: MustNewName("go.dev."), |
| Type: TypeA, |
| Class: ClassINET, |
| }, |
| &AResource{[4]byte{127, 0, 0, 1}}, |
| }, |
| }, |
| Authorities: []Resource{ |
| { |
| ResourceHeader{ |
| Name: MustNewName("go.dev."), |
| Type: TypeA, |
| Class: ClassINET, |
| }, |
| &AResource{[4]byte{127, 0, 0, 1}}, |
| }, |
| }, |
| } |
| |
| raw, err := msg.Pack() |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| var p Parser |
| |
| if _, err := p.Start(raw); err != nil { |
| t.Fatal(err) |
| } |
| |
| if err := p.SkipAllQuestions(); err != nil { |
| t.Fatal(err) |
| } |
| |
| hdr1, err := p.AnswerHeader() |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| hdr2, err := p.AnswerHeader() |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| if hdr1 != hdr2 { |
| t.Fatal("AnswerHeader called multiple times without parsing the RData returned different headers") |
| } |
| |
| if _, err := p.AResource(); err != nil { |
| t.Fatal(err) |
| } |
| |
| if _, err := p.AnswerHeader(); err != ErrSectionDone { |
| t.Fatalf("unexpected error: %v, want: %v", err, ErrSectionDone) |
| } |
| |
| hdr3, err := p.AuthorityHeader() |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| hdr4, err := p.AuthorityHeader() |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| if hdr3 != hdr4 { |
| t.Fatal("AuthorityHeader called multiple times without parsing the RData returned different headers") |
| } |
| |
| if _, err := p.AResource(); err != nil { |
| t.Fatal(err) |
| } |
| |
| if _, err := p.AuthorityHeader(); err != ErrSectionDone { |
| t.Fatalf("unexpected error: %v, want: %v", err, ErrSectionDone) |
| } |
| } |
| |
| func TestParseDifferentResourceHeadersWithoutParsingRData(t *testing.T) { |
| msg := smallTestMsg() |
| raw, err := msg.Pack() |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| var p Parser |
| if _, err := p.Start(raw); err != nil { |
| t.Fatal(err) |
| } |
| |
| if err := p.SkipAllQuestions(); err != nil { |
| t.Fatal(err) |
| } |
| |
| if _, err := p.AnswerHeader(); err != nil { |
| t.Fatal(err) |
| } |
| |
| if _, err := p.AdditionalHeader(); err == nil { |
| t.Errorf("p.AdditionalHeader() unexpected success") |
| } |
| |
| if _, err := p.AuthorityHeader(); err == nil { |
| t.Errorf("p.AuthorityHeader() unexpected success") |
| } |
| } |
| |
| func TestParseWrongSection(t *testing.T) { |
| msg := smallTestMsg() |
| raw, err := msg.Pack() |
| if err != nil { |
| t.Fatal(err) |
| } |
| |
| var p Parser |
| if _, err := p.Start(raw); err != nil { |
| t.Fatal(err) |
| } |
| |
| if err := p.SkipAllQuestions(); err != nil { |
| t.Fatalf("p.SkipAllQuestions() = %v", err) |
| } |
| if _, err := p.AnswerHeader(); err != nil { |
| t.Fatalf("p.AnswerHeader() = %v", err) |
| } |
| if _, err := p.AuthorityHeader(); err == nil { |
| t.Fatalf("p.AuthorityHeader(): unexpected success in Answer section") |
| } |
| if err := p.SkipAuthority(); err == nil { |
| t.Fatalf("p.SkipAuthority(): unexpected success in Answer section") |
| } |
| if err := p.SkipAllAuthorities(); err == nil { |
| t.Fatalf("p.SkipAllAuthorities(): unexpected success in Answer section") |
| } |
| } |
| |
| func TestBuilderNameCompressionWithNonZeroedName(t *testing.T) { |
| b := NewBuilder(nil, Header{}) |
| b.EnableCompression() |
| if err := b.StartQuestions(); err != nil { |
| t.Fatalf("b.StartQuestions() unexpected error: %v", err) |
| } |
| |
| name := MustNewName("go.dev.") |
| if err := b.Question(Question{Name: name}); err != nil { |
| t.Fatalf("b.Question() unexpected error: %v", err) |
| } |
| |
| // Character that is not part of the name (name.Data[:name.Length]), |
| // shouldn't affect the compression algorithm. |
| name.Data[name.Length] = '1' |
| if err := b.Question(Question{Name: name}); err != nil { |
| t.Fatalf("b.Question() unexpected error: %v", err) |
| } |
| |
| msg, err := b.Finish() |
| if err != nil { |
| t.Fatalf("b.Finish() unexpected error: %v", err) |
| } |
| |
| expect := []byte{ |
| 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, // header |
| 2, 'g', 'o', 3, 'd', 'e', 'v', 0, 0, 0, 0, 0, // question 1 |
| 0xC0, 12, 0, 0, 0, 0, // question 2 |
| } |
| if !bytes.Equal(msg, expect) { |
| t.Fatalf("b.Finish() = %v, want: %v", msg, expect) |
| } |
| } |
| |
| func TestBuilderCompressionInAppendMode(t *testing.T) { |
| maxPtr := int(^uint16(0) >> 2) |
| b := NewBuilder(make([]byte, maxPtr, maxPtr+512), Header{}) |
| b.EnableCompression() |
| if err := b.StartQuestions(); err != nil { |
| t.Fatalf("b.StartQuestions() unexpected error: %v", err) |
| } |
| if err := b.Question(Question{Name: MustNewName("go.dev.")}); err != nil { |
| t.Fatalf("b.Question() unexpected error: %v", err) |
| } |
| if err := b.Question(Question{Name: MustNewName("go.dev.")}); err != nil { |
| t.Fatalf("b.Question() unexpected error: %v", err) |
| } |
| msg, err := b.Finish() |
| if err != nil { |
| t.Fatalf("b.Finish() unexpected error: %v", err) |
| } |
| expect := []byte{ |
| 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, // header |
| 2, 'g', 'o', 3, 'd', 'e', 'v', 0, 0, 0, 0, 0, // question 1 |
| 0xC0, 12, 0, 0, 0, 0, // question 2 |
| } |
| if !bytes.Equal(msg[maxPtr:], expect) { |
| t.Fatalf("msg[maxPtr:] = %v, want: %v", msg[maxPtr:], expect) |
| } |
| } |