···

       
7
       
 
       
      - uses: actions/setup-go@v5

     

       
8
       
 
       
        with:

     

       
9
       
 
       
          go-version: '1.22.3'

     

       
0
       
 
       

     

       
10
       
 
       
      - run: go test ./...

     

···

       
7
       
 
       
      - uses: actions/setup-go@v5

     

       
8
       
 
       
        with:

     

       
9
       
 
       
          go-version: '1.22.3'

     

       
10
       
+
       
      - run: go mod download

     

       
11
       
 
       
      - run: go test ./...

     

···

       
66
       
 
       
}

     

       
67
       
 
       


     

       
68
       
 
       
// encode_domain returns the bytes of the input bytes appened with the encoded domain name.

     

       
69
       
-
       
func encode_domain(bytes []byte, domain_name string, offsets *map[string]uint8) []byte {

     

       
70
       
-
       
	pos := uint8(len(bytes))

     

       
71
       
 
       


     

       
72
       
 
       
	labels := strings.Split(domain_name, ".")

     

       
73
       
 
       
	for i, label := range labels {

     

       
74
       
 
       
		remaining_labels := strings.Join(labels[i:], ".")

     

       
75
       
 
       


     

       
76
       
 
       
		if offset, found := (*offsets)[remaining_labels]; found {

     

       
77
       
-
       
			pointer := 0xC000 | uint16(offset)

     

       
78
       
-
       
			bytes = binary.BigEndian.AppendUint16(bytes, pointer)

     

       
79
       
-
       


     

       
80
       
-
       
			return bytes

     

       
81
       
 
       
		}

     

       
82
       
 
       


     

       
0
       
 
       

     

       
83
       
 
       
		bytes = append(bytes, uint8(len(label)))

     

       
84
       
 
       
		bytes = append(bytes, []byte(label)...)

     

       
85
       
-
       


     

       
86
       
-
       
		(*offsets)[remaining_labels] = pos

     

       
87
       
-
       
		pos += 1 + uint8(len(label))

     

       
88
       
 
       
	}

     

       
89
       
 
       


     

       
90
       
-
       
	bytes = append(bytes, 0)

     

       
91
       
-
       
	return bytes

     

       
92
       
 
       
}

     

···

       
66
       
 
       
}

     

       
67
       
 
       


     

       
68
       
 
       
// encode_domain returns the bytes of the input bytes appened with the encoded domain name.

     

       
69
       
+
       
func encode_domain(bytes []byte, domain_name string, offsets *map[string]uint16) []byte {

     

       
70
       
+
       
	pos := uint16(len(bytes))

     

       
71
       
 
       


     

       
72
       
 
       
	labels := strings.Split(domain_name, ".")

     

       
73
       
 
       
	for i, label := range labels {

     

       
74
       
 
       
		remaining_labels := strings.Join(labels[i:], ".")

     

       
75
       
 
       


     

       
76
       
 
       
		if offset, found := (*offsets)[remaining_labels]; found {

     

       
77
       
+
       
			pointer := 0xC000 | offset

     

       
78
       
+
       
			return binary.BigEndian.AppendUint16(bytes, pointer)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
79
       
 
       
		}

     

       
80
       
 
       


     

       
81
       
+
       
		(*offsets)[remaining_labels] = pos

     

       
82
       
 
       
		bytes = append(bytes, uint8(len(label)))

     

       
83
       
 
       
		bytes = append(bytes, []byte(label)...)

     

       
84
       
+
       
		pos += 1 + uint16(len(label))

     

       
0
       
 
       

     

       
0
       
 
       

     

       
85
       
 
       
	}

     

       
86
       
 
       


     

       
87
       
+
       
	return append(bytes, 0)

     

       
0
       
 
       

     

       
88
       
 
       
}

     

···

       
2
       
 
       


     

       
3
       
 
       
import (

     

       
4
       
 
       
	"testing"

     

       
0
       
 
       

     

       
0
       
 
       

     

       
5
       
 
       
)

     

       
6
       
 
       


     

       
7
       
 
       
func TestDecodeDomain(t *testing.T) {

     
···

       
10
       
 
       
	}

     

       
11
       
 
       


     

       
12
       
 
       
	domain, offset, err := decode_domain(buf, 0)

     

       
13
       
-
       
	assert_eq(t, "com", domain)

     

       
14
       
-
       
	assert_eq(t, 5, offset)

     

       
15
       
-
       
	assert_no_error(t, err)

     

       
16
       
 
       
}

     

       
17
       
 
       


     

       
18
       
 
       
func TestDecodeDomainWithCompression(t *testing.T) {

     
···

       
21
       
 
       
	}

     

       
22
       
 
       


     

       
23
       
 
       
	domain, offset, err := decode_domain(buf, 5)

     

       
24
       
-
       
	assert_eq(t, "c.com", domain)

     

       
25
       
-
       
	assert_eq(t, 9, offset)

     

       
26
       
-
       
	assert_no_error(t, err)

     

       
27
       
 
       
}

     

       
28
       
 
       


     

       
29
       
 
       
func TestDecodeDomainWithCompressionLoop(t *testing.T) {

     
···

       
32
       
 
       
	}

     

       
33
       
 
       


     

       
34
       
 
       
	domain, offset, err := decode_domain(buf, 0)

     

       
35
       
-
       
	assert_eq(t, "", domain)

     

       
36
       
-
       
	assert_eq(t, 6, offset)

     

       
37
       
-
       
	assert_error(t, err)

     

       
38
       
 
       
}

     

       
39
       
 
       


     

       
40
       
 
       
func FuzzDecodeDomain(f *testing.F) {

     

···

       
2
       
 
       


     

       
3
       
 
       
import (

     

       
4
       
 
       
	"testing"

     

       
5
       
+
       


     

       
6
       
+
       
	"github.com/stretchr/testify/assert"

     

       
7
       
 
       
)

     

       
8
       
 
       


     

       
9
       
 
       
func TestDecodeDomain(t *testing.T) {

     
···

       
12
       
 
       
	}

     

       
13
       
 
       


     

       
14
       
 
       
	domain, offset, err := decode_domain(buf, 0)

     

       
15
       
+
       
	assert.Equal(t, "com", domain)

     

       
16
       
+
       
	assert.Equal(t, 5, offset)

     

       
17
       
+
       
	assert.NoError(t, err)

     

       
18
       
 
       
}

     

       
19
       
 
       


     

       
20
       
 
       
func TestDecodeDomainWithCompression(t *testing.T) {

     
···

       
23
       
 
       
	}

     

       
24
       
 
       


     

       
25
       
 
       
	domain, offset, err := decode_domain(buf, 5)

     

       
26
       
+
       
	assert.Equal(t, "c.com", domain)

     

       
27
       
+
       
	assert.Equal(t, 9, offset)

     

       
28
       
+
       
	assert.NoError(t, err)

     

       
29
       
 
       
}

     

       
30
       
 
       


     

       
31
       
 
       
func TestDecodeDomainWithCompressionLoop(t *testing.T) {

     
···

       
34
       
 
       
	}

     

       
35
       
 
       


     

       
36
       
 
       
	domain, offset, err := decode_domain(buf, 0)

     

       
