commit 4cec10a50453d9b93cb978c9d95d1840a7cffa95 · seiso.moe/magna

+21

LICENSE

···

       1
       1
       +
       MIT License

     

       2
       2
       +
       

     

       3
       3
       +
       Copyright (c) [2024] [blu]

     

       4
       4
       +
       

     

       5
       5
       +
       Permission is hereby granted, free of charge, to any person obtaining a copy

     

       6
       6
       +
       of this software and associated documentation files (the "Software"), to deal

     

       7
       7
       +
       in the Software without restriction, including without limitation the rights

     

       8
       8
       +
       to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

     

       9
       9
       +
       copies of the Software, and to permit persons to whom the Software is

     

       10
       10
       +
       furnished to do so, subject to the following conditions:

     

       11
       11
       +
       

     

       12
       12
       +
       The above copyright notice and this permission notice shall be included in all

     

       13
       13
       +
       copies or substantial portions of the Software.

     

       14
       14
       +
       

     

       15
       15
       +
       THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

     

       16
       16
       +
       IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

     

       17
       17
       +
       FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

     

       18
       18
       +
       AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

     

       19
       19
       +
       LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

     

       20
       20
       +
       OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

     

       21
       21
       +
       SOFTWARE.

README.md

···

       1
       1
       +
       # Magna

+92

domain_name.go

···

       1
       1
       +
       package magna

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"encoding/binary"

     

       5
       5
       +
       	"strings"

     

       6
       6
       +
       )

     

       7
       7
       +
       

     

       8
       8
       +
       // decode_domain decodes a domain name from a buffer starting at offset.

     

       9
       9
       +
       // It returns the domain name along with the offset and error.

     

       10
       10
       +
       func decode_domain(buf []byte, offset int) (string, int, error) {

     

       11
       11
       +
       	labels := make([]string, 0)

     

       12
       12
       +
       	seen_offsets := make(map[int]struct{})

     

       13
       13
       +
       	has_jumped := false

     

       14
       14
       +
       	prev_offset := 0

     

       15
       15
       +
       

     

       16
       16
       +
       	var length uint8

     

       17
       17
       +
       	var label []byte

     

       18
       18
       +
       	var sec byte

     

       19
       19
       +
       	var err error

     

       20
       20
       +
       	for {

     

       21
       21
       +
       		length, offset, err = getU8(buf, offset)

     

       22
       22
       +
       		if err != nil {

     

       23
       23
       +
       			return "", len(buf), err

     

       24
       24
       +
       		}

     

       25
       25
       +
       

     

       26
       26
       +
       		if length == 0 {

     

       27
       27
       +
       			break

     

       28
       28
       +
       		}

     

       29
       29
       +
       

     

       30
       30
       +
       		if length&0xC0 == 0xC0 {

     

       31
       31
       +
       			sec, offset, err = getU8(buf, offset)

     

       32
       32
       +
       			if err != nil {

     

       33
       33
       +
       				return "", len(buf), err

     

       34
       34
       +
       			}

     

       35
       35
       +
       

     

       36
       36
       +
       			if !has_jumped {

     

       37
       37
       +
       				prev_offset = offset

     

       38
       38
       +
       				has_jumped = true

     

       39
       39
       +
       			}

     

       40
       40
       +
       

     

       41
       41
       +
       			if _, found := seen_offsets[offset]; found {

     

       42
       42
       +
       				return "", len(buf), &DomainCompressionError{}

     

       43
       43
       +
       			}

     

       44
       44
       +
       

     

       45
       45
       +
       			seen_offsets[offset] = struct{}{}

     

       46
       46
       +
       			offset = int(sec)

     

       47
       47
       +
       		} else {

     

       48
       48
       +
       			if length > 63 {

     

       49
       49
       +
       				return "", len(buf), &InvalidLabelError{Length: int(length)}

     

       50
       50
       +
       			}

     

       51
       51
       +
       

     

       52
       52
       +
       			label, offset, err = getSlice(buf, offset, int(length))

     

       53
       53
       +
       			if err != nil {

     

       54
       54
       +
       				return "", len(buf), err

     

       55
       55
       +
       			}

     

       56
       56
       +
       

     

       57
       57
       +
       			labels = append(labels, string(label))

     

       58
       58
       +
       		}

     

       59
       59
       +
       	}

     

       60
       60
       +
       

     

       61
       61
       +
       	if has_jumped {

     

       62
       62
       +
       		offset = prev_offset

     

       63
       63
       +
       	}

     

       64
       64
       +
       

     

       65
       65
       +
       	return strings.Join(labels, "."), offset, nil

     

       66
       66
       +
       }

     

       67
       67
       +
       

     

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

     

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

     

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

     

       71
       71
       +
       

     

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

     

       73
       73
       +
       	for i, label := range labels {

     

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

     

       75
       75
       +
       

     

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

     

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

     

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

     

       79
       79
       +
       

     

       80
       80
       +
       			return bytes

     

       81
       81
       +
       		}

     

       82
       82
       +
       

     

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

     

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

     

       85
       85
       +
       

     

       86
       86
       +
       		(*offsets)[remaining_labels] = pos

     

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

     

       88
       88
       +
       	}

     

       89
       89
       +
       

     

       90
       90
       +
       	bytes = append(bytes, 0)

     

       91
       91
       +
       	return bytes

     

       92
       92
       +
       }

+58

domain_test.go

···

       1
       1
       +
       package magna

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"testing"

     

       5
       5
       +
       )

     

       6
       6
       +
       

     

       7
       7
       +
       func TestDecodeDomain(t *testing.T) {

     

       8
       8
       +
       	buf := []byte{

     

       9
       9
       +
       		0x03, 0x63, 0x6f, 0x6d, 0x00,

     

       10
       10
       +
       	}

     

       11
       11
       +
       

     

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

     

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

     

       14
       14
       +
       	assert_eq(t, 5, offset)

     

       15
       15
       +
       	assert_no_error(t, err)

     

       16
       16
       +
       }

     

       17
       17
       +
       

     

       18
       18
       +
       func TestDecodeDomainWithCompression(t *testing.T) {

     

       19
       19
       +
       	buf := []byte{

     

       20
       20
       +
       		0x03, 0x63, 0x6f, 0x6d, 0x00, 0x01, 0x63, 0xC0, 0x00,

     

       21
       21
       +
       	}

     

       22
       22
       +
       

     

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

     

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

     

       25
       25
       +
       	assert_eq(t, 9, offset)

     

       26
       26
       +
       	assert_no_error(t, err)

     

       27
       27
       +
       }

     

       28
       28
       +
       

     

       29
       29
       +
       func TestDecodeDomainWithCompressionLoop(t *testing.T) {

     

       30
       30
       +
       	buf := []byte{

     

       31
       31
       +
       		0x03, 0x63, 0x6f, 0x6d, 0xC0, 0x00,

     

       32
       32
       +
       	}

     

       33
       33
       +
       

     

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

     

       35
       35
       +
       	assert_eq(t, "", domain)

     

       36
       36
       +
       	assert_eq(t, 6, offset)

     

       37
       37
       +
       	assert_error(t, err)

     

       38
       38
       +
       }

     

       39
       39
       +
       

     

       40
       40
       +
       func FuzzDecodeDomain(f *testing.F) {

     

       41
       41
       +
       	testcases := [][]byte{

     

       42
       42
       +
       		{

     

       43
       43
       +
       			0x03, 0x63, 0x6f, 0x6d, 0x00,

     

       44
       44
       +
       		},

     

       45
       45
       +
       		{

     

       46
       46
       +
       			0x03, 0x63, 0x6f, 0x6d, 0x00, 0x01, 0x63, 0xC0, 0x00,

     

       47
       47
       +
       		},

     

       48
       48
       +
       		{

     

       49
       49
       +
       			0x03, 0x63, 0x6f, 0x6d, 0xC0, 0x00,

     

       50
       50
       +
       		},

     

       51
       51
       +
       	}

     

       52
       52
       +
       	for _, tc := range testcases {

     

       53
       53
       +
       		f.Add(tc) // Use f.Add to provide a seed corpus

     

       54
       54
       +
       	}

     

       55
       55
       +
       	f.Fuzz(func(t *testing.T, msg []byte) {

     

       56
       56
       +
       		decode_domain(msg, 0)

     

       57
       57
       +
       	})

     

       58
       58
       +
       }

+40

errors.go

