593 lines
19 KiB
Go
593 lines
19 KiB
Go
package dns
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"io"
|
|
"strconv"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func namesEqual(a, b Name) bool {
|
|
if len(a) != len(b) {
|
|
return false
|
|
}
|
|
for i := 0; i < len(a); i++ {
|
|
if !bytes.Equal(a[i], b[i]) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func TestName(t *testing.T) {
|
|
for _, test := range []struct {
|
|
labels [][]byte
|
|
err error
|
|
s string
|
|
}{
|
|
{[][]byte{}, nil, "."},
|
|
{[][]byte{[]byte("test")}, nil, "test"},
|
|
{[][]byte{[]byte("a"), []byte("b"), []byte("c")}, nil, "a.b.c"},
|
|
|
|
{[][]byte{{}}, ErrZeroLengthLabel, ""},
|
|
{[][]byte{[]byte("a"), {}, []byte("c")}, ErrZeroLengthLabel, ""},
|
|
|
|
// 63 octets.
|
|
{[][]byte{[]byte("0123456789abcdef0123456789ABCDEF0123456789abcdef0123456789ABCDE")}, nil,
|
|
"0123456789abcdef0123456789ABCDEF0123456789abcdef0123456789ABCDE"},
|
|
// 64 octets.
|
|
{[][]byte{[]byte("0123456789abcdef0123456789ABCDEF0123456789abcdef0123456789ABCDEF")}, ErrLabelTooLong, ""},
|
|
|
|
// 64+64+64+62 octets.
|
|
{[][]byte{
|
|
[]byte("0123456789abcdef0123456789ABCDEF0123456789abcdef0123456789ABCDE"),
|
|
[]byte("0123456789abcdef0123456789ABCDEF0123456789abcdef0123456789ABCDE"),
|
|
[]byte("0123456789abcdef0123456789ABCDEF0123456789abcdef0123456789ABCDE"),
|
|
[]byte("0123456789abcdef0123456789ABCDEF0123456789abcdef0123456789ABC"),
|
|
}, nil,
|
|
"0123456789abcdef0123456789ABCDEF0123456789abcdef0123456789ABCDE.0123456789abcdef0123456789ABCDEF0123456789abcdef0123456789ABCDE.0123456789abcdef0123456789ABCDEF0123456789abcdef0123456789ABCDE.0123456789abcdef0123456789ABCDEF0123456789abcdef0123456789ABC"},
|
|
// 64+64+64+63 octets.
|
|
{[][]byte{
|
|
[]byte("0123456789abcdef0123456789ABCDEF0123456789abcdef0123456789ABCDE"),
|
|
[]byte("0123456789abcdef0123456789ABCDEF0123456789abcdef0123456789ABCDE"),
|
|
[]byte("0123456789abcdef0123456789ABCDEF0123456789abcdef0123456789ABCDE"),
|
|
[]byte("0123456789abcdef0123456789ABCDEF0123456789abcdef0123456789ABCD"),
|
|
}, ErrNameTooLong, ""},
|
|
// 127 one-octet labels.
|
|
{[][]byte{
|
|
{'0'}, {'1'}, {'2'}, {'3'}, {'4'}, {'5'}, {'6'}, {'7'}, {'8'}, {'9'}, {'a'}, {'b'}, {'c'}, {'d'}, {'e'}, {'f'},
|
|
{'0'}, {'1'}, {'2'}, {'3'}, {'4'}, {'5'}, {'6'}, {'7'}, {'8'}, {'9'}, {'A'}, {'B'}, {'C'}, {'D'}, {'E'}, {'F'},
|
|
{'0'}, {'1'}, {'2'}, {'3'}, {'4'}, {'5'}, {'6'}, {'7'}, {'8'}, {'9'}, {'a'}, {'b'}, {'c'}, {'d'}, {'e'}, {'f'},
|
|
{'0'}, {'1'}, {'2'}, {'3'}, {'4'}, {'5'}, {'6'}, {'7'}, {'8'}, {'9'}, {'A'}, {'B'}, {'C'}, {'D'}, {'E'}, {'F'},
|
|
{'0'}, {'1'}, {'2'}, {'3'}, {'4'}, {'5'}, {'6'}, {'7'}, {'8'}, {'9'}, {'a'}, {'b'}, {'c'}, {'d'}, {'e'}, {'f'},
|
|
{'0'}, {'1'}, {'2'}, {'3'}, {'4'}, {'5'}, {'6'}, {'7'}, {'8'}, {'9'}, {'A'}, {'B'}, {'C'}, {'D'}, {'E'}, {'F'},
|
|
{'0'}, {'1'}, {'2'}, {'3'}, {'4'}, {'5'}, {'6'}, {'7'}, {'8'}, {'9'}, {'a'}, {'b'}, {'c'}, {'d'}, {'e'}, {'f'},
|
|
{'0'}, {'1'}, {'2'}, {'3'}, {'4'}, {'5'}, {'6'}, {'7'}, {'8'}, {'9'}, {'A'}, {'B'}, {'C'}, {'D'}, {'E'},
|
|
}, nil,
|
|
"0.1.2.3.4.5.6.7.8.9.a.b.c.d.e.f.0.1.2.3.4.5.6.7.8.9.A.B.C.D.E.F.0.1.2.3.4.5.6.7.8.9.a.b.c.d.e.f.0.1.2.3.4.5.6.7.8.9.A.B.C.D.E.F.0.1.2.3.4.5.6.7.8.9.a.b.c.d.e.f.0.1.2.3.4.5.6.7.8.9.A.B.C.D.E.F.0.1.2.3.4.5.6.7.8.9.a.b.c.d.e.f.0.1.2.3.4.5.6.7.8.9.A.B.C.D.E"},
|
|
// 128 one-octet labels.
|
|
{[][]byte{
|
|
{'0'}, {'1'}, {'2'}, {'3'}, {'4'}, {'5'}, {'6'}, {'7'}, {'8'}, {'9'}, {'a'}, {'b'}, {'c'}, {'d'}, {'e'}, {'f'},
|
|
{'0'}, {'1'}, {'2'}, {'3'}, {'4'}, {'5'}, {'6'}, {'7'}, {'8'}, {'9'}, {'A'}, {'B'}, {'C'}, {'D'}, {'E'}, {'F'},
|
|
{'0'}, {'1'}, {'2'}, {'3'}, {'4'}, {'5'}, {'6'}, {'7'}, {'8'}, {'9'}, {'a'}, {'b'}, {'c'}, {'d'}, {'e'}, {'f'},
|
|
{'0'}, {'1'}, {'2'}, {'3'}, {'4'}, {'5'}, {'6'}, {'7'}, {'8'}, {'9'}, {'A'}, {'B'}, {'C'}, {'D'}, {'E'}, {'F'},
|
|
{'0'}, {'1'}, {'2'}, {'3'}, {'4'}, {'5'}, {'6'}, {'7'}, {'8'}, {'9'}, {'a'}, {'b'}, {'c'}, {'d'}, {'e'}, {'f'},
|
|
{'0'}, {'1'}, {'2'}, {'3'}, {'4'}, {'5'}, {'6'}, {'7'}, {'8'}, {'9'}, {'A'}, {'B'}, {'C'}, {'D'}, {'E'}, {'F'},
|
|
{'0'}, {'1'}, {'2'}, {'3'}, {'4'}, {'5'}, {'6'}, {'7'}, {'8'}, {'9'}, {'a'}, {'b'}, {'c'}, {'d'}, {'e'}, {'f'},
|
|
{'0'}, {'1'}, {'2'}, {'3'}, {'4'}, {'5'}, {'6'}, {'7'}, {'8'}, {'9'}, {'A'}, {'B'}, {'C'}, {'D'}, {'E'}, {'F'},
|
|
}, ErrNameTooLong, ""},
|
|
} {
|
|
// Test that NewName returns proper error codes, and otherwise
|
|
// returns an equal slice of labels.
|
|
name, err := NewName(test.labels)
|
|
if err != test.err || (err == nil && !namesEqual(name, test.labels)) {
|
|
t.Errorf("%+q returned (%+q, %v), expected (%+q, %v)",
|
|
test.labels, name, err, test.labels, test.err)
|
|
continue
|
|
}
|
|
if test.err != nil {
|
|
continue
|
|
}
|
|
|
|
// Test that the string version of the name comes out as
|
|
// expected.
|
|
s := name.String()
|
|
if s != test.s {
|
|
t.Errorf("%+q became string %+q, expected %+q", test.labels, s, test.s)
|
|
continue
|
|
}
|
|
|
|
// Test that parsing from a string back to a Name results in the
|
|
// original slice of labels.
|
|
name, err = ParseName(s)
|
|
if err != nil || !namesEqual(name, test.labels) {
|
|
t.Errorf("%+q parsing %+q returned (%+q, %v), expected (%+q, %v)",
|
|
test.labels, s, name, err, test.labels, nil)
|
|
continue
|
|
}
|
|
// A trailing dot should be ignored.
|
|
if !strings.HasSuffix(s, ".") {
|
|
dotName, dotErr := ParseName(s + ".")
|
|
if dotErr != err || !namesEqual(dotName, name) {
|
|
t.Errorf("%+q parsing %+q returned (%+q, %v), expected (%+q, %v)",
|
|
test.labels, s+".", dotName, dotErr, name, err)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestParseName(t *testing.T) {
|
|
for _, test := range []struct {
|
|
s string
|
|
name Name
|
|
err error
|
|
}{
|
|
// This case can't be tested by TestName above because String
|
|
// will never produce "" (it produces "." instead).
|
|
{"", [][]byte{}, nil},
|
|
} {
|
|
name, err := ParseName(test.s)
|
|
if err != test.err || (err == nil && !namesEqual(name, test.name)) {
|
|
t.Errorf("%+q returned (%+q, %v), expected (%+q, %v)",
|
|
test.s, name, err, test.name, test.err)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
|
|
func unescapeString(s string) ([][]byte, error) {
|
|
if s == "." {
|
|
return [][]byte{}, nil
|
|
}
|
|
|
|
var result [][]byte
|
|
for _, label := range strings.Split(s, ".") {
|
|
var buf bytes.Buffer
|
|
i := 0
|
|
for i < len(label) {
|
|
switch label[i] {
|
|
case '\\':
|
|
if i+3 >= len(label) {
|
|
return nil, fmt.Errorf("truncated escape sequence at index %v", i)
|
|
}
|
|
if label[i+1] != 'x' {
|
|
return nil, fmt.Errorf("malformed escape sequence at index %v", i)
|
|
}
|
|
b, err := strconv.ParseUint(string(label[i+2:i+4]), 16, 8)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("malformed hex sequence at index %v", i+2)
|
|
}
|
|
buf.WriteByte(byte(b))
|
|
i += 4
|
|
default:
|
|
buf.WriteByte(label[i])
|
|
i++
|
|
}
|
|
}
|
|
result = append(result, buf.Bytes())
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
func TestNameString(t *testing.T) {
|
|
for _, test := range []struct {
|
|
name Name
|
|
s string
|
|
}{
|
|
{[][]byte{}, "."},
|
|
{[][]byte{[]byte("\x00"), []byte("a.b"), []byte("c\nd\\")}, "\\x00.a\\x2eb.c\\x0ad\\x5c"},
|
|
{[][]byte{
|
|
[]byte("\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !\"#$%&'()*+,-./0123456789:;<=>"),
|
|
[]byte("?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}"),
|
|
[]byte("~\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc"),
|
|
[]byte("\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb"),
|
|
[]byte("\xfc\xfd\xfe\xff"),
|
|
}, "\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\x09\\x0a\\x0b\\x0c\\x0d\\x0e\\x0f\\x10\\x11\\x12\\x13\\x14\\x15\\x16\\x17\\x18\\x19\\x1a\\x1b\\x1c\\x1d\\x1e\\x1f\\x20\\x21\\x22\\x23\\x24\\x25\\x26\\x27\\x28\\x29\\x2a\\x2b\\x2c-\\x2e\\x2f0123456789\\x3a\\x3b\\x3c\\x3d\\x3e.\\x3f\\x40ABCDEFGHIJKLMNOPQRSTUVWXYZ\\x5b\\x5c\\x5d\\x5e\\x5f\\x60abcdefghijklmnopqrstuvwxyz\\x7b\\x7c\\x7d.\\x7e\\x7f\\x80\\x81\\x82\\x83\\x84\\x85\\x86\\x87\\x88\\x89\\x8a\\x8b\\x8c\\x8d\\x8e\\x8f\\x90\\x91\\x92\\x93\\x94\\x95\\x96\\x97\\x98\\x99\\x9a\\x9b\\x9c\\x9d\\x9e\\x9f\\xa0\\xa1\\xa2\\xa3\\xa4\\xa5\\xa6\\xa7\\xa8\\xa9\\xaa\\xab\\xac\\xad\\xae\\xaf\\xb0\\xb1\\xb2\\xb3\\xb4\\xb5\\xb6\\xb7\\xb8\\xb9\\xba\\xbb\\xbc.\\xbd\\xbe\\xbf\\xc0\\xc1\\xc2\\xc3\\xc4\\xc5\\xc6\\xc7\\xc8\\xc9\\xca\\xcb\\xcc\\xcd\\xce\\xcf\\xd0\\xd1\\xd2\\xd3\\xd4\\xd5\\xd6\\xd7\\xd8\\xd9\\xda\\xdb\\xdc\\xdd\\xde\\xdf\\xe0\\xe1\\xe2\\xe3\\xe4\\xe5\\xe6\\xe7\\xe8\\xe9\\xea\\xeb\\xec\\xed\\xee\\xef\\xf0\\xf1\\xf2\\xf3\\xf4\\xf5\\xf6\\xf7\\xf8\\xf9\\xfa\\xfb.\\xfc\\xfd\\xfe\\xff"},
|
|
} {
|
|
s := test.name.String()
|
|
if s != test.s {
|
|
t.Errorf("%+q escaped to %+q, expected %+q", test.name, s, test.s)
|
|
continue
|
|
}
|
|
unescaped, err := unescapeString(s)
|
|
if err != nil {
|
|
t.Errorf("%+q unescaping %+q resulted in error %v", test.name, s, err)
|
|
continue
|
|
}
|
|
if !namesEqual(Name(unescaped), test.name) {
|
|
t.Errorf("%+q roundtripped through %+q to %+q", test.name, s, unescaped)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestNameTrimSuffix(t *testing.T) {
|
|
for _, test := range []struct {
|
|
name, suffix string
|
|
trimmed string
|
|
ok bool
|
|
}{
|
|
{"", "", ".", true},
|
|
{".", ".", ".", true},
|
|
{"abc", "", "abc", true},
|
|
{"abc", ".", "abc", true},
|
|
{"", "abc", ".", false},
|
|
{".", "abc", ".", false},
|
|
{"example.com", "com", "example", true},
|
|
{"example.com", "net", ".", false},
|
|
{"example.com", "example.com", ".", true},
|
|
{"example.com", "test.com", ".", false},
|
|
{"example.com", "xample.com", ".", false},
|
|
{"example.com", "example", ".", false},
|
|
{"example.com", "COM", "example", true},
|
|
{"EXAMPLE.COM", "com", "EXAMPLE", true},
|
|
} {
|
|
tmp, ok := mustParseName(test.name).TrimSuffix(mustParseName(test.suffix))
|
|
trimmed := tmp.String()
|
|
if ok != test.ok || trimmed != test.trimmed {
|
|
t.Errorf("TrimSuffix %+q %+q returned (%+q, %v), expected (%+q, %v)",
|
|
test.name, test.suffix, trimmed, ok, test.trimmed, test.ok)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestReadName(t *testing.T) {
|
|
// Good tests.
|
|
for _, test := range []struct {
|
|
start int64
|
|
end int64
|
|
input string
|
|
s string
|
|
}{
|
|
// Empty name.
|
|
{0, 1, "\x00abcd", "."},
|
|
// No pointers.
|
|
{12, 25, "AAAABBBBCCCC\x07example\x03com\x00", "example.com"},
|
|
// Backward pointer.
|
|
{25, 31, "AAAABBBBCCCC\x07example\x03com\x00\x03sub\xc0\x0c", "sub.example.com"},
|
|
// Forward pointer.
|
|
{0, 4, "\x01a\xc0\x04\x03bcd\x00", "a.bcd"},
|
|
// Two backwards pointers.
|
|
{31, 38, "AAAABBBBCCCC\x07example\x03com\x00\x03sub\xc0\x0c\x04sub2\xc0\x19", "sub2.sub.example.com"},
|
|
// Forward then backward pointer.
|
|
{25, 31, "AAAABBBBCCCC\x07example\x03com\x00\x03sub\xc0\x1f\x04sub2\xc0\x0c", "sub.sub2.example.com"},
|
|
// Overlapping codons.
|
|
{0, 4, "\x01a\xc0\x03bcd\x00", "a.bcd"},
|
|
// Pointer to empty label.
|
|
{0, 10, "\x07example\xc0\x0a\x00", "example"},
|
|
{1, 11, "\x00\x07example\xc0\x00", "example"},
|
|
// Pointer to pointer to empty label.
|
|
{0, 10, "\x07example\xc0\x0a\xc0\x0c\x00", "example"},
|
|
{1, 11, "\x00\x07example\xc0\x0c\xc0\x00", "example"},
|
|
} {
|
|
r := bytes.NewReader([]byte(test.input))
|
|
_, err := r.Seek(test.start, io.SeekStart)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
name, err := readName(r)
|
|
if err != nil {
|
|
t.Errorf("%+q returned error %s", test.input, err)
|
|
continue
|
|
}
|
|
s := name.String()
|
|
if s != test.s {
|
|
t.Errorf("%+q returned %+q, expected %+q", test.input, s, test.s)
|
|
continue
|
|
}
|
|
cur, _ := r.Seek(0, io.SeekCurrent)
|
|
if cur != test.end {
|
|
t.Errorf("%+q left offset %d, expected %d", test.input, cur, test.end)
|
|
continue
|
|
}
|
|
}
|
|
|
|
// Bad tests.
|
|
for _, test := range []struct {
|
|
start int64
|
|
input string
|
|
err error
|
|
}{
|
|
{0, "", io.ErrUnexpectedEOF},
|
|
// Reserved label type.
|
|
{0, "\x80example", ErrReservedLabelType},
|
|
// Reserved label type.
|
|
{0, "\x40example", ErrReservedLabelType},
|
|
// No Terminating empty label.
|
|
{0, "\x07example\x03com", io.ErrUnexpectedEOF},
|
|
// Pointer past end of buffer.
|
|
{0, "\x07example\xc0\xff", io.ErrUnexpectedEOF},
|
|
// Pointer to self.
|
|
{0, "\x07example\x03com\xc0\x0c", ErrTooManyPointers},
|
|
// Pointer to self with intermediate label.
|
|
{0, "\x07example\x03com\xc0\x08", ErrTooManyPointers},
|
|
// Two pointers that point to each other.
|
|
{0, "\xc0\x02\xc0\x00", ErrTooManyPointers},
|
|
// Two pointers that point to each other, with intermediate labels.
|
|
{0, "\x01a\xc0\x04\x01b\xc0\x00", ErrTooManyPointers},
|
|
// EOF while reading label.
|
|
{0, "\x0aexample", io.ErrUnexpectedEOF},
|
|
// EOF before second byte of pointer.
|
|
{0, "\xc0", io.ErrUnexpectedEOF},
|
|
{0, "\x07example\xc0", io.ErrUnexpectedEOF},
|
|
} {
|
|
r := bytes.NewReader([]byte(test.input))
|
|
_, err := r.Seek(test.start, io.SeekStart)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
name, err := readName(r)
|
|
if err == io.EOF {
|
|
err = io.ErrUnexpectedEOF
|
|
}
|
|
if err != test.err {
|
|
t.Errorf("%+q returned (%+q, %v), expected %v", test.input, name, err, test.err)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
|
|
func mustParseName(s string) Name {
|
|
name, err := ParseName(s)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
return name
|
|
}
|
|
|
|
func questionsEqual(a, b *Question) bool {
|
|
if !namesEqual(a.Name, b.Name) {
|
|
return false
|
|
}
|
|
if a.Type != b.Type || a.Class != b.Class {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
func rrsEqual(a, b *RR) bool {
|
|
if !namesEqual(a.Name, b.Name) {
|
|
return false
|
|
}
|
|
if a.Type != b.Type || a.Class != b.Class || a.TTL != b.TTL {
|
|
return false
|
|
}
|
|
if !bytes.Equal(a.Data, b.Data) {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
func messagesEqual(a, b *Message) bool {
|
|
if a.ID != b.ID || a.Flags != b.Flags {
|
|
return false
|
|
}
|
|
if len(a.Question) != len(b.Question) {
|
|
return false
|
|
}
|
|
for i := 0; i < len(a.Question); i++ {
|
|
if !questionsEqual(&a.Question[i], &b.Question[i]) {
|
|
return false
|
|
}
|
|
}
|
|
for _, rec := range []struct{ rrA, rrB []RR }{
|
|
{a.Answer, b.Answer},
|
|
{a.Authority, b.Authority},
|
|
{a.Additional, b.Additional},
|
|
} {
|
|
if len(rec.rrA) != len(rec.rrB) {
|
|
return false
|
|
}
|
|
for i := 0; i < len(rec.rrA); i++ {
|
|
if !rrsEqual(&rec.rrA[i], &rec.rrB[i]) {
|
|
return false
|
|
}
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func TestMessageFromWireFormat(t *testing.T) {
|
|
for _, test := range []struct {
|
|
buf string
|
|
expected Message
|
|
err error
|
|
}{
|
|
{
|
|
"\x12\x34",
|
|
Message{},
|
|
io.ErrUnexpectedEOF,
|
|
},
|
|
{
|
|
"\x12\x34\x01\x00\x00\x01\x00\x00\x00\x00\x00\x00\x03www\x07example\x03com\x00\x00\x01\x00\x01",
|
|
Message{
|
|
ID: 0x1234,
|
|
Flags: 0x0100,
|
|
Question: []Question{
|
|
{
|
|
Name: mustParseName("www.example.com"),
|
|
Type: 1,
|
|
Class: 1,
|
|
},
|
|
},
|
|
Answer: []RR{},
|
|
Authority: []RR{},
|
|
Additional: []RR{},
|
|
},
|
|
nil,
|
|
},
|
|
{
|
|
"\x12\x34\x01\x00\x00\x01\x00\x00\x00\x00\x00\x00\x03www\x07example\x03com\x00\x00\x01\x00\x01X",
|
|
Message{},
|
|
ErrTrailingBytes,
|
|
},
|
|
{
|
|
"\x12\x34\x81\x80\x00\x01\x00\x01\x00\x00\x00\x00\x03www\x07example\x03com\x00\x00\x01\x00\x01\x03www\x07example\x03com\x00\x00\x01\x00\x01\x00\x00\x00\x80\x00\x04\xc0\x00\x02\x01",
|
|
Message{
|
|
ID: 0x1234,
|
|
Flags: 0x8180,
|
|
Question: []Question{
|
|
{
|
|
Name: mustParseName("www.example.com"),
|
|
Type: 1,
|
|
Class: 1,
|
|
},
|
|
},
|
|
Answer: []RR{
|
|
{
|
|
Name: mustParseName("www.example.com"),
|
|
Type: 1,
|
|
Class: 1,
|
|
TTL: 128,
|
|
Data: []byte{192, 0, 2, 1},
|
|
},
|
|
},
|
|
Authority: []RR{},
|
|
Additional: []RR{},
|
|
},
|
|
nil,
|
|
},
|
|
} {
|
|
message, err := MessageFromWireFormat([]byte(test.buf))
|
|
if err != test.err || (err == nil && !messagesEqual(&message, &test.expected)) {
|
|
t.Errorf("%+q\nreturned (%+v, %v)\nexpected (%+v, %v)",
|
|
test.buf, message, err, test.expected, test.err)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestMessageWireFormatRoundTrip(t *testing.T) {
|
|
for _, message := range []Message{
|
|
{
|
|
ID: 0x1234,
|
|
Flags: 0x0100,
|
|
Question: []Question{
|
|
{
|
|
Name: mustParseName("www.example.com"),
|
|
Type: 1,
|
|
Class: 1,
|
|
},
|
|
{
|
|
Name: mustParseName("www2.example.com"),
|
|
Type: 2,
|
|
Class: 2,
|
|
},
|
|
},
|
|
Answer: []RR{
|
|
{
|
|
Name: mustParseName("abc"),
|
|
Type: 2,
|
|
Class: 3,
|
|
TTL: 0xffffffff,
|
|
Data: []byte{1},
|
|
},
|
|
{
|
|
Name: mustParseName("xyz"),
|
|
Type: 2,
|
|
Class: 3,
|
|
TTL: 255,
|
|
Data: []byte{},
|
|
},
|
|
},
|
|
Authority: []RR{
|
|
{
|
|
Name: mustParseName("."),
|
|
Type: 65535,
|
|
Class: 65535,
|
|
TTL: 0,
|
|
Data: []byte("XXXXXXXXXXXXXXXXXXX"),
|
|
},
|
|
},
|
|
Additional: []RR{},
|
|
},
|
|
} {
|
|
buf, err := message.WireFormat()
|
|
if err != nil {
|
|
t.Errorf("%+v cannot make wire format: %v", message, err)
|
|
continue
|
|
}
|
|
message2, err := MessageFromWireFormat(buf)
|
|
if err != nil {
|
|
t.Errorf("%+q cannot parse wire format: %v", buf, err)
|
|
continue
|
|
}
|
|
if !messagesEqual(&message, &message2) {
|
|
t.Errorf("messages unequal\nbefore: %+v\n after: %+v", message, message2)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestDecodeRDataTXT(t *testing.T) {
|
|
for _, test := range []struct {
|
|
p []byte
|
|
decoded []byte
|
|
err error
|
|
}{
|
|
{[]byte{}, nil, io.ErrUnexpectedEOF},
|
|
{[]byte("\x00"), []byte{}, nil},
|
|
{[]byte("\x01"), nil, io.ErrUnexpectedEOF},
|
|
} {
|
|
decoded, err := DecodeRDataTXT(test.p)
|
|
if err != test.err || (err == nil && !bytes.Equal(decoded, test.decoded)) {
|
|
t.Errorf("%+q\nreturned (%+q, %v)\nexpected (%+q, %v)",
|
|
test.p, decoded, err, test.decoded, test.err)
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestEncodeRDataTXT(t *testing.T) {
|
|
// Encoding 0 bytes needs to return at least a single length octet of
|
|
// zero, not an empty slice.
|
|
p := make([]byte, 0)
|
|
encoded := EncodeRDataTXT(p)
|
|
if len(encoded) < 0 {
|
|
t.Errorf("EncodeRDataTXT(%v) returned %v", p, encoded)
|
|
}
|
|
|
|
// 255 bytes should be able to be encoded into 256 bytes.
|
|
p = make([]byte, 255)
|
|
encoded = EncodeRDataTXT(p)
|
|
if len(encoded) > 256 {
|
|
t.Errorf("EncodeRDataTXT(%d bytes) returned %d bytes", len(p), len(encoded))
|
|
}
|
|
}
|
|
|
|
func TestRDataTXTRoundTrip(t *testing.T) {
|
|
for _, p := range [][]byte{
|
|
{},
|
|
[]byte("\x00"),
|
|
{
|
|
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
|
|
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
|
|
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
|
|
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
|
|
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
|
|
0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
|
|
0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f,
|
|
0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f,
|
|
0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
|
|
0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,
|
|
0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,
|
|
0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
|
|
0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,
|
|
0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
|
|
0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
|
|
0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
|
|
},
|
|
} {
|
|
rdata := EncodeRDataTXT(p)
|
|
decoded, err := DecodeRDataTXT(rdata)
|
|
if err != nil || !bytes.Equal(decoded, p) {
|
|
t.Errorf("%+q returned (%+q, %v)", p, decoded, err)
|
|
continue
|
|
}
|
|
}
|
|
}
|