37
       
+
       
	assert.Equal(t, "", domain)

     

       
38
       
+
       
	assert.Equal(t, 6, offset)

     

       
39
       
+
       
	assert.Error(t, err)

     

       
40
       
 
       
}

     

       
41
       
 
       


     

       
42
       
 
       
func FuzzDecodeDomain(f *testing.F) {

     

···

       
1
       
 
       
module code.kiri.systems/kiri/magna

     

       
2
       
 
       


     

       
3
       
 
       
go 1.22.3

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

···

       
1
       
 
       
module code.kiri.systems/kiri/magna

     

       
2
       
 
       


     

       
3
       
 
       
go 1.22.3

     

       
4
       
+
       


     

       
5
       
+
       
require github.com/stretchr/testify v1.9.0

     

       
6
       
+
       


     

       
7
       
+
       
require (

     

       
8
       
+
       
	github.com/davecgh/go-spew v1.1.1 // indirect

     

       
9
       
+
       
	github.com/pmezard/go-difflib v1.0.0 // indirect

     

       
10
       
+
       
	gopkg.in/yaml.v3 v3.0.1 // indirect

     

       
11
       
+
       
)

     

···

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

···

       
1
       
+
       
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=

     

       
2
       
+
       
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=

     

       
3
       
+
       
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=

     

       
4
       
+
       
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=

     

       
5
       
+
       
github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=

     

       
6
       
+
       
github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=

     

       
7
       
+
       
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=

     

       
8
       
+
       
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=

     

       
9
       
+
       
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=

     

       
10
       
+
       
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

     

···

       
1
       
 
       
package magna

     

       
2
       
 
       


     

       
3
       
 
       
import (

     

       
4
       
-
       
	"reflect"

     

       
5
       
 
       
	"testing"

     

       
6
       
-
       
)

     

       
7
       
 
       


     

       
8
       
-
       
func assert_eq(t *testing.T, expected any, actual any) {

     

       
9
       
-
       
	if reflect.TypeOf(expected) != reflect.TypeOf(actual) {

     

       
10
       
-
       
		t.Errorf("expected type: %T\t actual type: %T\n", expected, actual)

     

       
11
       
-
       
	}

     

       
12
       
-
       


     

       
13
       
-
       
	if expected != actual {

     

       
14
       
-
       
		t.Fatalf("expected: %#v\t actual: %#v\n", expected, actual)

     

       
15
       
-
       
	}

     

       
16
       
-
       
}

     

       
17
       
-
       


     

       
18
       
-
       
func assert_no_error(t *testing.T, err error) {

     

       
19
       
-
       
	if err != nil {

     

       
20
       
-
       
		t.Fatalf("err is not nil: %v\n", err)

     

       
21
       
-
       
	}

     

       
22
       
-
       
}

     

       
23
       
-
       


     

       
24
       
-
       
func assert_error(t *testing.T, err error) {

     

       
25
       
-
       
	if err == nil {

     

       
26
       
-
       
		t.Fatalf("err is not nil: %v\n", err)

     

       
27
       
-
       
	}

     

       
28
       
-
       
}

     

       
29
       
 
       


     

       
30
       
 
       
func TestHeaderDecode(t *testing.T) {

     

       
31
       
 
       
	bytes := []byte{

     
···

       
47
       
 
       
		t.Errorf("offset should be 12 not %v\n", offset)

     

       
48
       
 
       
	}

     

       
49
       
 
       


     

       
50
       
-
       
	assert_eq(t, header.ID, uint16(258))

     

       
51
       
-
       
	assert_eq(t, header.QR, true)

     

       
52
       
-
       
	assert_eq(t, header.OPCode, OPCode(5))

     

       
53
       
-
       
	assert_eq(t, header.AA, false)

     

       
54
       
-
       
	assert_eq(t, header.TC, true)

     

       
55
       
-
       
	assert_eq(t, header.RD, false)

     

       
56
       
-
       
	assert_eq(t, header.RA, true)

     

       
57
       
-
       
	assert_eq(t, header.Z, uint8(0b010))

     

       
58
       
-
       
	assert_eq(t, header.RCode, RCode(0b1010))

     

       
59
       
-
       
	assert_eq(t, header.QDCount, uint16(1))

     

       
60
       
-
       
	assert_eq(t, header.ANCount, uint16(2))

     

       
61
       
-
       
	assert_eq(t, header.NSCount, uint16(3))

     

       
62
       
-
       
	assert_eq(t, header.ARCount, uint16(4))

     

       
63
       
 
       
}

     

       
64
       
 
       


     

       
65
       
 
       
func TestHeaderEncode(t *testing.T) {

     
···

       
74
       
 
       


     

       
75
       
 
       
	var header Header

     

       
76
       
 
       
	_, err := header.Decode(bytes, 0)

     

       
77
       
-
       
	assert_no_error(t, err)

     

       
78
       
 
       


     

       
79
       
 
       
	actual := header.Encode()

     

       
80
       
-
       
	for i := 0; i < len(bytes); i++ {

     

       
81
       
-
       
		if bytes[i] != actual[i] {

     

       
82
       
-
       
			t.Fatal(bytes, actual)

     

       
83
       
-
       
		}

     

       
84
       
-
       
	}

     

       
85
       
 
       
}

     

       
86
       
 
       


     

       
87
       
 
       
func FuzzDecodeHeader(f *testing.F) {

     

···

       
1
       
 
       
package magna

     

       
2
       
 
       


     

       
3
       
 
       
import (

     

       
0
       
 
       

     

       
4
       
 
       
	"testing"

     

       
0
       
 
       

     

       
5
       
 
       


     

       
6
       
+
       
	"github.com/stretchr/testify/assert"

     

       
7
       
+
       
)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
8
       
 
       


     

       
9
       
 
       
func TestHeaderDecode(t *testing.T) {

     

       
10
       
 
       
	bytes := []byte{

     
···

       
26
       
 
       
		t.Errorf("offset should be 12 not %v\n", offset)

     

       
27
       
 
       
	}

     

       
28
       
 
       


     

       
29
       
+
       
	assert.Equal(t, header.ID, uint16(258))

     

       
30
       
+
       
	assert.Equal(t, header.QR, true)

     

       
31
       
+
       
	assert.Equal(t, header.OPCode, OPCode(5))

     

       
32
       
+
       
	assert.Equal(t, header.AA, false)

     

       
33
       
+
       
	assert.Equal(t, header.TC, true)

     

       
34
       
+
       
	assert.Equal(t, header.RD, false)

     

       
35
       
+
       
	assert.Equal(t, header.RA, true)

     

       
36
       
+
       
	assert.Equal(t, header.Z, uint8(0b010))

     

       
37
       
+
       
	assert.Equal(t, header.RCode, RCode(0b1010))

     

       
38
       
+
       
	assert.Equal(t, header.QDCount, uint16(1))

     

       
39
       
+
       
	assert.Equal(t, header.ANCount, uint16(2))

     

       
40
       
+
       
	assert.Equal(t, header.NSCount, uint16(3))

     

       
41
       
+
       
	assert.Equal(t, header.ARCount, uint16(4))

     

       
42
       
 
       
}

     

       
43
       
 
       


     

       
44
       
 
       
func TestHeaderEncode(t *testing.T) {

     
···

       
53
       
 
       


     

       
54
       
 
       
	var header Header

     

       
55
       
 
       
	_, err := header.Decode(bytes, 0)

     

       
56
       
+
       
	assert.NoError(t, err)

     

       
57
       
 
       


     

       
58
       
 
       
	actual := header.Encode()

     

       
59
       
+
       
	assert.Equal(t, bytes, actual)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
60
       
 
       
}

     

       
61
       
 
       


     

       
62
       
 
       
func FuzzDecodeHeader(f *testing.F) {

     

···

       
53
       
 
       
// Encode encodes a message to a DNS packet.

     

       
54
       
 
       
// TODO: set truncation bit if over 512 and udp is protocol

     

       
55
       
 
       
func (m *Message) Encode() []byte {

     

       
56
       
-
       
	m.offsets = make(map[string]uint8)

     

       
57
       
 
       
	bytes := m.Header.Encode()

     

       
58
       
 
       


     

       
59
       
 
       
	for _, question := range m.Question {

     

···

       
53
       
 
       
// Encode encodes a message to a DNS packet.

     

       
54
       
 
       
// TODO: set truncation bit if over 512 and udp is protocol

     

       
55
       
 
       
func (m *Message) Encode() []byte {

     

       
56
       
+
       
	m.offsets = make(map[string]uint16)

     

       
57
       
 
       
	bytes := m.Header.Encode()

     

       
58
       
 
       


     

       
59
       
 
       
	for _, question := range m.Question {

     

···

       
2
       
 
       


     

       
3
       
 
       
import (

     

       
4
       
 
       
	"testing"

     

       
0
       
 
       

     

       
0
       
 
       

     

       
5
       
 
       
)

     

       
6
       
 
       


     

       
7
       
 
       
func TestMessageDecode(t *testing.T) {

     
···

       
14
       
 
       


     

       
15
       
 
       
	var msg Message

     

       
16
       
 
       
	msg.Decode(bytes)

     

       
17
       
-
       
	assert_eq(t, uint16(0x8e19), msg.Header.ID)

     

       
18
       
-
       
	assert_eq(t, true, msg.Header.QR)

     

       
19
       
-
       
	assert_eq(t, OPCode(0), msg.Header.OPCode)

     

       
20
       
-
       
	assert_eq(t, false, msg.Header.AA)

     

       
21
       
-
       
	assert_eq(t, false, msg.Header.TC)

     

       
22
       
-
       
	assert_eq(t, true, msg.Header.RD)

     

       
23
       
-
       
	assert_eq(t, true, msg.Header.RA)

     

       
24
       
-
       
	assert_eq(t, uint8(0), msg.Header.Z)

     

       
25
       
-
       
	assert_eq(t, RCode(0), msg.Header.RCode)

     

       
26
       
-
       
	assert_eq(t, uint16(1), msg.Header.QDCount)

     

       
27
       
-
       
	assert_eq(t, uint16(1), msg.Header.ANCount)

     

       
28
       
-
       
	assert_eq(t, uint16(0), msg.Header.NSCount)

     

       
29
       
-
       
	assert_eq(t, uint16(0), msg.Header.ARCount)

     

       
30
       
 
       


     

       
31
       
-
       
	assert_eq(t, 1, len(msg.Question))

     

       
32
       
 
       


     

       
33
       
 
       
	question := msg.Question[0]

     

       
34
       
-
       
	assert_eq(t, "news.ycombinator.com", question.QName)

     

       
35
       
-
       
	assert_eq(t, DNSType(1), question.QType)

     

       
36
       
-
       
	assert_eq(t, DNSClass(1), question.QClass)

     

       
37
       
 
       


     

       
38
       
-
       
	assert_eq(t, 1, len(msg.Answer))

     

       
39
       
 
       
	answer := msg.Answer[0]

     

       
40
       
-
       
	assert_eq(t, answer.Name, "news.ycombinator.com")

     

       
41
       
-
       
	assert_eq(t, DNSType(1), answer.RType)

     

       
42
       
-
       
	assert_eq(t, DNSClass(1), answer.RClass)

     

       
43
       
-
       
	assert_eq(t, uint32(1), answer.TTL)

     

       
44
       
-
       
	assert_eq(t, uint16(4), answer.RDLength)

     

       
45
       
 
       
}

     

       
46
       
 
       


     

       
47
       
 
       
func TestMessageDecodeWithU14Offset(t *testing.T) {

     
···

       
116
       
 
       
	// assert_no_error(t, err)

     

       
117
       
 
       


     

       
118
       
 
       
	// Header Section

     

       
119
       
-
       
	assert_eq(t, uint16(0x0ec3), msg.Header.ID)

     

       
120
       
-
       
	assert_eq(t, true, msg.Header.QR)

     

       
121
       
-
       
	assert_eq(t, QUERY, msg.Header.OPCode)

     

       
122
       
-
       
	assert_eq(t, false, msg.Header.AA)

     

       
123
       
-
       
	assert_eq(t, false, msg.Header.TC)

     

       
124
       
-
       
	assert_eq(t, false, msg.Header.RD)

     

       
125
       
-
       
	assert_eq(t, false, msg.Header.RA)

     

       
126
       
-
       
	assert_eq(t, uint8(0), msg.Header.Z)

     

       
127
       
-
       
	assert_eq(t, NOERROR, msg.Header.RCode)

     

       
128
       
-
       
	assert_eq(t, uint16(1), msg.Header.QDCount)

     

       
129
       
-
       
	assert_eq(t, uint16(0), msg.Header.ANCount)

     

       
130
       
-
       
	assert_eq(t, uint16(13), msg.Header.NSCount)

     

       
131
       
-
       
	assert_eq(t, uint16(14), msg.Header.ARCount)

     

       
132
       
 
       


     

       
133
       
 
       
	// Query Section

     

       
134
       
-
       
	assert_eq(t, 1, len(msg.Question))

     

       
135
       
 
       
	question := msg.Question[0]

     

       
136
       
-
       
	assert_eq(t, "ns-372.awsdns-46.com", question.QName)

     

       
137
       
-
       
	assert_eq(t, AType, question.QType)

     

       
138
       
-
       
	assert_eq(t, IN, question.QClass)

     

       
139
       
 
       


     

       
140
       
-
       
	assert_eq(t, 13, len(msg.Authority))

     

       
141
       
-
       
	assert_eq(t, 14, len(msg.Additional))

     

       
142
       
 
       
}

     

       
143
       
 
       


     

       
144
       
 
       
func TestMessageEncode(t *testing.T) {

     
···

       
151
       
 
       


     

       
152
       
 
       
	var msg Message

     

       
153
       
 
       
	err := msg.Decode(bytes)

     

       
154
       
-
       
	assert_no_error(t, err)

     

       
155
       
 
       


     

       
156
       
 
       
	actual := msg.Encode()

     

       
157
       
-
       
	for i := 0; i < len(bytes); i++ {

     

       
158
       
-
       
		if bytes[i] != actual[i] {

     

       
159
       
-
       
			t.Fatal(bytes, actual)

     

       
160
       
-
       
		}

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
161
       
 
       
	}

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
162
       
 
       
}

     

       
163
       
 
       


     

       
164
       
 
       
func FuzzDecodeMessage(f *testing.F) {

     

···

       
2
       
 
       


     

       
3
       
 
       
import (

     

       
4
       
 
       
	"testing"

     

       
5
       
+
       


     

       
6
       
+
       
	"github.com/stretchr/testify/assert"

     

       
7
       
 
       
)

     

       
8
       
 
       


     

       
9
       
 
       
func TestMessageDecode(t *testing.T) {

     
···

       
16
       
 
       


     

       
17
       
 
       
	var msg Message

     

       
18
       
 
       
	msg.Decode(bytes)

     

       
19
       
+
       
	assert.Equal(t, uint16(0x8e19), msg.Header.ID)

     

       
20
       
+
       
	assert.Equal(t, true, msg.Header.QR)

     

       
21
       
+
       
	assert.Equal(t, OPCode(0), msg.Header.OPCode)

     

       
22
       
+
       
	assert.Equal(t, false, msg.Header.AA)

     

       
23
       
+
       
	assert.Equal(t, false, msg.Header.TC)

     

       
24
       
+
       
	assert.Equal(t, true, msg.Header.RD)

     

       
25
       
+
       
	assert.Equal(t, true, msg.Header.RA)

     

       
26
       
+
       
	assert.Equal(t, uint8(0), msg.Header.Z)

     

       
27
       
+
       
	assert.Equal(t, RCode(0), msg.Header.RCode)

     

       
28
       
+
       
	assert.Equal(t, uint16(1), msg.Header.QDCount)

     

       
29
       
+
       
	assert.Equal(t, uint16(1), msg.Header.ANCount)

     

       
30
       
+
       
	assert.Equal(t, uint16(0), msg.Header.NSCount)

     

       
31
       
+
       
	assert.Equal(t, uint16(0), msg.Header.ARCount)

     

       
32
       
 
       


     

       
33
       
+
       
	assert.Equal(t, 1, len(msg.Question))

     

       
34
       
 
       


     

       
35
       
 
       
	question := msg.Question[0]

     

       
36
       
+
       
	assert.Equal(t, "news.ycombinator.com", question.QName)

     

       
37
       
+
       
	assert.Equal(t, DNSType(1), question.QType)

     

       
38
       
+
       
	assert.Equal(t, DNSClass(1), question.QClass)

     

       
39
       
 
       


     

       
40
       
+
       
	assert.Equal(t, 1, len(msg.Answer))

     

       
41
       
 
       
	answer := msg.Answer[0]

     

       
42
       
+
       
	assert.Equal(t, answer.Name, "news.ycombinator.com")

     

       
43
       
+
       
	assert.Equal(t, DNSType(1), answer.RType)

     

       
44
       
+
       
	assert.Equal(t, DNSClass(1), answer.RClass)

     

       
45
       
+
       
	assert.Equal(t, uint32(1), answer.TTL)

     

       
46
       
+
       
	assert.Equal(t, uint16(4), answer.RDLength)

     

       
47
       
 
       
}

     

       
48
       
 
       


     

       
49
       
 
       
func TestMessageDecodeWithU14Offset(t *testing.T) {

     
···

       
118
       
 
       
	// assert_no_error(t, err)

     

       
119
       
 
       


     

       
120
       
 
       
	// Header Section

     

       
121
       
+
       
	assert.Equal(t, uint16(0x0ec3), msg.Header.ID)

     

       
122
       
+
       
	assert.Equal(t, true, msg.Header.QR)

     

       
123
       
+
       
	assert.Equal(t, QUERY, msg.Header.OPCode)

     

       
124
       
+
       
	assert.Equal(t, false, msg.Header.AA)

     

       
125
       
+
       
	assert.Equal(t, false, msg.Header.TC)

     

       
126
       
+
       
	assert.Equal(t, false, msg.Header.RD)

     

       
127
       
+
       
	assert.Equal(t, false, msg.Header.RA)

     

       
128
       
+
       
	assert.Equal(t, uint8(0), msg.Header.Z)

     

       
129
       
+
       
	assert.Equal(t, NOERROR, msg.Header.RCode)

     

       
130
       
+
       
	assert.Equal(t, uint16(1), msg.Header.QDCount)

     

       
131
       
+
       
	assert.Equal(t, uint16(0), msg.Header.ANCount)

     

       
132
       
+
       
	assert.Equal(t, uint16(13), msg.Header.NSCount)

     

       
133
       
+
       
	assert.Equal(t, uint16(14), msg.Header.ARCount)

     

       
134
       
 
       


     

       
135
       
 
       
	// Query Section

     

       
136
       
+
       
	assert.Equal(t, 1, len(msg.Question))

     

       
137
       
 
       
	question := msg.Question[0]

     

       
138
       
+
       
	assert.Equal(t, "ns-372.awsdns-46.com", question.QName)

     

       
139
       
+
       
	assert.Equal(t, AType, question.QType)

     

       
140
       
+
       
	assert.Equal(t, IN, question.QClass)

     

       
141
       
 
       


     

       
142
       
+
       
	assert.Equal(t, 13, len(msg.Authority))

     

       
143
       
+
       
	assert.Equal(t, 14, len(msg.Additional))

     

       
144
       
 
       
}

     

       
145
       
 
       


     

       
146
       
 
       
func TestMessageEncode(t *testing.T) {

     
···

       
153
       
 
       


     

       
154
       
 
       
	var msg Message

     

       
155
       
 
       
	err := msg.Decode(bytes)

     

       
156
       
+
       
	assert.NoError(t, err)

     

       
157
       
 
       


     

       
158
       
 
       
	actual := msg.Encode()

     

       
159
       
+
       
	assert.Equal(t, bytes, actual)

     

       
160
       
+
       
}

     

       
161
       
+
       


     

       
162
       
+
       
func TestMessageEncode2(t *testing.T) {

     

       
163
       
+
       
	bytes := []byte{

     

       
164
       
+
       
		0xfc, 0xa9, 0x81, 0x80, 0x00, 0x01, 0x00, 0x05,

     

       
165
       
+
       
		0x00, 0x00, 0x00, 0x00, 0x03, 0x6f, 0x6c, 0x64,

     

       
166
       
+
       
		0x06, 0x72, 0x65, 0x64, 0x64, 0x69, 0x74, 0x03,

     

       
167
       
+
       
		0x63, 0x6f, 0x6d, 0x00, 0x00, 0x01, 0x00, 0x01,

     

       
168
       
+
       
		0xc0, 0x0c, 0x00, 0x05, 0x00, 0x01, 0x00, 0x00,

     

       
169
       
+
       
		0x2a, 0x17, 0x00, 0x17, 0x06, 0x72, 0x65, 0x64,

     

       
170
       
+
       
		0x64, 0x69, 0x74, 0x03, 0x6d, 0x61, 0x70, 0x06,

     

       
171
       
+
       
		0x66, 0x61, 0x73, 0x74, 0x6c, 0x79, 0x03, 0x6e,

     

       
172
       
+
       
		0x65, 0x74, 0x00, 0xc0, 0x2c, 0x00, 0x01, 0x00,

     

       
173
       
+
       
		0x01, 0x00, 0x00, 0x00, 0x23, 0x00, 0x04, 0x97,

     

       
174
       
+
       
		0x65, 0x01, 0x8c, 0xc0, 0x2c, 0x00, 0x01, 0x00,

     

       
175
       
+
       
		0x01, 0x00, 0x00, 0x00, 0x23, 0x00, 0x04, 0x97,

     

       
176
       
+
       
		0x65, 0xc1, 0x8c, 0xc0, 0x2c, 0x00, 0x01, 0x00,

     

       
177
       
+
       
		0x01, 0x00, 0x00, 0x00, 0x23, 0x00, 0x04, 0x97,

     

       
178
       
+
       
		0x65, 0x41, 0x8c, 0xc0, 0x2c, 0x00, 0x01, 0x00,

     

       
179
       
+
       
		0x01, 0x00, 0x00, 0x00, 0x23, 0x00, 0x04, 0x97,

     

       
180
       
+
       
		0x65, 0x81, 0x8c,

     

       
181
       
 
       
	}

     

       
182
       
+
       


     

       
183
       
+
       
	var msg Message

     

       
184
       
+
       
	err := msg.Decode(bytes)

     

       
185
       
+
       
	assert.NoError(t, err)

     

       
186
       
+
       


     

       
187
       
+
       
	actual := msg.Encode()

     

       
188
       
+
       
	assert.Equal(t, bytes, actual)

     

       
189
       
 
       
}

     

       
190
       
 
       


     

       
191
       
 
       
func FuzzDecodeMessage(f *testing.F) {

     

···

       
26
       
 
       
}

     

       
27
       
 
       


     

       
28
       
 
       
// Encode serializes a Question into bytes, using a map to handle domain name compression offsets.

     

       
29
       
-
       
func (q *Question) Encode(bytes []byte, offsets *map[string]uint8) []byte {

     

       
30
       
 
       
	bytes = encode_domain(bytes, q.QName, offsets)

     

       
31
       
 
       
	bytes = binary.BigEndian.AppendUint16(bytes, uint16(q.QType))

     

       
32
       
 
       
	bytes = binary.BigEndian.AppendUint16(bytes, uint16(q.QClass))

     

···

       
26
       
 
       
}

     

       
27
       
 
       


     

       
28
       
 
       
// Encode serializes a Question into bytes, using a map to handle domain name compression offsets.

     

       
29
       
+
       
func (q *Question) Encode(bytes []byte, offsets *map[string]uint16) []byte {

     

       
30
       
 
       
	bytes = encode_domain(bytes, q.QName, offsets)

     

       
31
       
 
       
	bytes = binary.BigEndian.AppendUint16(bytes, uint16(q.QType))

     

       
32
       
 
       
	bytes = binary.BigEndian.AppendUint16(bytes, uint16(q.QClass))

     

···

       
17
       
 
       
	return offset, err

     

       
18
       
 
       
}

     

       
19
       
 
       


     

       
20
       
-
       
func (a *A) Encode(bytes []byte, offsets *map[string]uint8) []byte {

     

       
21
       
 
       
	return append(bytes, a.Address.To4()...)

     

       
22
       
 
       
}

     

       
23
       
 
       


     
···

       
35
       
 
       
	return offset, err

     

       
36
       
 
       
}

     

       
37
       
 
       


     

       
38
       
-
       
func (ns *NS) Encode(bytes []byte, offsets *map[string]uint8) []byte {

     

       
39
       
 
       
	return encode_domain(bytes, ns.NSDName, offsets)

     

       
40
       
 
       
}

     

       
41
       
 
       


     
···

       
53
       
 
       
	return offset, err

     

       
54
       
 
       
}

     

       
55
       
 
       


     

       
56
       
-
       
func (md *MD) Encode(bytes []byte, offsets *map[string]uint8) []byte {

     

       
57
       
 
       
	return encode_domain(bytes, md.MADName, offsets)

     

       
58
       
 
       
}

     

       
59
       
 
       


     
···

       
71
       
 
       
	return offset, err

     

       
72
       
 
       
}

     

       
73
       
 
       


     

       
74
       
-
       
func (mf *MF) Encode(bytes []byte, offsets *map[string]uint8) []byte {

     

       
75
       
 
       
	return encode_domain(bytes, mf.MADName, offsets)

     

       
76
       
 
       
}

     

       
77
       
 
       


     
···

       
89
       
 
       
	return offset, err

     

       
90
       
 
       
}

     

       
91
       
 
       


     

       
92
       
-
       
func (c *CNAME) Encode(bytes []byte, offsets *map[string]uint8) []byte {

     

       
93
       
 
       
	return encode_domain(bytes, c.CName, offsets)

     

       
94
       
 
       
}

     

       
95
       
 
       


     
···

       
137
       
 
       
	return offset, err

     

       
138
       
 
       
}

     

       
139
       
 
       


     

       
140
       
-
       
func (soa *SOA) Encode(bytes []byte, offsets *map[string]uint8) []byte {

     

       
141
       
 
       
	bytes = append(bytes, encode_domain(bytes, soa.MName, offsets)...)

     

       
142
       
 
       
	bytes = append(bytes, encode_domain(bytes, soa.RName, offsets)...)

     

       
143
       
 
       
	bytes = binary.BigEndian.AppendUint32(bytes, soa.Serial)

     
···

       
163
       
 
       
	return offset, err

     

       
164
       
 
       
}

     

       
165
       
 
       


     

       
166
       
-
       
func (mb *MB) Encode(bytes []byte, offsets *map[string]uint8) []byte {

     

       
167
       
 
       
	return encode_domain(bytes, mb.MADName, offsets)

     

       
168
       
 
       
}

     

       
169
       
 
       


     
···

       
181
       
 
       
	return offset, err

     

       
182
       
 
       
}

     

       
183
       
 
       


     

       
184
       
-
       
func (mg *MG) Encode(bytes []byte, offsets *map[string]uint8) []byte {

     

       
185
       
 
       
	return encode_domain(bytes, mg.MGMName, offsets)

     

       
186
       
 
       
}

     

       
187
       
 
       


     
···

       
199
       
 
       
	return offset, err

     

       
200
       
 
       
}

     

       
201
       
 
       


     

       
202
       
-
       
func (mr *MR) Encode(bytes []byte, offsets *map[string]uint8) []byte {

     

       
203
       
 
       
	return encode_domain(bytes, mr.NEWName, offsets)

     

       
204
       
 
       
}

     

       
205
       
 
       


     
···

       
217
       
 
       
	return offset, err

     

       
218
       
 
       
}

     

       
219
       
 
       


     

       
220
       