···

       1
       1
       +
       package magna

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"fmt"

     

       5
       5
       +
       )

     

       6
       6
       +
       

     

       7
       7
       +
       // BufferOverflowError represents an error when there is a buffer overflow.

     

       8
       8
       +
       type BufferOverflowError struct {

     

       9
       9
       +
       	Length int

     

       10
       10
       +
       	Offset int

     

       11
       11
       +
       }

     

       12
       12
       +
       

     

       13
       13
       +
       func (e *BufferOverflowError) Error() string {

     

       14
       14
       +
       	return fmt.Sprintf("magna: offset %d is past the buffer length %d", e.Offset, e.Length)

     

       15
       15
       +
       }

     

       16
       16
       +
       

     

       17
       17
       +
       // InvalidLabelError represents an error when an invalid label length is encountered.

     

       18
       18
       +
       type InvalidLabelError struct {

     

       19
       19
       +
       	Length int

     

       20
       20
       +
       }

     

       21
       21
       +
       

     

       22
       22
       +
       func (e *InvalidLabelError) Error() string {

     

       23
       23
       +
       	return fmt.Sprintf("magna: received invalid label length %d", e.Length)

     

       24
       24
       +
       }

     

       25
       25
       +
       

     

       26
       26
       +
       // DomainCompressionError represents an error related to domain compression.

     

       27
       27
       +
       type DomainCompressionError struct{}

     

       28
       28
       +
       

     

       29
       29
       +
       func (e *DomainCompressionError) Error() string {

     

       30
       30
       +
       	return "magna: loop detected in domain compression"

     

       31
       31
       +
       }

     

       32
       32
       +
       

     

       33
       33
       +
       // MagnaError represents a generic error with a custom message.

     

       34
       34
       +
       type MagnaError struct {

     

       35
       35
       +
       	Message string

     

       36
       36
       +
       }

     

       37
       37
       +
       

     

       38
       38
       +
       func (e *MagnaError) Error() string {

     

       39
       39
       +
       	return fmt.Sprintf("magna: %s", e.Message)

     

       40
       40
       +
       }

go.mod

···

       1
       1
       +
       module code.kiri.systems/magna

     

       2
       2
       +
       

     

       3
       3
       +
       go 1.22.3

+89

header.go

···

       1
       1
       +
       package magna

     

       2
       2
       +
       

     

       3
       3
       +
       import "encoding/binary"

     

       4
       4
       +
       

     

       5
       5
       +
       // Decode decodes the header from the bytes.

     

       6
       6
       +
       func (h *Header) Decode(buf []byte, offset int) (int, error) {

     

       7
       7
       +
       	var err error

     

       8
       8
       +
       	h.ID, offset, err = getU16(buf, offset)

     

       9
       9
       +
       	if err != nil {

     

       10
       10
       +
       		return len(buf), err

     

       11
       11
       +
       	}

     

       12
       12
       +
       

     

       13
       13
       +
       	flags, offset, err := getU16(buf, offset)

     

       14
       14
       +
       	if err != nil {

     

       15
       15
       +
       		return len(buf), err

     

       16
       16
       +
       	}

     

       17
       17
       +
       

     

       18
       18
       +
       	h.QDCount, offset, err = getU16(buf, offset)

     

       19
       19
       +
       	if err != nil {

     

       20
       20
       +
       		return len(buf), err

     

       21
       21
       +
       	}

     

       22
       22
       +
       

     

       23
       23
       +
       	h.ANCount, offset, err = getU16(buf, offset)

     

       24
       24
       +
       	if err != nil {

     

       25
       25
       +
       		return len(buf), err

     

       26
       26
       +
       	}

     

       27
       27
       +
       

     

       28
       28
       +
       	h.NSCount, offset, err = getU16(buf, offset)

     

       29
       29
       +
       	if err != nil {

     

       30
       30
       +
       		return len(buf), err

     

       31
       31
       +
       	}

     

       32
       32
       +
       

     

       33
       33
       +
       	h.ARCount, offset, err = getU16(buf, offset)

     

       34
       34
       +
       	if err != nil {

     

       35
       35
       +
       		return len(buf), err

     

       36
       36
       +
       	}

     

       37
       37
       +
       

     

       38
       38
       +
       	h.QR = ((flags >> 15) & 0x01) == 1

     

       39
       39
       +
       	h.OPCode = OPCode((flags >> 11) & 0x0F)

     

       40
       40
       +
       	h.AA = ((flags >> 10) & 0x01) == 1

     

       41
       41
       +
       	h.TC = ((flags >> 9) & 0x01) == 1

     

       42
       42
       +
       	h.RD = ((flags >> 8) & 0x01) == 1

     

       43
       43
       +
       	h.RA = ((flags >> 7) & 0x01) == 1

     

       44
       44
       +
       	h.Z = uint8((flags >> 4) & 0x07)

     

       45
       45
       +
       	h.RCode = RCode((flags & 0x0F))

     

       46
       46
       +
       

     

       47
       47
       +
       	return offset, nil

     

       48
       48
       +
       }

     

       49
       49
       +
       

     

       50
       50
       +
       // Encode encodes the header packet to the byte representation.

     

       51
       51
       +
       func (h *Header) Encode() []byte {

     

       52
       52
       +
       	var bytes []byte

     

       53
       53
       +
       

     

       54
       54
       +
       	bytes = binary.BigEndian.AppendUint16(bytes, h.ID)

     

       55
       55
       +
       

     

       56
       56
       +
       	var flags uint16

     

       57
       57
       +
       	if h.QR {

     

       58
       58
       +
       		flags |= 1 << 15

     

       59
       59
       +
       	}

     

       60
       60
       +
       

     

       61
       61
       +
       	flags |= uint16(h.OPCode) << 11

     

       62
       62
       +
       

     

       63
       63
       +
       	if h.AA {

     

       64
       64
       +
       		flags |= 1 << 10

     

       65
       65
       +
       	}

     

       66
       66
       +
       

     

       67
       67
       +
       	if h.TC {

     

       68
       68
       +
       		flags |= 1 << 9

     

       69
       69
       +
       	}

     

       70
       70
       +
       

     

       71
       71
       +
       	if h.RD {

     

       72
       72
       +
       		flags |= 1 << 8

     

       73
       73
       +
       	}

     

       74
       74
       +
       

     

       75
       75
       +
       	if h.RA {

     

       76
       76
       +
       		flags |= 1 << 7

     

       77
       77
       +
       	}

     

       78
       78
       +
       

     

       79
       79
       +
       	flags |= uint16(h.Z) << 4

     

       80
       80
       +
       	flags |= uint16(h.RCode)

     

       81
       81
       +
       

     

       82
       82
       +
       	bytes = binary.BigEndian.AppendUint16(bytes, flags)

     

       83
       83
       +
       	bytes = binary.BigEndian.AppendUint16(bytes, h.QDCount)

     

       84
       84
       +
       	bytes = binary.BigEndian.AppendUint16(bytes, h.ANCount)

     

       85
       85
       +
       	bytes = binary.BigEndian.AppendUint16(bytes, h.NSCount)

     

       86
       86
       +
       	bytes = binary.BigEndian.AppendUint16(bytes, h.ARCount)

     

       87
       87
       +
       

     

       88
       88
       +
       	return bytes

     

       89
       89
       +
       }

+105

header_test.go

···

       1
       1
       +
       package magna

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"reflect"

     

       5
       5
       +
       	"testing"

     

       6
       6
       +
       )

     

       7
       7
       +
       

     

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

     

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

     

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

     

       11
       11
       +
       	}

     

       12
       12
       +
       

     

       13
       13
       +
       	if expected != actual {

     

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

     

       15
       15
       +
       	}

     

       16
       16
       +
       }

     

       17
       17
       +
       

     

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

     

       19
       19
       +
       	if err != nil {

     

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

     

       21
       21
       +
       	}

     

       22
       22
       +
       }

     

       23
       23
       +
       

     

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

     

       25
       25
       +
       	if err == nil {

     

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

     

       27
       27
       +
       	}

     

       28
       28
       +
       }

     

       29
       29
       +
       

     

       30
       30
       +
       func TestHeaderDecode(t *testing.T) {

     

       31
       31
       +
       	bytes := []byte{

     

       32
       32
       +
       		0x01, 0x02, // ID

     

       33
       33
       +
       		0xaa, 0xaa, // QR, Opcode, AA, TC, RD, RA, Z, RCODE

     

       34
       34
       +
       		0x00, 0x01, // QDCOUNT

     

       35
       35
       +
       		0x00, 0x02, // ANCOUNT

     

       36
       36
       +
       		0x00, 0x03, // NSCOUNT

     

       37
       37
       +
       		0x00, 0x04, // ARCOUNT

     

       38
       38
       +
       	}

     

       39
       39
       +
       

     

       40
       40
       +
       	var header Header

     

       41
       41
       +
       	offset, err := header.Decode(bytes, 0)

     

       42
       42
       +
       	if err != nil {

     

       43
       43
       +
       		t.Errorf("error should be nil\n")

     

       44
       44
       +
       	}

     

       45
       45
       +
       

     

       46
       46
       +
       	if offset != 12 {

     

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

     

       48
       48
       +
       	}

     

       49
       49
       +
       

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

       63
       63
       +
       }

     

       64
       64
       +
       

     

       65
       65
       +
       func TestHeaderEncode(t *testing.T) {

     

       66
       66
       +
       	bytes := []byte{

     

       67
       67
       +
       		0x01, 0x02, // ID

     

       68
       68
       +
       		0xaa, 0xaa, // QR, Opcode, AA, TC, RD, RA, Z, RCODE

     

       69
       69
       +
       		0x00, 0x01, // QDCOUNT

     

       70
       70
       +
       		0x00, 0x02, // ANCOUNT

     

       71
       71
       +
       		0x00, 0x03, // NSCOUNT

     

       72
       72
       +
       		0x00, 0x04, // ARCOUNT

     

       73
       73
       +
       	}

     

       74
       74
       +
       

     

       75
       75
       +
       	var header Header

     

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

     

       77
       77
       +
       	assert_no_error(t, err)

     

       78
       78
       +
       

     

       79
       79
       +
       	actual := header.Encode()

     

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

     

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

     

       82
       82
       +
       			t.Fatal(bytes, actual)

     

       83
       83
       +
       		}

     

       84
       84
       +
       	}

     

       85
       85
       +
       }

     

       86
       86
       +
       

     

       87
       87
       +
       func FuzzDecodeHeader(f *testing.F) {

     

       88
       88
       +
       	testcases := [][]byte{

     

       89
       89
       +
       		{

     

       90
       90
       +
       			0x01, 0x02,

     

       91
       91
       +
       			0xaa, 0xaa,

     

       92
       92
       +
       			0x00, 0x01,

     

       93
       93
       +
       			0x00, 0x02,

     

       94
       94
       +
       			0x00, 0x03,

     

       95
       95
       +
       			0x00, 0x04,

     

       96
       96
       +
       		},

     

       97
       97
       +
       	}

     

       98
       98
       +
       	for _, tc := range testcases {

     

       99
       99
       +
       		f.Add(tc) // Use f.Add to provide a seed corpus

     

       100
       100
       +
       	}

     

       101
       101
       +
       	var header Header

     

       102
       102
       +
       	f.Fuzz(func(t *testing.T, msg []byte) {

     

       103
       103
       +
       		header.Decode(msg, 0)

     

       104
       104
       +
       	})

     

       105
       105
       +
       }

magna.go

···

       1
       1
       +
       // Package magna implements DNS message encoding/decoding.

     

       2
       2
       +
       package magna

+76

message.go

···

       1
       1
       +
       package magna

     

       2
       2
       +
       

     

       3
       3
       +
       // Decode decodes a DNS packet.

     

       4
       4
       +
       func (m *Message) Decode(buf []byte) (err error) {

     

       5
       5
       +
       	offset, err := m.Header.Decode(buf, 0)

     

       6
       6
       +
       	if err != nil {

     

       7
       7
       +
       		return err

     

       8
       8
       +
       	}

     

       9
       9
       +
       

     

       10
       10
       +
       	for x := 0; x < int(m.Header.QDCount); x++ {

     

       11
       11
       +
       		var question Question

     

       12
       12
       +
       		offset, err = question.Decode(buf, offset)

     

       13
       13
       +
       		if err != nil {

     

       14
       14
       +
       			return err

     

       15
       15
       +
       		}

     

       16
       16
       +
       

     

       17
       17
       +
       		m.Question = append(m.Question, question)

     

       18
       18
       +
       	}

     

       19
       19
       +
       

     

       20
       20
       +
       	for x := 0; x < int(m.Header.ANCount); x++ {

     

       21
       21
       +
       		var rr ResourceRecord

     

       22
       22
       +
       		offset, err = rr.Decode(buf, offset)

     

       23
       23
       +
       		if err != nil {

     

       24
       24
       +
       			return err

     

       25
       25
       +
       		}

     

       26
       26
       +
       

     

       27
       27
       +
       		m.Answer = append(m.Answer, rr)

     

       28
       28
       +
       	}

     

       29
       29
       +
       

     

       30
       30
       +
       	for x := 0; x < int(m.Header.NSCount); x++ {

     

       31
       31
       +
       		var rr ResourceRecord

     

       32
       32
       +
       		offset, err = rr.Decode(buf, offset)

     

       33
       33
       +
       		if err != nil {

     

       34
       34
       +
       			return err

     

       35
       35
       +
       		}

     

       36
       36
       +
       

     

       37
       37
       +
       		m.Authority = append(m.Authority, rr)

     

       38
       38
       +
       	}

     

       39
       39
       +
       

     

       40
       40
       +
       	for x := 0; x < int(m.Header.ARCount); x++ {

     

       41
       41
       +
       		var rr ResourceRecord

     

       42
       42
       +
       		offset, err = rr.Decode(buf, offset)

     

       43
       43
       +
       		if err != nil {

     

       44
       44
       +
       			return err

     

       45
       45
       +
       		}

     

       46
       46
       +
       

     

       47
       47
       +
       		m.Additional = append(m.Additional, rr)

     

       48
       48
       +
       	}

     

       49
       49
       +
       

     

       50
       50
       +
       	return nil

     

       51
       51
       +
       }

     

       52
       52
       +
       

     

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

     

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

     

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

     

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

     

       57
       57
       +
       	bytes := m.Header.Encode()

     

       58
       58
       +
       

     

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

     

       60
       60
       +
       		bytes = question.Encode(bytes, &m.offsets)

     

       61
       61
       +
       	}

     

       62
       62
       +
       

     

       63
       63
       +
       	for _, answer := range m.Answer {

     

       64
       64
       +
       		bytes = answer.Encode(bytes, &m.offsets)

     

       65
       65
       +
       	}

     

       66
       66
       +
       

     

       67
       67
       +
       	for _, authority := range m.Authority {

     

       68
       68
       +
       		bytes = authority.Encode(bytes, &m.offsets)

     

       69
       69
       +
       	}

     

       70
       70
       +
       

     

       71
       71
       +
       	for _, additional := range m.Additional {

     

       72
       72
       +
       		bytes = additional.Encode(bytes, &m.offsets)

     

       73
       73
       +
       	}

     

       74
       74
       +
       

     

       75
       75
       +
       	return bytes

     

       76
       76
       +
       }

+83

message_test.go

···

       1
       1
       +
       package magna

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"testing"

     

       5
       5
       +
       )

     

       6
       6
       +
       

     

       7
       7
       +
       func TestMessageDecode(t *testing.T) {

     

       8
       8
       +
       	bytes := []byte{

     

       9
       9
       +
       		0x8e, 0x19, 0x81, 0x80, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x04, 0x6e, 0x65,

     

       10
       10
       +
       		0x77, 0x73, 0x0b, 0x79, 0x63, 0x6f, 0x6d, 0x62, 0x69, 0x6e, 0x61, 0x74, 0x6f, 0x72, 0x03,

     

       11
       11
       +
       		0x63, 0x6f, 0x6d, 0x00, 0x00, 0x01, 0x00, 0x01, 0xc0, 0x0c, 0x00, 0x01, 0x00, 0x01, 0x00,

     

       12
       12
       +
       		0x00, 0x00, 0x01, 0x00, 0x04, 0xd1, 0xd8, 0xe6, 0xcf,

     

       13
       13
       +
       	}

     

       14
       14
       +
       

     

       15
       15
       +
       	var msg Message

     

       16
       16
       +
       	msg.Decode(bytes)

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

       30
       30
       +
       

     

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

     

       32
       32
       +
       

     

       33
       33
       +
       	question := msg.Question[0]

     

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

     

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

     

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

     

       37
       37
       +
       

     

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

     

       39
       39
       +
       	answer := msg.Answer[0]

     

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

     

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

     

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

     

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

     

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

     

       45
       45
       +
       }

     

       46
       46
       +
       

     

       47
       47
       +
       func TestMessageEncode(t *testing.T) {

     

       48
       48
       +
       	bytes := []byte{

     

       49
       49
       +
       		0x8e, 0x19, 0x81, 0x80, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x04, 0x6e, 0x65,

     

       50
       50
       +
       		0x77, 0x73, 0x0b, 0x79, 0x63, 0x6f, 0x6d, 0x62, 0x69, 0x6e, 0x61, 0x74, 0x6f, 0x72, 0x03,

     

       51
       51
       +
       		0x63, 0x6f, 0x6d, 0x00, 0x00, 0x01, 0x00, 0x01, 0xc0, 0x0c, 0x00, 0x01, 0x00, 0x01, 0x00,

     

       52
       52
       +
       		0x00, 0x00, 0x01, 0x00, 0x04, 0xd1, 0xd8, 0xe6, 0xcf,

     

       53
       53
       +
       	}

     

       54
       54
       +
       

     

       55
       55
       +
       	var msg Message

     

       56
       56
       +
       	err := msg.Decode(bytes)

     

       57
       57
       +
       	assert_no_error(t, err)

     

       58
       58
       +
       

     

       59
       59
       +
       	actual := msg.Encode()

     

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

     

       61
       61
       +
       		if bytes[i] != actual[i] {

     

       62
       62
       +
       			t.Fatal(bytes, actual)

     

       63
       63
       +
       		}

     

       64
       64
       +
       	}

     

       65
       65
       +
       }

     

       66
       66
       +
       

     

       67
       67
       +
       func FuzzDecodeMessage(f *testing.F) {

     

       68
       68
       +
       	testcases := [][]byte{

     

       69
       69
       +
       		{

     

       70
       70
       +
       			0x8e, 0x19, 0x81, 0x80, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x04, 0x6e, 0x65,

     

       71
       71
       +
       			0x77, 0x73, 0x0b, 0x79, 0x63, 0x6f, 0x6d, 0x62, 0x69, 0x6e, 0x61, 0x74, 0x6f, 0x72, 0x03,

     

       72
       72
       +
       			0x63, 0x6f, 0x6d, 0x00, 0x00, 0x01, 0x00, 0x01, 0xc0, 0x0c, 0x00, 0x01, 0x00, 0x01, 0x00,

     

       73
       73
       +
       			0x00, 0x00, 0x01, 0x00, 0x04, 0xd1, 0xd8, 0xe6, 0xcf,

     

       74
       74
       +
       		},

     

       75
       75
       +
       	}

     

       76
       76
       +
       	for _, tc := range testcases {

     

       77
       77
       +
       		f.Add(tc) // Use f.Add to provide a seed corpus

     

       78
       78
       +
       	}

     

       79
       79
       +
       	f.Fuzz(func(t *testing.T, msg []byte) {

     

       80
       80
       +
       		var m Message

     

       81
       81
       +
       		m.Decode(msg)

     

       82
       82
       +
       	})

     

       83
       83
       +
       }