-
       
func (null *NULL) Encode(bytes []byte, offsets *map[string]uint8) []byte {

     

       
221
       
 
       
	return append(bytes, null.Anything...)

     

       
222
       
 
       
}

     

       
223
       
 
       


     
···

       
246
       
 
       
	return offset, err

     

       
247
       
 
       
}

     

       
248
       
 
       


     

       
249
       
-
       
func (wks *WKS) Encode(bytes []byte, offsets *map[string]uint8) []byte {

     

       
250
       
 
       
	bytes = append(bytes, wks.Address.To4()...)

     

       
251
       
 
       
	bytes = append(bytes, wks.Protocol)

     

       
252
       
 
       
	bytes = append(bytes, wks.BitMap...)

     
···

       
268
       
 
       
	return offset, err

     

       
269
       
 
       
}

     

       
270
       
 
       


     

       
271
       
-
       
func (ptr *PTR) Encode(bytes []byte, offsets *map[string]uint8) []byte {

     

       
272
       
 
       
	return encode_domain(bytes, ptr.PTRDName, offsets)

     

       
273
       
 
       
}

     

       
274
       
 
       


     
···

       
292
       
 
       
	return offset, err

     

       
293
       
 
       
}

     

       
294
       
 
       


     

       
295
       
-
       
func (hinfo *HINFO) Encode(bytes []byte, offsets *map[string]uint8) []byte {

     

       
296
       
 
       
	bytes = append(bytes, []byte(hinfo.CPU)...)

     

       
297
       
 
       
	bytes = append(bytes, ' ')

     

       
298
       
 
       
	bytes = append(bytes, []byte(hinfo.OS)...)

     
···

       
319
       
 
       
	return offset, err

     

       
320
       
 
       
}

     

       
321
       
 
       


     

       
322
       