+34

question.go

···

       1
       1
       +
       package magna

     

       2
       2
       +
       

     

       3
       3
       +
       import "encoding/binary"

     

       4
       4
       +
       

     

       5
       5
       +
       // Decode decodes a question from buf at the offset

     

       6
       6
       +
       func (q *Question) Decode(buf []byte, offset int) (int, error) {

     

       7
       7
       +
       	var err error

     

       8
       8
       +
       	q.QName, offset, err = decode_domain(buf, offset)

     

       9
       9
       +
       	if err != nil {

     

       10
       10
       +
       		return offset, err

     

       11
       11
       +
       	}

     

       12
       12
       +
       

     

       13
       13
       +
       	qtype, offset, err := getU16(buf, offset)

     

       14
       14
       +
       	if err != nil {

     

       15
       15
       +
       		return offset, err

     

       16
       16
       +
       	}

     

       17
       17
       +
       

     

       18
       18
       +
       	qclass, offset, err := getU16(buf, offset)

     

       19
       19
       +
       	if err != nil {

     

       20
       20
       +
       		return offset, err

     

       21
       21
       +
       	}

     

       22
       22
       +
       

     

       23
       23
       +
       	q.QType = DNSType(qtype)

     

       24
       24
       +
       	q.QClass = DNSClass(qclass)

     

       25
       25
       +
       	return offset, nil

     

       26
       26
       +
       }

     

       27
       27
       +
       

     

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

     

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

     

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

     

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

     

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

     

       33
       33
       +
       	return bytes

     

       34
       34
       +
       }

+421

resource_record.go