-
       
func (minfo *MINFO) Encode(bytes []byte, offsets *map[string]uint8) []byte {

     

       
323
       
 
       
	bytes = encode_domain(bytes, minfo.RMailBx, offsets)

     

       
324
       
 
       
	bytes = encode_domain(bytes, minfo.EMailBx, offsets)

     

       
325
       
 
       


     
···

       
345
       
 
       
	return offset, err

     

       
346
       
 
       
}

     

       
347
       
 
       


     

       
348
       
-
       
func (mx *MX) Encode(bytes []byte, offsets *map[string]uint8) []byte {

     

       
349
       
 
       
	bytes = binary.BigEndian.AppendUint16(bytes, mx.Preference)

     

       
350
       
 
       
	bytes = encode_domain(bytes, mx.Exchange, offsets)

     

       
351
       
 
       


     
···

       
366
       
 
       
	return offset, err

     

       
367
       
 
       
}

     

       
368
       
 
       


     

       
369
       
-
       
func (txt *TXT) Encode(bytes []byte, offsets *map[string]uint8) []byte {

     

       
370
       
 
       
	return append(bytes, []byte(txt.TxtData)...)

     

       
371
       
 
       
}

     

       
372
       
 
       


     
···

       
384
       
 
       
	return offset, err

     

       
385
       
 
       
}

     

       
386
       
 
       


     

       
387
       
-
       
func (r *Reserved) Encode(bytes []byte, offsets *map[string]uint8) []byte {

     

       
388
       
 
       
	return append(bytes, r.Bytes...)

     

       
389
       
 
       
}

     

       
390
       
 
       


     
···

       
470
       
 
       
}

     

       
471
       
 
       


     

       
472
       
 
       
// Encode encdoes a resource record and returns the input bytes appened.

     

       
473
       
-
       
func (r *ResourceRecord) Encode(bytes []byte, offsets *map[string]uint8) []byte {

     

       
474
       
 
       
	bytes = encode_domain(bytes, r.Name, offsets)

     

       
475
       
 
       
	bytes = binary.BigEndian.AppendUint16(bytes, uint16(r.RType))

     

       
476
       
 
       
	bytes = binary.BigEndian.AppendUint16(bytes, uint16(r.RClass))

     

       
477
       
 
       
	bytes = binary.BigEndian.AppendUint32(bytes, r.TTL)

     

       
478
       
 
       


     

       
479
       
-
       
	second_dinner := make([]byte, len(bytes))

     

       
480
       
-
       
	copy(second_dinner, bytes)

     

       
481
       
-
       
	start := len(second_dinner)

     

       
482
       
-
       
	second_dinner = r.RData.Encode(second_dinner, offsets)

     

       
483
       
-
       
	end := len(second_dinner)

     

       
484
       
-
       
	data := second_dinner[start:end]

     

       
485
       
-
       


     

       
486
       
-
       
	bytes = binary.BigEndian.AppendUint16(bytes, uint16(end-start))

     

       
487
       
-
       
	bytes = append(bytes, data...)

     

       
488
       
 
       


     

       
489
       
 
       
	return bytes

     

       
490
       
 
       
}

     