···

       1
       1
       +
       package magna

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"encoding/binary"

     

       5
       5
       +
       	"net"

     

       6
       6
       +
       	"strings"

     

       7
       7
       +
       )

     

       8
       8
       +
       

     

       9
       9
       +
       func (a *A) Decode(buf []byte, offset int, rdlength int) (int, error) {

     

       10
       10
       +
       	bytes, offset, err := getSlice(buf, offset, rdlength)

     

       11
       11
       +
       	if err != nil {

     

       12
       12
       +
       		return offset, err

     

       13
       13
       +
       	}

     

       14
       14
       +
       

     

       15
       15
       +
       	a.Address = net.IP(bytes)

     

       16
       16
       +
       	return offset, err

     

       17
       17
       +
       }

     

       18
       18
       +
       

     

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

     

       20
       20
       +
       	return append(bytes, a.Address.To4()...)

     

       21
       21
       +
       }

     

       22
       22
       +
       

     

       23
       23
       +
       func (ns *NS) Decode(buf []byte, offset int, rdlength int) (int, error) {

     

       24
       24
       +
       	var err error

     

       25
       25
       +
       	ns.NSDName, offset, err = decode_domain(buf, offset)

     

       26
       26
       +
       	if err != nil {

     

       27
       27
       +
       		return offset, err

     

       28
       28
       +
       	}

     

       29
       29
       +
       

     

       30
       30
       +
       	return offset, err

     

       31
       31
       +
       }

     

       32
       32
       +
       

     

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

     

       34
       34
       +
       	return append(bytes, encode_domain(bytes, ns.NSDName, offsets)...)

     

       35
       35
       +
       }

     

       36
       36
       +
       

     

       37
       37
       +
       func (md *MD) Decode(buf []byte, offset int, rdlength int) (int, error) {

     

       38
       38
       +
       	var err error

     

       39
       39
       +
       	md.MADName, offset, err = decode_domain(buf, offset)

     

       40
       40
       +
       	if err != nil {

     

       41
       41
       +
       		return offset, err

     

       42
       42
       +
       	}

     

       43
       43
       +
       

     

       44
       44
       +
       	return offset, err

     

       45
       45
       +
       }

     

       46
       46
       +
       

     

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

     

       48
       48
       +
       	return append(bytes, encode_domain(bytes, md.MADName, offsets)...)

     

       49
       49
       +
       }

     

       50
       50
       +
       

     

       51
       51
       +
       func (mf *MF) Decode(buf []byte, offset int, rdlength int) (int, error) {

     

       52
       52
       +
       	var err error

     

       53
       53
       +
       	mf.MADName, offset, err = decode_domain(buf, offset)

     

       54
       54
       +
       	if err != nil {

     

       55
       55
       +
       		return offset, err

     

       56
       56
       +
       	}

     

       57
       57
       +
       

     

       58
       58
       +
       	return offset, err

     

       59
       59
       +
       }

     

       60
       60
       +
       

     

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

     

       62
       62
       +
       	return append(bytes, encode_domain(bytes, mf.MADName, offsets)...)

     

       63
       63
       +
       }

     

       64
       64
       +
       

     

       65
       65
       +
       func (c *CNAME) Decode(buf []byte, offset int, rdlength int) (int, error) {

     

       66
       66
       +
       	var err error

     

       67
       67
       +
       	c.CName, offset, err = decode_domain(buf, offset)

     

       68
       68
       +
       	if err != nil {

     

       69
       69
       +
       		return offset, err

     

       70
       70
       +
       	}

     

       71
       71
       +
       

     

       72
       72
       +
       	return offset, err

     

       73
       73
       +
       }

     

       74
       74
       +
       

     

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

     

       76
       76
       +
       	return append(bytes, encode_domain(bytes, c.CName, offsets)...)

     

       77
       77
       +
       }

     

       78
       78
       +
       

     

       79
       79
       +
       func (soa *SOA) Decode(buf []byte, offset int, rdlength int) (int, error) {

     

       80
       80
       +
       	var err error

     

       81
       81
       +
       	soa.MName, offset, err = decode_domain(buf, offset)

     

       82
       82
       +
       	if err != nil {

     

       83
       83
       +
       		return offset, err

     

       84
       84
       +
       	}

     

       85
       85
       +
       

     

       86
       86
       +
       	soa.RName, offset, err = decode_domain(buf, offset)

     

       87
       87
       +
       	if err != nil {

     

       88
       88
       +
       		return offset, err

     

       89
       89
       +
       	}

     

       90
       90
       +
       

     

       91
       91
       +
       	soa.Serial, offset, err = getU32(buf, offset)

     

       92
       92
       +
       	if err != nil {

     

       93
       93
       +
       		return offset, err

     

       94
       94
       +
       	}

     

       95
       95
       +
       

     

       96
       96
       +
       	soa.Refresh, offset, err = getU32(buf, offset)

     

       97
       97
       +
       	if err != nil {

     

       98
       98
       +
       		return offset, err

     

       99
       99
       +
       	}

     

       100
       100
       +
       

     

       101
       101
       +
       	soa.Retry, offset, err = getU32(buf, offset)

     

       102
       102
       +
       	if err != nil {

     

       103
       103
       +
       		return offset, err

     

       104
       104
       +
       	}

     

       105
       105
       +
       

     

       106
       106
       +
       	soa.Expire, offset, err = getU32(buf, offset)

     

       107
       107
       +
       	if err != nil {

     

       108
       108
       +
       		return offset, err

     

       109
       109
       +
       	}

     

       110
       110
       +
       

     

       111
       111
       +
       	soa.Minimum, offset, err = getU32(buf, offset)

     

       112
       112
       +
       	if err != nil {

     

       113
       113
       +
       		return offset, err

     

       114
       114
       +
       	}

     

       115
       115
       +
       

     

       116
       116
       +
       	return offset, err

     

       117
       117
       +
       }

     

       118
       118
       +
       

     

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

     

       120
       120
       +
       	bytes = append(bytes, encode_domain(bytes, soa.MName, offsets)...)

     

       121
       121
       +
       	bytes = append(bytes, encode_domain(bytes, soa.RName, offsets)...)

     

       122
       122
       +
       	bytes = binary.BigEndian.AppendUint32(bytes, soa.Serial)

     

       123
       123
       +
       	bytes = binary.BigEndian.AppendUint32(bytes, soa.Refresh)

     

       124
       124
       +
       	bytes = binary.BigEndian.AppendUint32(bytes, soa.Retry)

     

       125
       125
       +
       	bytes = binary.BigEndian.AppendUint32(bytes, soa.Expire)

     

       126
       126
       +
       	bytes = binary.BigEndian.AppendUint32(bytes, soa.Minimum)

     

       127
       127
       +
       

     

       128
       128
       +
       	return bytes

     

       129
       129
       +
       }

     

       130
       130
       +
       

     

       131
       131
       +
       func (mb *MB) Decode(buf []byte, offset int, rdlength int) (int, error) {

     

       132
       132
       +
       	madname, offset, err := decode_domain(buf, offset)

     

       133
       133
       +
       	if err != nil {

     

       134
       134
       +
       		return offset, err

     

       135
       135
       +
       	}

     

       136
       136
       +
       

     

       137
       137
       +
       	mb.MADName = string(madname)

     

       138
       138
       +
       	return offset, err

     

       139
       139
       +
       }

     

       140
       140
       +
       

     

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

     

       142
       142
       +
       	return append(bytes, encode_domain(bytes, mb.MADName, offsets)...)

     

       143
       143
       +
       }

     

       144
       144
       +
       

     

       145
       145
       +
       func (mg *MG) Decode(buf []byte, offset int, rdlength int) (int, error) {

     

       146
       146
       +
       	var err error

     

       147
       147
       +
       	mg.MGMName, offset, err = decode_domain(buf, offset)

     

       148
       148
       +
       	if err != nil {

     

       149
       149
       +
       		return offset, err

     

       150
       150
       +
       	}

     

       151
       151
       +
       

     

       152
       152
       +
       	return offset, err

     

       153
       153
       +
       }

     

       154
       154
       +
       

     

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

     

       156
       156
       +
       	return append(bytes, encode_domain(bytes, mg.MGMName, offsets)...)

     

       157
       157
       +
       }

     

       158
       158
       +
       

     

       159
       159
       +
       func (mr *MR) Decode(buf []byte, offset int, rdlength int) (int, error) {

     

       160
       160
       +
       	var err error

     

       161
       161
       +
       	mr.NEWName, offset, err = decode_domain(buf, offset)

     

       162
       162
       +
       	if err != nil {

     

       163
       163
       +
       		return offset, err

     

       164
       164
       +
       	}

     

       165
       165
       +
       

     

       166
       166
       +
       	return offset, err

     

       167
       167
       +
       }

     

       168
       168
       +
       

     

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

     

       170
       170
       +
       	return append(bytes, encode_domain(bytes, mr.NEWName, offsets)...)

     

       171
       171
       +
       }

     

       172
       172
       +
       

     

       173
       173
       +
       func (null *NULL) Decode(buf []byte, offset int, rdlength int) (int, error) {

     

       174
       174
       +
       	var err error

     

       175
       175
       +
       	null.Anything, offset, err = getSlice(buf, offset, int(rdlength))

     

       176
       176
       +
       	if err != nil {

     

       177
       177
       +
       		return offset, err

     

       178
       178
       +
       	}

     

       179
       179
       +
       

     

       180
       180
       +
       	return offset, err

     

       181
       181
       +
       }

     

       182
       182
       +
       

     

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

     

       184
       184
       +
       	return append(bytes, null.Anything...)

     

       185
       185
       +
       }

     

       186
       186
       +
       

     

       187
       187
       +
       func (wks *WKS) Decode(buf []byte, offset int, rdlength int) (int, error) {

     

       188
       188
       +
       	address, offset, err := getSlice(buf, offset, 4)

     

       189
       189
       +
       	if err != nil {

     

       190
       190
       +
       		return offset, err

     

       191
       191
       +
       	}

     

       192
       192
       +
       

     

       193
       193
       +
       	protocol, offset, err := getU8(buf, offset)

     

       194
       194
       +
       	if err != nil {

     

       195
       195
       +
       		return offset, err

     

       196
       196
       +
       	}

     

       197
       197
       +
       

     

       198
       198
       +
       	wks.Address = net.IP(address)

     

       199
       199
       +
       	wks.Protocol = protocol

     

       200
       200
       +
       	wks.BitMap, offset, err = getSlice(buf, offset, offset+int(rdlength)-5)

     

       201
       201
       +
       	if err != nil {

     

       202
       202
       +
       		return offset, err

     

       203
       203
       +
       	}

     

       204
       204
       +
       

     

       205
       205
       +
       	return offset, err

     

       206
       206
       +
       }

     

       207
       207
       +
       

     

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

     

       209
       209
       +
       	bytes = append(bytes, wks.Address.To4()...)

     

       210
       210
       +
       	bytes = append(bytes, wks.Protocol)

     

       211
       211
       +
       	bytes = append(bytes, wks.BitMap...)

     

       212
       212
       +
       

     

       213
       213
       +
       	return bytes

     

       214
       214
       +
       }

     

       215
       215
       +
       

     

       216
       216
       +
       func (ptr *PTR) Decode(buf []byte, offset int, rdlength int) (int, error) {

     

       217
       217
       +
       	var err error

     

       218
       218
       +
       	ptr.PTRDName, offset, err = decode_domain(buf, offset)

     

       219
       219
       +
       	if err != nil {

     

       220
       220
       +
       		return offset, err

     

       221
       221
       +
       	}

     

       222
       222
       +
       

     

       223
       223
       +
       	return offset, err

     

       224
       224
       +
       }

     

       225
       225
       +
       

     

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

     

       227
       227
       +
       	return append(bytes, encode_domain(bytes, ptr.PTRDName, offsets)...)

     

       228
       228
       +
       }

     

       229
       229
       +
       

     

       230
       230
       +
       func (hinfo *HINFO) Decode(buf []byte, offset int, rdlength int) (int, error) {

     

       231
       231
       +
       	input, offset, err := getSlice(buf, offset, int(rdlength))

     

       232
       232
       +
       	if err != nil {

     

       233
       233
       +
       		return offset, err

     

       234
       234
       +
       	}

     

       235
       235
       +
       

     

       236
       236
       +
       	parts := strings.SplitN(string(input), " ", 2)

     

       237
       237
       +
       	if len(parts) != 2 {

     

       238
       238
       +
       		return offset, &MagnaError{Message: "HINFO expected 2 values separated by a space"}

     

       239
       239
       +
       	}

     

       240
       240
       +
       

     

       241
       241
       +
       	hinfo.CPU = parts[0]

     

       242
       242
       +
       	hinfo.OS = parts[1]

     

       243
       243
       +
       	return offset, err

     

       244
       244
       +
       }

     

       245
       245
       +
       

     

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

     

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

     

       248
       248
       +
       	bytes = append(bytes, ' ')

     

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

     

       250
       250
       +
       	return bytes

     

       251
       251
       +
       }

     

       252
       252
       +
       

     

       253
       253
       +
       func (minfo *MINFO) Decode(buf []byte, offset int, rdlength int) (int, error) {

     

       254
       254
       +
       	var err error

     

       255
       255
       +
       

     

       256
       256
       +
       	minfo.RMailBx, offset, err = decode_domain(buf, offset)

     

       257
       257
       +
       	if err != nil {

     

       258
       258
       +
       		return offset, err

     

       259
       259
       +
       	}

     

       260
       260
       +
       

     

       261
       261
       +
       	minfo.EMailBx, offset, err = decode_domain(buf, offset)

     

       262
       262
       +
       	if err != nil {

     

       263
       263
       +
       		return offset, err

     

       264
       264
       +
       	}

     

       265
       265
       +
       

     

       266
       266
       +
       	return offset, err

     

       267
       267
       +
       }

     

       268
       268
       +
       

     

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

     

       270
       270
       +
       	bytes = append(bytes, encode_domain(bytes, minfo.RMailBx, offsets)...)

     

       271
       271
       +
       	bytes = append(bytes, encode_domain(bytes, minfo.EMailBx, offsets)...)

     

       272
       272
       +
       

     

       273
       273
       +
       	return bytes

     

       274
       274
       +
       }

     

       275
       275
       +
       

     

       276
       276
       +
       func (mx *MX) Decode(buf []byte, offset int, rdlength int) (int, error) {

     

       277
       277
       +
       	var err error

     

       278
       278
       +
       	mx.Preference, offset, err = getU16(buf, offset)

     

       279
       279
       +
       	if err != nil {

     

       280
       280
       +
       		return offset, err

     

       281
       281
       +
       	}

     

       282
       282
       +
       

     

       283
       283
       +
       	mx.Exchange, offset, err = decode_domain(buf, offset)

     

       284
       284
       +
       	if err != nil {

     

       285
       285
       +
       		return offset, err

     

       286
       286
       +
       	}

     

       287
       287
       +
       

     

       288
       288
       +
       	return offset, err

     

       289
       289
       +
       }

     

       290
       290
       +
       

     

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

     

       292
       292
       +
       	bytes = binary.BigEndian.AppendUint16(bytes, mx.Preference)

     

       293
       293
       +
       	bytes = append(bytes, encode_domain(bytes, mx.Exchange, offsets)...)

     

       294
       294
       +
       

     

       295
       295
       +
       	return bytes

     

       296
       296
       +
       }

     

       297
       297
       +
       

     

       298
       298
       +
       func (txt *TXT) Decode(buf []byte, offset int, rdlength int) (int, error) {

     

       299
       299
       +
       	bytes, offset, err := getSlice(buf, offset, rdlength)

     

       300
       300
       +
       	if err != nil {

     

       301
       301
       +
       		return offset, err

     

       302
       302
       +
       	}

     

       303
       303
       +
       

     

       304
       304
       +
       	txt.TxtData = string(bytes)

     

       305
       305
       +
       	return offset, err

     

       306
       306
       +
       }

     

       307
       307
       +
       

     

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

     

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

     

       310
       310
       +
       }

     

       311
       311
       +
       

     

       312
       312
       +
       func (r *Reserved) Decode(buf []byte, offset int, rdlength int) (int, error) {

     

       313
       313
       +
       	var err error

     

       314
       314
       +
       	r.Bytes, offset, err = getSlice(buf, offset, int(rdlength))

     

       315
       315
       +
       	if err != nil {

     

       316
       316
       +
       		return offset, err

     

       317
       317
       +
       	}

     

       318
       318
       +
       

     

       319
       319
       +
       	return offset, err

     

       320
       320
       +
       }

     

       321
       321
       +
       

     

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

     

       323
       323
       +
       	return append(bytes, r.Bytes...)

     

       324
       324
       +
       }

     

       325
       325
       +
       

     

       326
       326
       +
       // Decode decodes a resource record from buf at the offset.

     

       327
       327
       +
       func (r *ResourceRecord) Decode(buf []byte, offset int) (int, error) {

     

       328
       328
       +
       	name, offset, err := decode_domain(buf, offset)

     

       329
       329
       +
       	if err != nil {

     

       330
       330
       +
       		return offset, err

     

       331
       331
       +
       	}

     

       332
       332
       +
       	r.Name = name

     

       333
       333
       +
       

     

       334
       334
       +
       	rtype, offset, err := getU16(buf, offset)

     

       335
       335
       +
       	if err != nil {

     

       336
       336
       +
       		return offset, err

     

       337
       337
       +
       	}

     

       338
       338
       +
       	r.RType = DNSType(rtype)

     

       339
       339
       +
       

     

       340
       340
       +
       	rclass, offset, err := getU16(buf, offset)

     

       341
       341
       +
       	if err != nil {

     

       342
       342
       +
       		return offset, err

     

       343
       343
       +
       	}

     

       344
       344
       +
       	r.RClass = DNSClass(rclass)

     

       345
       345
       +
       

     

       346
       346
       +
       	r.TTL, offset, err = getU32(buf, offset)

     

       347
       347
       +
       	if err != nil {

     

       348
       348
       +
       		return offset, err

     

       349
       349
       +
       	}

     

       350
       350
       +
       

     

       351
       351
       +
       	r.RDLength, offset, err = getU16(buf, offset)

     

       352
       352
       +
       	if err != nil {

     

       353
       353
       +
       		return offset, err

     

       354
       354
       +
       	}

     

       355
       355
       +
       

     

       356
       356
       +
       	switch r.RType {

     

       357
       357
       +
       	case 1:

     

       358
       358
       +
       		r.RData = &A{}

     

       359
       359
       +
       	case 2:

     

       360
       360
       +
       		r.RData = &NS{}

     

       361
       361
       +
       	case 3:

     

       362
       362
       +
       		r.RData = &MD{}

     

       363
       363
       +
       	case 4:

     

       364
       364
       +
       		r.RData = &MF{}

     

       365
       365
       +
       	case 5:

     

       366
       366
       +
       		r.RData = &CNAME{}

     

       367
       367
       +
       	case 6:

     

       368
       368
       +
       		r.RData = &SOA{}

     

       369
       369
       +
       	case 7:

     

       370
       370
       +
       		r.RData = &MB{}

     

       371
       371
       +
       	case 8:

     

       372
       372
       +
       		r.RData = &MG{}

     

       373
       373
       +
       	case 9:

     

       374
       374
       +
       		r.RData = &MR{}

     

       375
       375
       +
       	case 10:

     

       376
       376
       +
       		r.RData = &NULL{}

     

       377
       377
       +
       	case 11:

     

       378
       378
       +
       		r.RData = &WKS{}

     

       379
       379
       +
       	case 12:

     

       380
       380
       +
       		r.RData = &PTR{}

     

       381
       381
       +
       	case 13:

     

       382
       382
       +
       		r.RData = &HINFO{}

     

       383
       383
       +
       	case 14:

     

       384
       384
       +
       		r.RData = &MINFO{}

     

       385
       385
       +
       	case 15:

     

       386
       386
       +
       		r.RData = &MX{}

     

       387
       387
       +
       	case 16:

     

       388
       388
       +
       		r.RData = &TXT{}

     

       389
       389
       +
       	default:

     

       390
       390
       +
       		r.RData = &Reserved{}

     

       391
       391
       +
       	}

     

       392
       392
       +
       

     

       393
       393
       +
       	if r.RData != nil {

     

       394
       394
       +
       		offset, err = r.RData.Decode(buf, offset, int(r.RDLength))

     

       395
       395
       +
       		if err != nil {

     

       396
       396
       +
       			return offset, err

     

       397
       397
       +
       		}

     

       398
       398
       +
       	}

     

       399
       399
       +
       

     

       400
       400
       +
       	return offset, nil

     

       401
       401
       +
       }

     

       402
       402
       +
       

     

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

     

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

     

       405
       405
       +
       	bytes = encode_domain(bytes, r.Name, offsets)

     

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

     

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

     

       408
       408
       +
       	bytes = binary.BigEndian.AppendUint32(bytes, r.TTL)

     

       409
       409
       +
       

     

       410
       410
       +
       	second_dinner := make([]byte, len(bytes))

     

       411
       411
       +
       	copy(second_dinner, bytes)

     

       412
       412
       +
       	start := len(second_dinner)

     

       413
       413
       +
       	second_dinner = r.RData.Encode(second_dinner, offsets)

     

       414
       414
       +
       	end := len(second_dinner)

     

       415
       415
       +
       	data := second_dinner[start:end]

     

       416
       416
       +
       

     

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

     

       418
       418
       +
       	bytes = append(bytes, data...)

     

       419
       419
       +
       

     

       420
       420
       +
       	return bytes

     

       421
       421
       +
       }