···

       
17
       
 
       
	return offset, err

     

       
18
       
 
       
}

     

       
19
       
 
       


     

       
20
       
+
       
func (a *A) Encode(bytes []byte, offsets *map[string]uint16) []byte {

     

       
21
       
 
       
	return append(bytes, a.Address.To4()...)

     

       
22
       
 
       
}

     

       
23
       
 
       


     
···

       
35
       
 
       
	return offset, err

     

       
36
       
 
       
}

     

       
37
       
 
       


     

       
38
       
+
       
func (ns *NS) Encode(bytes []byte, offsets *map[string]uint16) []byte {

     

       
39
       
 
       
	return encode_domain(bytes, ns.NSDName, offsets)

     

       
40
       
 
       
}

     

       
41
       
 
       


     
···

       
53
       
 
       
	return offset, err

     

       
54
       
 
       
}

     

       
55
       
 
       


     

       
56
       
+
       
func (md *MD) Encode(bytes []byte, offsets *map[string]uint16) []byte {

     

       
57
       
 
       
	return encode_domain(bytes, md.MADName, offsets)

     

       
58
       
 
       
}

     

       
59
       
 
       


     
···

       
71
       
 
       
	return offset, err

     

       
72
       
 
       
}

     

       
73
       
 
       


     

       
74
       
+
       
func (mf *MF) Encode(bytes []byte, offsets *map[string]uint16) []byte {

     

       
75
       
 
       
	return encode_domain(bytes, mf.MADName, offsets)

     

       
76
       
 
       
}

     

       
77
       
 
       


     
···

       
89
       
 
       
	return offset, err

     

       
90
       
 
       
}

     

       
91
       
 
       


     

       
92
       
+
       
func (c *CNAME) Encode(bytes []byte, offsets *map[string]uint16) []byte {

     

       
93
       
 
       
	return encode_domain(bytes, c.CName, offsets)

     

       
94
       
 
       
}

     

       
95
       
 
       


     
···

       
137
       
 
       
	return offset, err

     

       
138
       
 
       
}

     

       
139
       
 
       


     

       
140
       
+
       
func (soa *SOA) Encode(bytes []byte, offsets *map[string]uint16) []byte {

     

       
141
       
 
       
	bytes = append(bytes, encode_domain(bytes, soa.MName, offsets)...)

     

       
142
       
 
       
	bytes = append(bytes, encode_domain(bytes, soa.RName, offsets)...)

     

       
143
       
 
       
	bytes = binary.BigEndian.AppendUint32(bytes, soa.Serial)

     
···

       
163
       
 
       
	return offset, err

     

       
164
       
 
       
}

     

       
165
       
 
       


     

       
166
       
+
       
func (mb *MB) Encode(bytes []byte, offsets *map[string]uint16) []byte {

     

       
167
       
 
       
	return encode_domain(bytes, mb.MADName, offsets)

     

       
168
       
 
       
}

     

       
169
       
 
       


     
···

       
181
       
 
       
	return offset, err

     

       