+325

types.go

···

       1
       1
       +
       package magna

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"fmt"

     

       5
       5
       +
       	"net"

     

       6
       6
       +
       )

     

       7
       7
       +
       

     

       8
       8
       +
       type (

     

       9
       9
       +
       	// An OPCode specifies the kind of query.

     

       10
       10
       +
       	OPCode int

     

       11
       11
       +
       

     

       12
       12
       +
       	// A RCode specifies the response code.

     

       13
       13
       +
       	RCode int

     

       14
       14
       +
       

     

       15
       15
       +
       	// A DNSType specifies the type of the query.

     

       16
       16
       +
       	DNSType uint16

     

       17
       17
       +
       

     

       18
       18
       +
       	// A DNSClass specifies the class of the query.

     

       19
       19
       +
       	DNSClass uint16

     

       20
       20
       +
       )

     

       21
       21
       +
       

     

       22
       22
       +
       const (

     

       23
       23
       +
       	QUERY OPCode = iota

     

       24
       24
       +
       	IQUERY

     

       25
       25
       +
       	STATUS

     

       26
       26
       +
       )

     

       27
       27
       +
       

     

       28
       28
       +
       func (op OPCode) String() string {

     

       29
       29
       +
       	switch op {

     

       30
       30
       +
       	case QUERY:

     

       31
       31
       +
       		return "QUERY"

     

       32
       32
       +
       	case IQUERY:

     

       33
       33
       +
       		return "IQUERY"

     

       34
       34
       +
       	case STATUS:

     

       35
       35
       +
       		return "STATUS"

     

       36
       36
       +
       	default:

     

       37
       37
       +
       		return fmt.Sprintf("RESERVED(%d)", int(op))

     

       38
       38
       +
       	}

     

       39
       39
       +
       }

     

       40
       40
       +
       

     

       41
       41
       +
       const (

     

       42
       42
       +
       	NOERROR RCode = iota

     

       43
       43
       +
       	FORMERR

     

       44
       44
       +
       	SERVFAIL

     

       45
       45
       +
       	NXDOMAIN

     

       46
       46
       +
       	NOTIMP

     

       47
       47
       +
       	REFUSED

     

       48
       48
       +
       )

     

       49
       49
       +
       

     

       50
       50
       +
       func (r RCode) String() string {

     

       51
       51
       +
       	switch r {

     

       52
       52
       +
       	case NOERROR:

     

       53
       53
       +
       		return "NOERROR"

     

       54
       54
       +
       	case FORMERR:

     

       55
       55
       +
       		return "FORMERR"

     

       56
       56
       +
       	case SERVFAIL:

     

       57
       57
       +
       		return "SERVFAIL"

     

       58
       58
       +
       	case NXDOMAIN:

     

       59
       59
       +
       		return "NXDOMAIN"

     

       60
       60
       +
       	case NOTIMP:

     

       61
       61
       +
       		return "NOTIMP"

     

       62
       62
       +
       	case REFUSED:

     

       63
       63
       +
       		return "REFUSED"

     

       64
       64
       +
       	default:

     

       65
       65
       +
       		return fmt.Sprintf("RESERVED(%d)", int(r))

     

       66
       66
       +
       	}

     

       67
       67
       +
       }

     

       68
       68
       +
       

     

       69
       69
       +
       const (

     

       70
       70
       +
       	AType DNSType = iota + 1

     

       71
       71
       +
       	NSType

     

       72
       72
       +
       	MDType

     

       73
       73
       +
       	MFType

     

       74
       74
       +
       	CNAMEType

     

       75
       75
       +
       	SOAType

     

       76
       76
       +
       	MBType

     

       77
       77
       +
       	MGType

     

       78
       78
       +
       	MRType

     

       79
       79
       +
       	NULLType

     

       80
       80
       +
       	WKSType

     

       81
       81
       +
       	PTRType

     

       82
       82
       +
       	HINFOType

     

       83
       83
       +
       	MINFOType

     

       84
       84
       +
       	MXType

     

       85
       85
       +
       	TXTType

     

       86
       86
       +
       

     

       87
       87
       +
       	AXFRType  = 252

     

       88
       88
       +
       	MAILBType = 253

     

       89
       89
       +
       	MAILAType = 254

     

       90
       90
       +
       	AllType   = 255

     

       91
       91
       +
       )

     

       92
       92
       +
       

     

       93
       93
       +
       func (t DNSType) String() string {

     

       94
       94
       +
       	switch t {

     

       95
       95
       +
       	case AType:

     

       96
       96
       +
       		return "A"

     

       97
       97
       +
       	case NSType:

     

       98
       98
       +
       		return "NS"

     

       99
       99
       +
       	case MDType:

     

       100
       100
       +
       		return "MD"

     

       101
       101
       +
       	case MFType:

     

       102
       102
       +
       		return "MF"

     

       103
       103
       +
       	case CNAMEType:

     

       104
       104
       +
       		return "CNAME"

     

       105
       105
       +
       	case SOAType:

     

       106
       106
       +
       		return "SOA"

     

       107
       107
       +
       	case MBType:

     

       108
       108
       +
       		return "MB"

     

       109
       109
       +
       	case MGType:

     

       110
       110
       +
       		return "MG"

     

       111
       111
       +
       	case MRType:

     

       112
       112
       +
       		return "MR"

     

       113
       113
       +
       	case NULLType:

     

       114
       114
       +
       		return "NULL"

     

       115
       115
       +
       	case WKSType:

     

       116
       116
       +
       		return "WKS"

     

       117
       117
       +
       	case PTRType:

     

       118
       118
       +
       		return "PTR"

     

       119
       119
       +
       	case HINFOType:

     

       120
       120
       +
       		return "HINFO"

     

       121
       121
       +
       	case MINFOType:

     

       122
       122
       +
       		return "MINFO"

     

       123
       123
       +
       	case MXType:

     

       124
       124
       +
       		return "MX"

     

       125
       125
       +
       	case TXTType:

     

       126
       126
       +
       		return "TXT"

     

       127
       127
       +
       	case AXFRType:

     

       128
       128
       +
       		return "AXFR"

     

       129
       129
       +
       	case MAILBType:

     

       130
       130
       +
       		return "MAILB"

     

       131
       131
       +
       	case MAILAType:

     

       132
       132
       +
       		return "MAILA"

     

       133
       133
       +
       	case AllType:

     

       134
       134
       +
       		return "All"

     

       135
       135
       +
       	default:

     

       136
       136
       +
       		return fmt.Sprintf("RESERVED(%d)", int(t))

     

       137
       137
       +
       	}

     

       138
       138
       +
       }

     

       139
       139
       +
       

     

       140
       140
       +
       const (

     

       141
       141
       +
       	IN DNSClass = iota + 1

     

       142
       142
       +
       	CS

     

       143
       143
       +
       	CH

     

       144
       144
       +
       	HS

     

       145
       145
       +
       

     

       146
       146
       +
       	ANY = 255

     

       147
       147
       +
       )

     

       148
       148
       +
       

     

       149
       149
       +
       func (c DNSClass) String() string {

     

       150
       150
       +
       	switch c {

     

       151
       151
       +
       	case IN:

     

       152
       152
       +
       		return "IN"

     

       153
       153
       +
       	case CS:

     

       154
       154
       +
       		return "CS"

     

       155
       155
       +
       	case CH:

     

       156
       156
       +
       		return "CH"

     

       157
       157
       +
       	case HS:

     

       158
       158
       +
       		return "HS"

     

       159
       159
       +
       	case ANY:

     

       160
       160
       +
       		return "*"

     

       161
       161
       +
       	default:

     

       162
       162
       +
       		return fmt.Sprintf("RESERVED(%d)", int(c))

     

       163
       163
       +
       	}

     

       164
       164
       +
       }

     

       165
       165
       +
       

     

       166
       166
       +
       // A Message represents the single format supported by the DNS protocol.

     

       167
       167
       +
       type Message struct {

     

       168
       168
       +
       	Header     Header           // Header contains metadata about the message.

     

       169
       169
       +
       	Question   []Question       // Question contains a slice of questions.

     

       170
       170
       +
       	Answer     []ResourceRecord // Answer contains a slice of resource records.

     

       171
       171
       +
       	Authority  []ResourceRecord // Authority contains a slice of resource records.

     

       172
       172
       +
       	Additional []ResourceRecord // Additional contains a slice of resource records.

     

       173
       173
       +
       

     

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

     

       175
       175
       +
       	// in domain compression.

     

       176
       176
       +
       	offsets map[string]uint8

     

       177
       177
       +
       }

     

       178
       178
       +
       

     

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

     

       180
       180
       +
       type Header struct {

     

       181
       181
       +
       	ID      uint16 // ID is a 16 bit identifier.

     

       182
       182
       +
       	QR      bool   // QR (query response) specifies if the packet is a query (false) or response (true).

     

       183
       183
       +
       	OPCode  OPCode // OPCode is a 4bit value that specifies the kind of the query.

     

       184
       184
       +
       	AA      bool   // AA (Authoritative Answer) specifies if the responding name server is the authoritative server.

     

       185
       185
       +
       	TC      bool   // TC (Truncation) specifies if the packet was truncated due to length.

     

       186
       186
       +
       	RD      bool   // RD (Recursion Desired) specifies that the client wants to recurse.

     

       187
       187
       +
       	RA      bool   // RA (Recursion Available) specifies that the server is available to recurse.

     

       188
       188
       +
       	Z       uint8  // Z  Reserved for future use

     

       189
       189
       +
       	RCode   RCode  // RCode is a 4 bit field representing the response error.

     

       190
       190
       +
       	QDCount uint16 // QDCount specifies number of entries in the Question slice.

     

       191
       191
       +
       	ANCount uint16 // ANCount specifies number of entries in the Answer slice.

     

       192
       192
       +
       	NSCount uint16 // NSCount specifies number of entries in the Authority slice.

     

       193
       193
       +
       	ARCount uint16 // ARCount specifies number of entries in the Additional slice.

     

       194
       194
       +
       }

     

       195
       195
       +
       

     

       196
       196
       +
       // A Question represent a question in the DNS packet.

     

       197
       197
       +
       type Question struct {

     

       198
       198
       +
       	QName  string   // QName domain name being questioned.

     

       199
       199
       +
       	QType  DNSType  // QType specifies the type of the question.

     

       200
       200
       +
       	QClass DNSClass // QClass specifies the class of the question.

     

       201
       201
       +
       }

     

       202
       202
       +
       

     

       203
       203
       +
       // A ResourceRecordData represents the RDATA field of the resource record.

     

       204
       204
       +
       // Decode:

     

       205
       205
       +
       //

     

       206
       206
       +
       //	[]byte - DNS packet

     

       207
       207
       +
       //	int    - offset in []byte to start parsing resource record data

     

       208
       208
       +
       //	int    - length of the resource record field

     

       209
       209
       +
       //

     

       210
       210
       +
       // Encode:

     

       211
       211
       +
       //

     

       212
       212
       +
       //	[]byte            - DNS Packet

     

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

     

       214
       214
       +
       type ResourceRecordData interface {

     

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

     

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

     

       217
       217
       +
       }

     

       218
       218
       +
       

     

       219
       219
       +
       // ResourceRecord represents DNS records.

     

       220
       220
       +
       type ResourceRecord struct {

     

       221
       221
       +
       	Name     string             // a domain label

     

       222
       222
       +
       	RType    DNSType            // the type of the record

     

       223
       223
       +
       	RClass   DNSClass           // the class of the record

     

       224
       224
       +
       	TTL      uint32             // the time to live of the record in seconds

     

       225
       225
       +
       	RDLength uint16             // the length of the record in number of bytes

     

       226
       226
       +
       	RData    ResourceRecordData // the data of the record

     

       227
       227
       +
       }

     

       228
       228
       +
       

     

       229
       229
       +
       // A represents a 32 bit Internet Address.

     

       230
       230
       +
       type A struct {

     

       231
       231
       +
       	Address net.IP

     

       232
       232
       +
       }

     

       233
       233
       +
       

     

       234
       234
       +
       // NS represents

     

       235
       235
       +
       type NS struct {

     

       236
       236
       +
       	NSDName string

     

       237
       237
       +
       }

     

       238
       238
       +
       

     

       239
       239
       +
       // MD represents the mail agent for a domain.

     

       240
       240
       +
       // XXX: Obsolete

     

       241
       241
       +
       type MD struct {

     

       242
       242
       +
       	MADName string

     

       243
       243
       +
       }

     

       244
       244
       +
       

     

       245
       245
       +
       // MF represents a host which has a mail agent for a domain.

     

       246
       246
       +
       // XXX: Obsolete

     

       247
       247
       +
       type MF struct {

     

       248
       248
       +
       	MADName string

     

       249
       249
       +
       }

     

       250
       250
       +
       

     

       251
       251
       +
       // CNAME represents the canonical name for the owner.

     

       252
       252
       +
       type CNAME struct {

     

       253
       253
       +
       	CName string

     

       254
       254
       +
       }

     

       255
       255
       +
       

     

       256
       256
       +
       // SOA represents

     

       257
       257
       +
       type SOA struct {

     

       258
       258
       +
       	MName   string // MName represents the name server that was the original source of data for a zone.

     

       259
       259
       +
       	RName   string // RName represents a mailbox of the person responsible for this zone.

     

       260
       260
       +
       	Serial  uint32 // Serial is a 32 bit version number of the original copy of the zone.

     

       261
       261
       +
       	Refresh uint32 // Refresh is a 32 bit time interval before the zone should be refreshed.

     

       262
       262
       +
       	Retry   uint32 // Retry is a 32 bit time interval that should elapse before a failed refresh is retried.

     

       263
       263
       +
       	Expire  uint32 // Expire is the upper limit on the time interval that can elapse before the zone is no longer authoritative.

     

       264
       264
       +
       	Minimum uint32 // Minimum is the minimum TTL field that should be exported with any RR from this zone.

     

       265
       265
       +
       }

     

       266
       266
       +
       

     

       267
       267
       +
       // MB represents the host with a specified mailbox.

     

       268
       268
       +
       type MB struct {

     

       269
       269
       +
       	MADName string

     

       270
       270
       +
       }

     

       271
       271
       +
       

     

       272
       272
       +
       // MG represents a mailbox which is configured for MGMName.

     

       273
       273
       +
       type MG struct {

     

       274
       274
       +
       	MGMName string

     

       275
       275
       +
       }

     

       276
       276
       +
       

     

       277
       277
       +
       // MR specifies the proper rename of a mailbox.

     

       278
       278
       +
       type MR struct {

     

       279
       279
       +
       	NEWName string

     

       280
       280
       +
       }

     

       281
       281
       +
       

     

       282
       282
       +
       // NULL can be anything as long as its under 65535 octets.

     

       283
       283
       +
       type NULL struct {

     

       284
       284
       +
       	Anything []byte

     

       285
       285
       +
       }

     

       286
       286
       +
       

     

       287
       287
       +
       // WKS specifies well known services supported by a protocol.

     

       288
       288
       +
       type WKS struct {

     

       289
       289
       +
       	Address  net.IP // Address is  a 32 bit Internet address.

     

       290
       290
       +
       	Protocol uint8  // Protocol is a 8 bit IP protocol number.

     

       291
       291
       +
       	BitMap   []byte // BitMap is a variable length bit map must be multiple of 8 bits.

     

       292
       292
       +
       }

     

       293
       293
       +
       

     

       294
       294
       +
       // PTR specifies to a location in the domain name space.

     

       295
       295
       +
       type PTR struct {

     

       296
       296
       +
       	PTRDName string

     

       297
       297
       +
       }

     

       298
       298
       +
       

     

       299
       299
       +
       // HINFO represents the general information about a server.

     

       300
       300
       +
       type HINFO struct {

     

       301
       301
       +
       	CPU string // CPU specifies the CPU type.

     

       302
       302
       +
       	OS  string // OS specifies the operating system.

     

       303
       303
       +
       }

     

       304
       304
       +
       

     

       305
       305
       +
       // MINFO represents mailing list information.

     

       306
       306
       +
       type MINFO struct {

     

       307
       307
       +
       	RMailBx string // RMailBx specifies the mailbox for a mailing list.

     

       308
       308
       +
       	EMailBx string // EMailBx specifes a mailbox for receiving errors.

     

       309
       309
       +
       }

     

       310
       310
       +
       

     

       311
       311
       +
       // MX represents a host acting as a mail exchange.

     

       312
       312
       +
       type MX struct {

     

       313
       313
       +
       	Preference uint16 // Preference specifies the preference with lower values being prefered.

     

       314
       314
       +
       	Exchange   string // Exchange specifies host acting for the name.

     

       315
       315
       +
       }

     

       316
       316
       +
       

     

       317
       317
       +
       // TXT represents one or more character strings.

     

       318
       318
       +
       type TXT struct {

     

       319
       319
       +
       	TxtData string

     

       320
       320
       +
       }

     

       321
       321
       +
       

     

       322
       322
       +
       // Reserved represents a record that is not yet implemented.

     

       323
       323
       +
       type Reserved struct {

     

       324
       324
       +
       	Bytes []byte

     

       325
       325
       +
       }

+45

utils.go

···

       1
       1
       +
       package magna

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"encoding/binary"

     

       5
       5
       +
       )

     

       6
       6
       +
       

     

       7
       7
       +
       // getU8 returns the first byte from a byte array at offset.

     

       8
       8
       +
       func getU8(buf []byte, offset int) (uint8, int, error) {

     

       9
       9
       +
       	next_offset := offset + 1

     

       10
       10
       +
       	if next_offset > len(buf) {

     

       11
       11
       +
       		return 0, len(buf), &BufferOverflowError{Length: len(buf), Offset: next_offset}

     

       12
       12
       +
       	}

     

       13
       13
       +
       

     

       14
       14
       +
       	return buf[offset], next_offset, nil

     

       15
       15
       +
       }

     

       16
       16
       +
       

     

       17
       17
       +
       // getU16 returns the bigEndian uint16 from a byte array at offset.

     

       18
       18
       +
       func getU16(buf []byte, offset int) (uint16, int, error) {

     

       19
       19
       +
       	next_offset := offset + 2

     

       20
       20
       +
       	if next_offset > len(buf) {

     

       21
       21
       +
       		return 0, len(buf), &BufferOverflowError{Length: len(buf), Offset: next_offset}

     

       22
       22
       +
       	}

     

       23
       23
       +
       

     

       24
       24
       +
       	return binary.BigEndian.Uint16(buf[offset:]), next_offset, nil

     

       25
       25
       +
       }

     

       26
       26
       +
       

     

       27
       27
       +
       // getU32 returns the bigEndian uint32 from a byte array at offset.

     

       28
       28
       +
       func getU32(buf []byte, offset int) (uint32, int, error) {

     

       29
       29
       +
       	next_offset := offset + 4

     

       30
       30
       +
       	if next_offset > len(buf) {

     

       31
       31
       +
       		return 0, len(buf), &BufferOverflowError{Length: len(buf), Offset: next_offset}

     

       32
       32
       +
       	}

     

       33
       33
       +
       

     

       34
       34
       +
       	return binary.BigEndian.Uint32(buf[offset:]), next_offset, nil

     

       35
       35
       +
       }

     

       36
       36
       +
       

     

       37
       37
       +
       // getSlice returns a slice of bytes from a byte array at an offset and of length.

     

       38
       38
       +
       func getSlice(buf []byte, offset int, length int) ([]byte, int, error) {

     

       39
       39
       +
       	next_offset := offset + length

     

       40
       40
       +
       	if next_offset > len(buf) {

     

       41
       41
       +
       		return nil, len(buf), &BufferOverflowError{Length: len(buf), Offset: next_offset}

     

       42
       42
       +
       	}

     

       43
       43
       +
       

     

       44
       44
       +
       	return buf[offset:next_offset], next_offset, nil

     

       45
       45
       +
       }