182
       
 
       
}

     

       
183
       
 
       


     

       
184
       
+
       
func (mg *MG) Encode(bytes []byte, offsets *map[string]uint16) []byte {

     

       
185
       
 
       
	return encode_domain(bytes, mg.MGMName, offsets)

     

       
186
       
 
       
}

     

       
187
       
 
       


     
···

       
199
       
 
       
	return offset, err

     

       
200
       
 
       
}

     

       
201
       
 
       


     

       
202
       
+
       
func (mr *MR) Encode(bytes []byte, offsets *map[string]uint16) []byte {

     

       
203
       
 
       
	return encode_domain(bytes, mr.NEWName, offsets)

     

       
204
       
 
       
}

     

       
205
       
 
       


     
···

       
217
       
 
       
	return offset, err

     

       
218
       
 
       
}

     

       
219
       
 
       


     

       
220
       
+
       
func (null *NULL) Encode(bytes []byte, offsets *map[string]uint16) []byte {

     

       
221
       
 
       
	return append(bytes, null.Anything...)

     

       
222
       
 
       
}

     

       
223
       
 
       


     
···

       
246
       
 
       
	return offset, err

     

       
247
       
 
       
}

     

       
248
       
 
       


     

       
249
       
+
       
func (wks *WKS) Encode(bytes []byte, offsets *map[string]uint16) []byte {

     

       
250
       
 
       
	bytes = append(bytes, wks.Address.To4()...)

     

       
251
       
 
       
	bytes = append(bytes, wks.Protocol)

     

       
252
       
 
       
	bytes = append(bytes, wks.BitMap...)

     
···

       
268
       
 
       
	return offset, err

     

       
269
       
 
       
}

     

       
270
       
 
       


     

       
271
       
+
       
func (ptr *PTR) Encode(bytes []byte, offsets *map[string]uint16) []byte {

     

       
272
       
 
       
	return encode_domain(bytes, ptr.PTRDName, offsets)

     

       
273
       
 
       
}

     

       
274
       
 
       


     
···

       
292
       
 
       
	return offset, err

     

       
293
       
 
       
}

     

       
294
       
 
       


     

       
295
       
+
       
func (hinfo *HINFO) Encode(bytes []byte, offsets *map[string]uint16) []byte {

     

       
296
       
 
       
	bytes = append(bytes, []byte(hinfo.CPU)...)

     

       
297
       
 
       
	bytes = append(bytes, ' ')

     

       
298
       
 
       
	bytes = append(bytes, []byte(hinfo.OS)...)

     
···

       
319
       
 
       
	return offset, err

     

       
320
       
 
       
}

     

       
321
       
 
       


     

       
322
       
+
       
func (minfo *MINFO) Encode(bytes []byte, offsets *map[string]uint16) []byte {

     

       
323
       
 
       
	bytes = encode_domain(bytes, minfo.RMailBx, offsets)

     

       
324
       
 
       
	bytes = encode_domain(bytes, minfo.EMailBx, offsets)

     

       
325
       
 
       


     
···

       
345
       
 
       
	return offset, err

     

       
346
       
 
       
}

     

       
347
       
 
       


     

       
348
       
+
       
func (mx *MX) Encode(bytes []byte, offsets *map[string]uint16) []byte {

     

       
349
       
 
       
	bytes = binary.BigEndian.AppendUint16(bytes, mx.Preference)

     

       
350
       
 
       
	bytes = encode_domain(bytes, mx.Exchange, offsets)

     

       
351
       
 
       


     
···

       
366
       
 
       
	return offset, err

     

       
367
       
 
       
}

     

       
368
       
 
       


     

       
369
       
+
       
func (txt *TXT) Encode(bytes []byte, offsets *map[string]uint16) []byte {

     

       
370
       
 
       
	return append(bytes, []byte(txt.TxtData)...)

     

       
371
       
 
       
}

     

       
372
       
 
       


     
···

       
384
       
 
       
	return offset, err

     

       
385
       
 
       
}

     

       
386
       
 
       


     

       
387
       
+
       
func (r *Reserved) Encode(bytes []byte, offsets *map[string]uint16) []byte {

     

       
388
       
 
       
	return append(bytes, r.Bytes...)

     

       
389
       
 
       
}

     

       
390
       
 
       


     
···

       
470
       
 
       
}

     

       
471
       
 
       


     

       
472
       
 
       
// Encode encdoes a resource record and returns the input bytes appened.

     

       
473
       
+
       
func (r *ResourceRecord) Encode(bytes []byte, offsets *map[string]uint16) []byte {

     

       
474
       
 
       
	bytes = encode_domain(bytes, r.Name, offsets)

     

       
475
       
 
       
	bytes = binary.BigEndian.AppendUint16(bytes, uint16(r.RType))

     

       
476
       
 
       
	bytes = binary.BigEndian.AppendUint16(bytes, uint16(r.RClass))

     

       
477
       
 
       
	bytes = binary.BigEndian.AppendUint32(bytes, r.TTL)

     

       
478
       
 
       


     

       
479
       
+
       
	rdata_start := len(bytes)

     

       
480
       
+
       
	bytes = binary.BigEndian.AppendUint16(bytes, 0)

     

       
481
       
+
       
	bytes = r.RData.Encode(bytes, offsets)

     

       
482
       
+
       
	rdata_length := uint16(len(bytes) - rdata_start - 2)

     

       
483
       
+
       
	binary.BigEndian.PutUint16(bytes[rdata_start:rdata_start+2], rdata_length)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
484
       
 
       


     

       
485
       
 
       
	return bytes

     

       
486
       
 
       
}

     

···

       
173
       
 
       


     

       
174
       
 
       
	// offsets is a map of domains pointing to the seen offset used

     

       
175
       
 
       
	// in domain compression.

     

       
176
       
-
       
	offsets map[string]uint8

     

       
177
       
 
       
}

     

       
178
       
 
       


     

       
179
       
 
       
// A Header represents the metadata information of a DNS packet.

     
···

       
213
       
 
       
//	*map[string]uint8 - map containing labels and offsets for domain name compression

     

       
214
       
 
       
type ResourceRecordData interface {

     

       
215
       
 
       
	Decode([]byte, int, int) (int, error)

     

       
216
       
-
       
	Encode([]byte, *map[string]uint8) []byte

     

       
217
       
 
       
	String() string

     

       
218
       
 
       
}

     

       
219
       
 
       


     

···

       
173
       
 
       


     

       
174
       
 
       
	// offsets is a map of domains pointing to the seen offset used

     

       
175
       
 
       
	// in domain compression.

     

       
176
       
+
       
	offsets map[string]uint16

     

       
177
       
 
       
}

     

       
178
       
 
       


     

       
179
       
 
       
// A Header represents the metadata information of a DNS packet.

     
···

       
213
       
 
       
//	*map[string]uint8 - map containing labels and offsets for domain name compression

     

       
214
       
 
       