+69

utils_test.go

···

       1
       1
       +
       package magna

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"testing"

     

       5
       5
       +
       )

     

       6
       6
       +
       

     

       7
       7
       +
       func TestU8(t *testing.T) {

     

       8
       8
       +
       	buf := []byte{

     

       9
       9
       +
       		0x01,

     

       10
       10
       +
       	}

     

       11
       11
       +
       

     

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

     

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

     

       14
       14
       +
       	assert_eq(t, 1, offset)

     

       15
       15
       +
       	assert_no_error(t, err)

     

       16
       16
       +
       

     

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

     

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

     

       19
       19
       +
       	assert_eq(t, 1, offset)

     

       20
       20
       +
       	assert_error(t, err)

     

       21
       21
       +
       }

     

       22
       22
       +
       

     

       23
       23
       +
       func TestU16(t *testing.T) {

     

       24
       24
       +
       	buf := []byte{

     

       25
       25
       +
       		0x00, 0x01,

     

       26
       26
       +
       	}

     

       27
       27
       +
       

     

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

     

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

     

       30
       30
       +
       	assert_eq(t, 2, offset)

     

       31
       31
       +
       	assert_no_error(t, err)

     

       32
       32
       +
       

     

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

     

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

     

       35
       35
       +
       	assert_eq(t, 2, offset)

     

       36
       36
       +
       	assert_error(t, err)

     

       37
       37
       +
       }

     

       38
       38
       +
       

     

       39
       39
       +
       func TestU32(t *testing.T) {

     

       40
       40
       +
       	buf := []byte{

     

       41
       41
       +
       		0x00, 0x00, 0x00, 0x01,

     

       42
       42
       +
       	}

     

       43
       43
       +
       

     

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

     

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

     

       46
       46
       +
       	assert_eq(t, 4, offset)

     

       47
       47
       +
       	assert_no_error(t, err)

     

       48
       48
       +
       

     

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

     

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

     

       51
       51
       +
       	assert_eq(t, 4, offset)

     

       52
       52
       +
       	assert_error(t, err)

     

       53
       53
       +
       }

     

       54
       54
       +
       

     

       55
       55
       +
       func TestSlice(t *testing.T) {

     

       56
       56
       +
       	buf := []byte{

     

       57
       57
       +
       		0x62, 0x6c, 0x75,

     

       58
       58
       +
       	}

     

       59
       59
       +
       

     

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

     

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

     

       62
       62
       +
       	assert_eq(t, 3, offset)

     

       63
       63
       +
       	assert_no_error(t, err)

     

       64
       64
       +
       

     

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

     

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

     

       67
       67
       +
       	assert_eq(t, 3, offset)

     

       68
       68
       +
       	assert_error(t, err)

     

       69
       69
       +
       }