type ResourceRecordData interface {

     

       
215
       
 
       
	Decode([]byte, int, int) (int, error)

     

       
216
       
+
       
	Encode([]byte, *map[string]uint16) []byte

     

       
217
       
 
       
	String() string

     

       
218
       
 
       
}

     

       
219
       
 
       


     

···

       
2
       
 
       


     

       
3
       
 
       
import (

     

       
4
       
 
       
	"testing"

     

       
0
       
 
       

     

       
0
       
 
       

     

       
5
       
 
       
)

     

       
6
       
 
       


     

       
7
       
 
       
func TestU8(t *testing.T) {

     
···

       
10
       
 
       
	}

     

       
11
       
 
       


     

       
12
       
 
       
	actual, offset, err := getU8(buf, 0)

     

       
13
       
-
       
	assert_eq(t, uint8(1), actual)

     

       
14
       
-
       
	assert_eq(t, 1, offset)

     

       
15
       
-
       
	assert_no_error(t, err)

     

       
16
       
 
       


     

       
17
       
 
       
	actual, offset, err = getU8(buf, 1)

     

       
18
       
-
       
	assert_eq(t, uint8(0), actual)

     

       
19
       
-
       
	assert_eq(t, 1, offset)

     

       
20
       
-
       
	assert_error(t, err)

     

       
21
       
 
       
}

     

       
22
       
 
       


     

       
23
       
 
       
func TestU16(t *testing.T) {

     
···

       
26
       
 
       
	}

     

       
27
       
 
       


     

       
28
       
 
       
	actual, offset, err := getU16(buf, 0)

     

       
29
       
-
       
	assert_eq(t, uint16(1), actual)

     

       
30
       
-
       
	assert_eq(t, 2, offset)

     

       
31
       
-
       
	assert_no_error(t, err)

     

       
32
       
 
       


     

       
33
       
 
       
	actual, offset, err = getU16(buf, 1)

     

       
34
       
-
       
	assert_eq(t, uint16(0), actual)

     

       
35
       
-
       
	assert_eq(t, 2, offset)

     

       
36
       
-
       
	assert_error(t, err)

     

       
37
       
 
       
}

     

       
38
       
 
       


     

       
39
       
 
       
func TestU32(t *testing.T) {

     
···

       
42
       
 
       
	}

     

       
43
       
 
       


     

       
44
       
 
       
	actual, offset, err := getU32(buf, 0)

     

       
45
       
-
       
	assert_eq(t, uint32(1), actual)

     

       
46
       
-
       
	assert_eq(t, 4, offset)

     

       
47
       
-
       
	assert_no_error(t, err)

     

       
48
       
 
       


     

       
49
       
 
       
	actual, offset, err = getU32(buf, 1)

     

       
50
       
-
       
	assert_eq(t, uint32(0), actual)

     

       
51
       
-
       
	assert_eq(t, 4, offset)

     

       
52
       
-
       
	assert_error(t, err)

     

       
53
       
 
       
}

     

       
54
       
 
       


     

       
55
       
 
       
func TestSlice(t *testing.T) {

     
···

       
58
       
 
       
	}

     

       
59
       
 
       


     

       
60
       
 
       
	actual, offset, err := getSlice(buf, 0, 3)

     

       
61
       
-
       
	assert_eq(t, "blu", string(actual))

     

       
62
       
-
       
	assert_eq(t, 3, offset)

     

       
63
       
-
       
	assert_no_error(t, err)

     

       
64
       
 
       


     

       
65
       
 
       
	actual, offset, err = getSlice(buf, 0, 4)

     

       
66
       
-
       
	assert_eq(t, "", string(actual))

     

       
67
       
-
       
	assert_eq(t, 3, offset)

     

       
68
       
-
       
	assert_error(t, err)

     

       
69
       
 
       
}

     

···

       
2
       
 
       


     

       
3
       
 
       
import (

     

       
4
       
 
       
	"testing"

     

       
5
       
+
       


     

       
6
       
+
       
	"github.com/stretchr/testify/assert"

     

       
7
       
 
       
)

     

       
8
       
 
       


     

       
9
       
 
       
func TestU8(t *testing.T) {

     
···

       
12
       
 
       
	}

     

       
13
       
 
       


     

       
14
       
 
       
	actual, offset, err := getU8(buf, 0)

     

       
15
       
+
       
	assert.Equal(t, uint8(1), actual)

     

       
16
       
+
       
	assert.Equal(t, 1, offset)

     

       
17
       
+
       
	assert.NoError(t, err)

     

       
18
       
 
       


     

       
19
       
 
       
	actual, offset, err = getU8(buf, 1)

     

       
20
       
+
       
	assert.Equal(t, uint8(0), actual)

     

       
21
       
+
       
	assert.Equal(t, 1, offset)

     

       
22
       
+
       
	assert.Error(t, err)

     

       
23
       
 
       
}

     

       
24
       
 
       


     

       
25
       
 
       
func TestU16(t *testing.T) {

     
···

       
28
       
 
       
	}

     

       
29
       
 
       


     

       
30
       
 
       
	actual, offset, err := getU16(buf, 0)

     

       
31
       
+
       
	assert.Equal(t, uint16(1), actual)

     

       
32
       
+
       
	assert.Equal(t, 2, offset)

     

       
33
       
+
       
	assert.NoError(t, err)

     

       
34
       
 
       


     

       
35
       
 
       
	actual, offset, err = getU16(buf, 1)

     

       
36
       
+
       
	assert.Equal(t, uint16(0), actual)

     

       
37
       
+
       
	assert.Equal(t, 2, offset)

     

       
38
       
+
       
	assert.Error(t, err)

     

       
39
       
 
       
}

     

       
40
       
 
       


     

       
41
       
 
       
func TestU32(t *testing.T) {

     
···

       
44
       
 
       
	}

     

       
45
       
 
       


     

       
46
       
 
       
	actual, offset, err := getU32(buf, 0)

     

       
47
       
+
       
	assert.Equal(t, uint32(1), actual)

     

       
48
       
+
       
	assert.Equal(t, 4, offset)

     

       
49
       
+
       
	assert.NoError(t, err)

     

       
50
       
 
       


     

       
51
       
 
       
	actual, offset, err = getU32(buf, 1)

     

       
52
       
+
       
	assert.Equal(t, uint32(0), actual)

     

       
53
       
+
       
	assert.Equal(t, 4, offset)

     

       
54
       
+
       
	assert.Error(t, err)

     

       
55
       
 
       
}

     

       
56
       
 
       


     

       
57
       
 
       
func TestSlice(t *testing.T) {

     
···

       
60
       
 
       
	}

     

       
61
       
 
       


     

       
62
       
 
       
	actual, offset, err := getSlice(buf, 0, 3)

     

       
63
       
+
       
	assert.Equal(t, "blu", string(actual))

     

       
64
       
+
       
	assert.Equal(t, 3, offset)

     

       
65
       
+
       
	assert.NoError(t, err)

     

       
66
       
 
       


     

       
67
       
 
       
	actual, offset, err = getSlice(buf, 0, 4)

     

       
68
       
+
       
	assert.Equal(t, "", string(actual))

     

       
69
       
+
       
	assert.Equal(t, 3, offset)

     

       
70
       
+
       
	assert.Error(t, err)

     

       
71
       
 
       
}