comparing codereview and feature/tangled-ci on seiso.moe/magna

+30 -31

domain_name.go

···

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
        
       	"encoding/binary"

     

       5
       5
       +
       	"fmt"

     

       5
       6
        
       	"strings"

     

       6
       7
        
       )

     

       7
       8
        
       

     

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

     

       9
       9
       +
       // decodeDomain decodes a domain name from a buffer starting at offset.

     

       9
       10
        
       // 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
       +
       func decodeDomain(buf []byte, offset int) (string, int, error) {

     

       11
       12
        
       	var builder strings.Builder

     

       12
       13
        
       	firstLabel := true

     

       13
       14
        
       

     

       14
       14
       -
       	seen_offsets := make(map[int]struct{})

     

       15
       15
       +
       	seenOffsets := make(map[int]struct{})

     

       15
       16
        
       	finalOffsetAfterJump := -1

     

       16
       17
        
       

     

       17
       18
        
       	currentOffset := offset

     

       18
       19
        
       

     

       19
       20
        
       	for {

     

       20
       20
       -
       		if _, found := seen_offsets[currentOffset]; found {

     

       21
       21
       +
       		if _, found := seenOffsets[currentOffset]; found {

     

       21
       22
        
       			return "", len(buf), &DomainCompressionError{}

     

       22
       23
        
       		}

     

       23
       23
       -
       		seen_offsets[currentOffset] = struct{}{}

     

       24
       24
       +
       		seenOffsets[currentOffset] = struct{}{}

     

       24
       25
        
       

     

       25
       26
        
       		length, nextOffsetAfterLen, err := getU8(buf, currentOffset)

     

       26
       27
        
       		if err != nil {

     

       27
       27
       -
       			return "", len(buf), err

     

       28
       28
       +
       			return "", len(buf), fmt.Errorf("failed to read domain label length: %w", err)

     

       28
       29
        
       		}

     

       29
       30
        
       

     

       30
       31
        
       		if length == 0 {

     
···

       35
       36
        
       		if (length & 0xC0) == 0xC0 {

     

       36
       37
        
       			sec, nextOffsetAfterPtr, err := getU8(buf, nextOffsetAfterLen)

     

       37
       38
        
       			if err != nil {

     

       38
       38
       -
       				return "", len(buf), err

     

       39
       39
       +
       				return "", len(buf), fmt.Errorf("failed to read domain compression pointer offset byte: %w", err)

     

       39
       40
        
       			}

     

       40
       41
        
       

     

       41
       42
        
       			jumpTargetOffset := int(length&0x3F)<<8 | int(sec)

     
···

       43
       44
        
       			if jumpTargetOffset >= len(buf) {

     

       44
       45
        
       				return "", len(buf), &BufferOverflowError{Length: len(buf), Offset: jumpTargetOffset}

     

       45
       46
        
       			}

     

       46
       46
       -
       			if _, found := seen_offsets[jumpTargetOffset]; found {

     

       47
       47
       +
       			if _, found := seenOffsets[jumpTargetOffset]; found {

     

       47
       48
        
       				return "", len(buf), &DomainCompressionError{}

     

       48
       49
        
       			}

     

       49
       50
        
       

     
···

       61
       62
        
       

     

       62
       63
        
       		labelBytes, nextOffsetAfterLabel, err := getSlice(buf, nextOffsetAfterLen, int(length))

     

       63
       64
        
       		if err != nil {

     

       64
       64
       -
       			return "", len(buf), err

     

       65
       65
       +
       			return "", len(buf), fmt.Errorf("failed to read domain label data: %w", err)

     

       65
       66
        
       		}

     

       66
       67
        
       

     

       67
       68
        
       		if !firstLabel {

     
···

       82
       83
        
       	return builder.String(), finalReadOffset, nil

     

       83
       84
        
       }

     

       84
       85
        
       

     

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

     

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

     

       87
       87
       -
       	if domain_name == "." || domain_name == "" {

     

       88
       88
       -
       		return append(bytes, 0)

     

       86
       86
       +
       // encodeDomain returns the bytes of the input bytes appened with the encoded domain name.

     

       87
       87
       +
       func encodeDomain(bytes []byte, domainName string, offsets *map[string]uint16) ([]byte, error) {

     

       88
       88
       +
       	if domainName == "." || domainName == "" {

     

       89
       89
       +
       		return append(bytes, 0), nil

     

       89
       90
        
       	}

     

       90
       91
        
       

     

       91
       91
       -
       	clean_domain := strings.TrimSuffix(domain_name, ".")

     

       92
       92
       -
       	if clean_domain == "" {

     

       93
       93
       -
       		return append(bytes, 0)

     

       92
       92
       +
       	cleanDomain := strings.TrimSuffix(domainName, ".")

     

       93
       93
       +
       	if cleanDomain == "" {

     

       94
       94
       +
       		return append(bytes, 0), nil

     

       94
       95
        
       	}

     

       95
       96
        
       

     

       96
       97
        
       	start := 0

     

       97
       97
       -
       	for start < len(clean_domain) {

     

       98
       98
       -
       		suffix := clean_domain[start:]

     

       98
       98
       +
       	for start < len(cleanDomain) {

     

       99
       99
       +
       		suffix := cleanDomain[start:]

     

       99
       100
        
       

     

       100
       101
        
       		if offset, found := (*offsets)[suffix]; found {

     

       101
       101
       -
       			if offset > 0x3FFF {

     

       102
       102
       -
       				end := strings.IndexByte(suffix, '.')

     

       103
       103
       -
       				if end == -1 {

     

       104
       104
       -
       					end = len(suffix)

     

       105
       105
       -
       				}

     

       106
       106
       -
       			} else {

     

       107
       107
       -
       				pointer := 0xC000 | offset

     

       108
       108
       -
       				return binary.BigEndian.AppendUint16(bytes, pointer)

     

       109
       109
       -
       			}

     

       102
       102
       +
       			pointer := 0xC000 | offset

     

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

     

       104
       104
       +
       			return bytes, nil

     

       110
       105
        
       		}

     

       111
       106
        
       

     

       112
       107
        
       		currentPos := uint16(len(bytes))

     
···

       116
       111
        
       

     

       117
       112
        
       		end := strings.IndexByte(suffix, '.')

     

       118
       113
        
       		var label string

     

       119
       119
       -
       		nextStart := len(clean_domain)

     

       114
       114
       +
       		nextStart := len(cleanDomain)

     

       120
       115
        
       

     

       121
       116
        
       		if end == -1 {

     

       122
       117
        
       			label = suffix

     
···

       130
       125
        
       		labelBytes := []byte(label)

     

       131
       126
        
       

     

       132
       127
        
       		if len(labelBytes) > 63 {

     

       133
       133
       -
       			// XXX: maybe should return an error

     

       134
       134
       -
       			labelBytes = labelBytes[:63]

     

       128
       128
       +
       			return nil, &InvalidLabelError{Length: int(len(labelBytes))}

     

       129
       129
       +
       		}

     

       130
       130
       +
       

     

       131
       131
       +
       		if len(labelBytes) == 0 && start < len(cleanDomain) {

     

       132
       132
       +
       			return nil, &InvalidLabelError{Length: 0}

     

       135
       133
        
       		}

     

       136
       134
        
       

     

       137
       135
        
       		bytes = append(bytes, byte(len(labelBytes)))

     

       138
       136
        
       		bytes = append(bytes, labelBytes...)

     

       139
       137
        
       	}

     

       140
       138
        
       

     

       141
       141
       -
       	return append(bytes, 0)

     

       139
       139
       +
       	bytes = append(bytes, 0)

     

       140
       140
       +
       	return bytes, nil

     

       142
       141
        
       }

+143 -22

domain_test.go

···

       1
       1
        
       package magna

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"errors"

     

       4
       5
        
       	"testing"

     

       5
       6
        
       

     

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

     
···

       9
       10
        
       func BenchmarkDecodeDomainSimple(b *testing.B) {

     

       10
       11
        
       	input := []byte{3, 'w', 'w', 'w', 7, 'e', 'x', 'a', 'm', 'p', 'l', 'e', 3, 'c', 'o', 'm', 0}

     

       11
       12
        
       	for i := 0; i < b.N; i++ {

     

       12
       12
       -
       		_, _, _ = decode_domain(input, 0)

     

       13
       13
       +
       		_, _, _ = decodeDomain(input, 0)

     

       13
       14
        
       	}

     

       14
       15
        
       }

     

       15
       16
        
       

     
···

       21
       22
        
       	offset := 13

     

       22
       23
        
       	b.ResetTimer()

     

       23
       24
        
       	for i := 0; i < b.N; i++ {

     

       24
       24
       -
       		_, _, _ = decode_domain(input, offset)

     

       25
       25
       +
       		_, _, _ = decodeDomain(input, offset)

     

       25
       26
        
       	}

     

       26
       27
        
       }

     

       27
       28
        
       

     
···

       31
       32
        
       	out := make([]byte, 0, 64)

     

       32
       33
        
       	b.ResetTimer()

     

       33
       34
        
       	for i := 0; i < b.N; i++ {

     

       34
       34
       -
       		_ = encode_domain(out[:0], domain, &offsets)

     

       35
       35
       +
       		_, _ = encodeDomain(out[:0], domain, &offsets)

     

       35
       36
        
       		for k := range offsets {

     

       36
       37
        
       			delete(offsets, k)

     

       37
       38
        
       		}

     
···

       45
       46
        
       	out := make([]byte, 0, 128)

     

       46
       47
        
       	b.ResetTimer()

     

       47
       48
        
       	for i := 0; i < b.N; i++ {

     

       48
       48
       -
       		tempOut := encode_domain(out[:0], domain1, &offsets)

     

       49
       49
       -
       		_ = encode_domain(tempOut, domain2, &offsets)

     

       49
       49
       +
       		tempOut, _ := encodeDomain(out[:0], domain1, &offsets)

     

       50
       50
       +
       		_, _ = encodeDomain(tempOut, domain2, &offsets)

     

       50
       51
        
       		for k := range offsets {

     

       51
       52
        
       			delete(offsets, k)

     

       52
       53
        
       		}

     
···

       61
       62
        
       		expectedDomain string

     

       62
       63
        
       		expectedOffset int

     

       63
       64
        
       		expectedError  error

     

       65
       65
       +
       		errorCheck     func(t *testing.T, err error)

     

       64
       66
        
       	}{

     

       65
       67
        
       		{

     

       66
       68
        
       			name:           "Simple domain",

     
···

       83
       85
        
       			expectedDomain: "",

     

       84
       86
        
       			expectedOffset: 2,

     

       85
       87
        
       			expectedError:  &InvalidLabelError{Length: 64},

     

       88
       88
       +
       			errorCheck: func(t *testing.T, err error) {

     

       89
       89
       +
       				var target *InvalidLabelError

     

       90
       90
       +
       				assert.True(t, errors.As(err, &target))

     

       91
       91
       +
       				assert.Equal(t, 64, target.Length)

     

       92
       92
       +
       			},

     

       86
       93
        
       		},

     

       87
       94
        
       		{

     

       88
       95
        
       			name:           "Compression loop",

     
···

       90
       97
        
       			expectedDomain: "",

     

       91
       98
        
       			expectedOffset: 4,

     

       92
       99
        
       			expectedError:  &DomainCompressionError{},

     

       100
       100
       +
       			errorCheck: func(t *testing.T, err error) {

     

       101
       101
       +
       				assert.IsType(t, &DomainCompressionError{}, err)

     

       102
       102
       +
       			},

     

       93
       103
        
       		},

     

       94
       104
        
       		{

     

       95
       105
        
       			name:           "Truncated input",

     
···

       97
       107
        
       			expectedDomain: "",

     

       98
       108
        
       			expectedOffset: 3,

     

       99
       109
        
       			expectedError:  &BufferOverflowError{Length: 3, Offset: 4},

     

       110
       110
       +
       			errorCheck: func(t *testing.T, err error) {

     

       111
       111
       +
       				var target *BufferOverflowError

     

       112
       112
       +
       				assert.True(t, errors.As(err, &target), "Expected BufferOverflowError")

     

       113
       113
       +
       				if target != nil {

     

       114
       114
       +
       					assert.Equal(t, 3, target.Length)

     

       115
       115
       +
       					assert.Equal(t, 1+3, target.Offset)

     

       116
       116
       +
       				}

     

       117
       117
       +
       				assert.Contains(t, err.Error(), "failed to read domain label data")

     

       118
       118
       +
       			},

     

       100
       119
        
       		},

     

       101
       120
        
       	}

     

       102
       121
        
       

     

       103
       122
        
       	for _, tt := range tests {

     

       104
       123
        
       		t.Run(tt.name, func(t *testing.T) {

     

       105
       105
       -
       			domain, offset, err := decode_domain(tt.input, tt.offset)

     

       124
       124
       +
       			domain, offset, err := decodeDomain(tt.input, tt.offset)

     

       106
       125
        
       

     

       107
       107
       -
       			t.Log(tt.name)

     

       108
       108
       -
       			assert.Equal(t, tt.expectedError, err)

     

       109
       109
       -
       			assert.Equal(t, tt.expectedDomain, domain)

     

       110
       110
       -
       			assert.Equal(t, tt.expectedOffset, offset)

     

       126
       126
       +
       			t.Logf("Test: %s, Input: %x, OffsetIn: %d => Domain: '%s', OffsetOut: %d, Err: %v", tt.name, tt.input, tt.offset, domain, offset, err)

     

       127
       127
       +
       

     

       128
       128
       +
       			if tt.expectedError != nil {

     

       129
       129
       +
       				assert.Error(t, err, "Expected an error but got nil")

     

       130
       130
       +
       				if tt.errorCheck != nil {

     

       131
       131
       +
       					tt.errorCheck(t, err)

     

       132
       132
       +
       				} else {

     

       133
       133
       +
       					assert.IsType(t, tt.expectedError, err, "Error type mismatch")

     

       134
       134
       +
       				}

     

       135
       135
       +
       			} else {

     

       136
       136
       +
       				assert.NoError(t, err, "Expected no error but got one")

     

       137
       137
       +
       			}

     

       138
       138
       +
       

     

       139
       139
       +
       			assert.Equal(t, tt.expectedDomain, domain, "Domain mismatch")

     

       140
       140
       +
       			if tt.expectedError == nil {

     

       141
       141
       +
       				assert.Equal(t, tt.expectedOffset, offset, "Offset mismatch")

     

       142
       142
       +
       			}

     

       111
       143
        
       		})

     

       112
       144
        
       	}

     

       113
       145
        
       }

     

       114
       146
        
       

     

       115
       147
        
       func TestEncodeDomain(t *testing.T) {

     

       116
       148
        
       	tests := []struct {

     

       117
       117
       -
       		name       string

     

       118
       118
       -
       		input      string

     

       119
       119
       -
       		offsets    map[string]uint16

     

       120
       120
       -
       		expected   []byte

     

       121
       121
       -
       		newOffsets map[string]uint16

     

       149
       149
       +
       		name        string

     

       150
       150
       +
       		input       string

     

       151
       151
       +
       		initialBuf  []byte

     

       152
       152
       +
       		offsets     map[string]uint16

     

       153
       153
       +
       		expected    []byte

     

       154
       154
       +
       		expectedErr error

     

       155
       155
       +
       		newOffsets  map[string]uint16

     

       122
       156
        
       	}{

     

       123
       157
        
       		{

     

       124
       158
        
       			name:       "Simple domain",

     

       125
       159
        
       			input:      "example.com",

     

       160
       160
       +
       			initialBuf: []byte{},

     

       126
       161
        
       			offsets:    make(map[string]uint16),

     

       127
       162
        
       			expected:   []byte{7, 'e', 'x', 'a', 'm', 'p', 'l', 'e', 3, 'c', 'o', 'm', 0},

     

       128
       163
        
       			newOffsets: map[string]uint16{"example.com": 0, "com": 8},

     

       129
       164
        
       		},

     

       130
       165
        
       		{

     

       131
       131
       -
       			name:       "Domain with existing offset",

     

       166
       166
       +
       			name:       "Domain with existing offset for compression",

     

       132
       167
        
       			input:      "test.example.com",

     

       168
       168
       +
       			initialBuf: []byte{},

     

       133
       169
        
       			offsets:    map[string]uint16{"example.com": 10},

     

       134
       170
        
       			expected:   []byte{4, 't', 'e', 's', 't', 0xC0, 0x0A},

     

       135
       171
        
       			newOffsets: map[string]uint16{"test.example.com": 0, "example.com": 10},

     
···

       137
       173
        
       		{

     

       138
       174
        
       			name:       "Multiple subdomains",

     

       139
       175
        
       			input:      "a.b.c.d",

     

       176
       176
       +
       			initialBuf: []byte{},

     

       140
       177
        
       			offsets:    make(map[string]uint16),

     

       141
       178
        
       			expected:   []byte{1, 'a', 1, 'b', 1, 'c', 1, 'd', 0},

     

       142
       179
        
       			newOffsets: map[string]uint16{"a.b.c.d": 0, "b.c.d": 2, "c.d": 4, "d": 6},

     

       143
       180
        
       		},

     

       181
       181
       +
       		{

     

       182
       182
       +
       			name:       "Root domain",

     

       183
       183
       +
       			input:      ".",

     

       184
       184
       +
       			initialBuf: []byte{},

     

       185
       185
       +
       			offsets:    make(map[string]uint16),

     

       186
       186
       +
       			expected:   []byte{0},

     

       187
       187
       +
       			newOffsets: map[string]uint16{},

     

       188
       188
       +
       		},

     

       189
       189
       +
       		{

     

       190
       190
       +
       			name:       "Empty domain",

     

       191
       191
       +
       			input:      "",

     

       192
       192
       +
       			initialBuf: []byte{},

     

       193
       193
       +
       			offsets:    make(map[string]uint16),

     

       194
       194
       +
       			expected:   []byte{0},

     

       195
       195
       +
       			newOffsets: map[string]uint16{},

     

       196
       196
       +
       		},

     

       197
       197
       +
       		{

     

       198
       198
       +
       			name:        "Label too long",

     

       199
       199
       +
       			input:       "labeltoolonglabeltoolonglabeltoolonglabeltoolonglabeltoolonglabeltoolong.com",

     

       200
       200
       +
       			initialBuf:  []byte{},

     

       201
       201
       +
       			offsets:     make(map[string]uint16),

     

       202
       202
       +
       			expected:    nil,

     

       203
       203
       +
       			expectedErr: &InvalidLabelError{Length: 72},

     

       204
       204
       +
       			newOffsets:  map[string]uint16{},

     

       205
       205
       +
       		},

     

       206
       206
       +
       		{

     

       207
       207
       +
       			name:        "Empty label inside domain",

     

       208
       208
       +
       			input:       "example..com",

     

       209
       209
       +
       			initialBuf:  []byte{},

     

       210
       210
       +
       			offsets:     make(map[string]uint16),

     

       211
       211
       +
       			expected:    nil,

     

       212
       212
       +
       			expectedErr: &InvalidLabelError{Length: 0},

     

       213
       213
       +
       			newOffsets:  map[string]uint16{},

     

       214
       214
       +
       		},

     

       215
       215
       +
       		{

     

       216
       216
       +
       			name:       "Append to existing buffer",

     

       217
       217
       +
       			input:      "example.com",

     

       218
       218
       +
       			initialBuf: []byte{0xAA, 0xBB},

     

       219
       219
       +
       			offsets:    make(map[string]uint16),

     

       220
       220
       +
       			expected:   []byte{0xAA, 0xBB, 7, 'e', 'x', 'a', 'm', 'p', 'l', 'e', 3, 'c', 'o', 'm', 0},

     

       221
       221
       +
       			newOffsets: map[string]uint16{"example.com": 2, "com": 10},

     

       222
       222
       +
       		},

     

       144
       223
        
       	}

     

       145
       224
        
       

     

       146
       225
        
       	for _, tt := range tests {

     

       147
       226
        
       		t.Run(tt.name, func(t *testing.T) {

     

       148
       148
       -
       			result := encode_domain([]byte{}, tt.input, &tt.offsets)

     

       149
       149
       -
       			assert.Equal(t, tt.expected, result, "Encoded domain does not match expected output")

     

       150
       150
       -
       			assert.Equal(t, tt.newOffsets, tt.offsets, "Offsets map does not match expected state")

     

       227
       227
       +
       			currentOffsets := make(map[string]uint16)

     

       228
       228
       +
       			for k, v := range tt.offsets {

     

       229
       229
       +
       				currentOffsets[k] = v

     

       230
       230
       +
       			}

     

       231
       231
       +
       

     

       232
       232
       +
       			result, err := encodeDomain(tt.initialBuf, tt.input, &currentOffsets)

     

       233
       233
       +
       

     

       234
       234
       +
       			if tt.expectedErr != nil {

     

       235
       235
       +
       				assert.Error(t, err, "Expected an error but got nil")

     

       236
       236
       +
       				assert.IsType(t, tt.expectedErr, err, "Error type mismatch")

     

       237
       237
       +
       				if expectedILE, ok := tt.expectedErr.(*InvalidLabelError); ok {

     

       238
       238
       +
       					actualILE := &InvalidLabelError{}

     

       239
       239
       +
       					if assert.True(t, errors.As(err, &actualILE)) {

     

       240
       240
       +
       						assert.Equal(t, expectedILE.Length, actualILE.Length)

     

       241
       241
       +
       					}

     

       242
       242
       +
       				}

     

       243
       243
       +
       			} else {

     

       244
       244
       +
       				assert.NoError(t, err, "Expected no error but got one")

     

       245
       245
       +
       				assert.Equal(t, tt.expected, result, "Encoded domain does not match expected output")

     

       246
       246
       +
       				assert.Equal(t, tt.newOffsets, currentOffsets, "Offsets map does not match expected state")

     

       247
       247
       +
       			}

     

       151
       248
        
       		})

     

       152
       249
        
       	}

     

       153
       250
        
       }

     
···

       158
       255
        
       			0x03, 0x63, 0x6f, 0x6d, 0x00,

     

       159
       256
        
       		},

     

       160
       257
        
       		{

     

       161
       161
       -
       			0x03, 0x63, 0x6f, 0x6d, 0x00, 0x01, 0x63, 0xC0, 0x00,

     

       258
       258
       +
       			0x03, 0x63, 0x6f, 0x6d, 0x00, 0x01, 0x63, 0xc0, 0x00,

     

       259
       259
       +
       		},

     

       260
       260
       +
       		{

     

       261
       261
       +
       			0x03, 0x63, 0x6f, 0x6d, 0xc0, 0x00,

     

       262
       262
       +
       		},

     

       263
       263
       +
       		{

     

       264
       264
       +
       			0xc0, 0x00,

     

       162
       265
        
       		},

     

       163
       266
        
       		{

     

       164
       164
       -
       			0x03, 0x63, 0x6f, 0x6d, 0xC0, 0x00,

     

       267
       267
       +
       			0xc0, 0xff,

     

       268
       268
       +
       		},

     

       269
       269
       +
       		{

     

       270
       270
       +
       			0x40,

     

       271
       271
       +
       		},

     

       272
       272
       +
       		{

     

       273
       273
       +
       			0x03, 0x63, 0x6f,

     

       274
       274
       +
       		},

     

       275
       275
       +
       		{

     

       276
       276
       +
       			0xc0,

     

       165
       277
        
       		},

     

       166
       278
        
       	}

     

       167
       279
        
       	for _, tc := range testcases {

     

       168
       280
        
       		f.Add(tc)

     

       169
       281
        
       	}

     

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

     

       171
       171
       -
       		decode_domain(msg, 0)

     

       283
       283
       +
       		_, _, err := decodeDomain(msg, 0)

     

       284
       284
       +
       		if err != nil {

     

       285
       285
       +
       			var bufErr *BufferOverflowError

     

       286
       286
       +
       			var labelErr *InvalidLabelError

     

       287
       287
       +
       			var compErr *DomainCompressionError

     

       288
       288
       +
       

     

       289
       289
       +
       			if !(errors.As(err, &bufErr) || errors.As(err, &labelErr) || errors.As(err, &compErr)) {

     

       290
       290
       +
       				t.Errorf("Fuzzing decodeDomain: unexpected error type %T: %v for input %x", err, err, msg)

     

       291
       291
       +
       			}

     

       292
       292
       +
       		}

     

       172
       293
        
       	})

     

       173
       294
        
       }

+24 -10

errors.go

···

       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)

     

       14
       14
       +
       	return fmt.Sprintf("buffer overflow: attempted to read past buffer length %d at offset %d", e.Length, e.Offset)

     

       15
       15
       +
       }

     

       16
       16
       +
       

     

       17
       17
       +
       func (e *BufferOverflowError) Is(target error) bool {

     

       18
       18
       +
       	_, ok := target.(*BufferOverflowError)

     

       19
       19
       +
       	return ok

     

       15
       20
        
       }

     

       16
       21
        
       

     

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

     
···

       20
       25
        
       }

     

       21
       26
        
       

     

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

     

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

     

       28
       28
       +
       	if e.Length > 63 {

     

       29
       29
       +
       		return fmt.Sprintf("invalid domain label: length %d exceeds maximum 63", e.Length)

     

       30
       30
       +
       	}

     

       31
       31
       +
       	if e.Length == 0 {

     

       32
       32
       +
       		return "invalid domain label: zero length label encountered"

     

       33
       33
       +
       	}

     

       34
       34
       +
       

     

       35
       35
       +
       	// XXX: this should be unreachable

     

       36
       36
       +
       	return fmt.Sprintf("invalid domain label: unexpected length %d", e.Length)

     

       37
       37
       +
       }

     

       38
       38
       +
       

     

       39
       39
       +
       func (e *InvalidLabelError) Is(target error) bool {

     

       40
       40
       +
       	_, ok := target.(*InvalidLabelError)

     

       41
       41
       +
       	return ok

     

       24
       42
        
       }

     

       25
       43
        
       

     

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

     

       27
       45
        
       type DomainCompressionError struct{}

     

       28
       46
        
       

     

       29
       47
        
       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

     

       48
       48
       +
       	return "invalid domain compression: pointer loop detected"

     

       36
       49
        
       }

     

       37
       50
        
       

     

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

     

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

     

       51
       51
       +
       func (e *DomainCompressionError) Is(target error) bool {

     

       52
       52
       +
       	_, ok := target.(*DomainCompressionError)

     

       53
       53
       +
       	return ok

     

       40
       54
        
       }

+8 -28

errors_test.go

···

       1
       1
        
       package magna

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       -
       	"fmt"

     

       5
       4
        
       	"testing"

     

       6
       5
        
       

     

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

     
···

       14
       13
        
       		offset   int

     

       15
       14
        
       		expected string

     

       16
       15
        
       	}{

     

       17
       17
       -
       		{"PositiveOffset", 10, 15, "magna: offset 15 is past the buffer length 10"},

     

       18
       18
       -
       		{"ZeroLengthBuffer", 0, 5, "magna: offset 5 is past the buffer length 0"},

     

       19
       19
       -
       		{"NegativeOffset", 10, -1, "magna: offset -1 is past the buffer length 10"},

     

       20
       20
       -
       		{"EqualOffset", 10, 10, "magna: offset 10 is past the buffer length 10"},

     

       16
       16
       +
       		{"PositiveOffset", 10, 15, "buffer overflow: attempted to read past buffer length 10 at offset 15"},

     

       17
       17
       +
       		{"ZeroLengthBuffer", 0, 5, "buffer overflow: attempted to read past buffer length 0 at offset 5"},

     

       18
       18
       +
       		{"NegativeOffset", 10, -1, "buffer overflow: attempted to read past buffer length 10 at offset -1"},

     

       19
       19
       +
       		{"EqualOffset", 10, 10, "buffer overflow: attempted to read past buffer length 10 at offset 10"},

     

       21
       20
        
       	}

     

       22
       21
        
       

     

       23
       22
        
       	for _, tt := range tests {

     
···

       34
       33
        
       		length   int

     

       35
       34
        
       		expected string

     

       36
       35
        
       	}{

     

       37
       37
       -
       		{"LengthTooLarge", 64, "magna: received invalid label length 64"},

     

       38
       38
       -
       		{"LengthZero", 0, "magna: received invalid label length 0"},

     

       39
       39
       -
       		{"NegativeLength", -1, "magna: received invalid label length -1"},

     

       36
       36
       +
       		{"LengthTooLarge", 64, "invalid domain label: length 64 exceeds maximum 63"},

     

       37
       37
       +
       		{"LengthZero", 0, "invalid domain label: zero length label encountered"},

     

       38
       38
       +
       		{"ValidLength", 30, "invalid domain label: unexpected length 30"},

     

       40
       39
        
       	}

     

       41
       40
        
       

     

       42
       41
        
       	for _, tt := range tests {

     
···

       50
       49
        
       func TestDomainCompressionError(t *testing.T) {

     

       51
       50
        
       	t.Run("Standard", func(t *testing.T) {

     

       52
       51
        
       		err := &DomainCompressionError{}

     

       53
       53
       -
       		expected := "magna: loop detected in domain compression"

     

       52
       52
       +
       		expected := "invalid domain compression: pointer loop detected"

     

       54
       53
        
       		assert.Equal(t, expected, err.Error(), "Error() output mismatch")

     

       55
       54
        
       	})

     

       56
       55
        
       }

     

       57
       57
       -
       

     

       58
       58
       -
       func TestMagnaError(t *testing.T) {

     

       59
       59
       -
       	tests := []struct {

     

       60
       60
       -
       		name     string

     

       61
       61
       -
       		message  string

     

       62
       62
       -
       		expected string

     

       63
       63
       -
       	}{

     

       64
       64
       -
       		{"EmptyMessage", "", "magna: "},

     

       65
       65
       -
       		{"SimpleMessage", "test error", "magna: test error"},

     

       66
       66
       -
       		{"MessageWithPunctuation", "error: invalid input!", "magna: error: invalid input!"},

     

       67
       67
       -
       	}

     

       68
       68
       -
       

     

       69
       69
       -
       	for _, tt := range tests {

     

       70
       70
       -
       		t.Run(tt.name, func(t *testing.T) {

     

       71
       71
       -
       			err := &MagnaError{Message: tt.message}

     

       72
       72
       -
       			assert.Equal(t, tt.expected, err.Error())

     

       73
       73
       -
       		})

     

       74
       74
       -
       	}

     

       75
       75
       -
       }

+10 -7

header.go

···

       1
       1
        
       package magna

     

       2
       2
        
       

     

       3
       3
       -
       import "encoding/binary"

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"encoding/binary"

     

       5
       5
       +
       	"fmt"

     

       6
       6
       +
       )

     

       4
       7
        
       

     

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

     

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

     

       7
       10
        
       	var err error

     

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

     

       9
       12
        
       	if err != nil {

     

       10
       10
       -
       		return len(buf), err

     

       13
       13
       +
       		return len(buf), fmt.Errorf("header decode: failed to read ID: %w", err)

     

       11
       14
        
       	}

     

       12
       15
        
       

     

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

     

       14
       17
        
       	if err != nil {

     

       15
       15
       -
       		return len(buf), err

     

       18
       18
       +
       		return len(buf), fmt.Errorf("header decode: failed to read flags: %w", err)

     

       16
       19
        
       	}

     

       17
       20
        
       

     

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

     

       19
       22
        
       	if err != nil {

     

       20
       20
       -
       		return len(buf), err

     

       23
       23
       +
       		return len(buf), fmt.Errorf("header decode: failed to read QDCount: %w", err)

     

       21
       24
        
       	}

     

       22
       25
        
       

     

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

     

       24
       27
        
       	if err != nil {

     

       25
       25
       -
       		return len(buf), err

     

       28
       28
       +
       		return len(buf), fmt.Errorf("header decode: failed to read ANCount: %w", err)

     

       26
       29
        
       	}

     

       27
       30
        
       

     

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

     

       29
       32
        
       	if err != nil {

     

       30
       30
       -
       		return len(buf), err

     

       33
       33
       +
       		return len(buf), fmt.Errorf("header decode: failed to read NSCount: %w", err)

     

       31
       34
        
       	}

     

       32
       35
        
       

     

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

     

       34
       37
        
       	if err != nil {

     

       35
       35
       -
       		return len(buf), err

     

       38
       38
       +
       		return len(buf), fmt.Errorf("header decode: failed to read ARCount: %w", err)

     

       36
       39
        
       	}

     

       37
       40
        
       

     

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

+81 -60

header_test.go

···

       1
       1
        
       package magna

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"bytes"

     

       4
       5
        
       	"encoding/binary"

     

       6
       6
       +
       	"errors"

     

       5
       7
        
       	"testing"

     

       6
       8
        
       

     

       7
       9
        
       	"github.com/stretchr/testify/assert"

     

       10
       10
       +
       	"github.com/stretchr/testify/require"

     

       8
       11
        
       )

     

       9
       12
        
       

     

       10
       13
        
       func TestHeaderDecode(t *testing.T) {

     
···

       14
       17
        
       		expectedHeader Header

     

       15
       18
        
       		expectedOffset int

     

       16
       19
        
       		expectedErr    error

     

       20
       20
       +
       		wantErrMsg     string

     

       17
       21
        
       	}{

     

       18
       22
        
       		{

     

       19
       23
        
       			name:  "Valid header",

     
···

       37
       41
        
       			expectedErr:    nil,

     

       38
       42
        
       		},

     

       39
       43
        
       		{

     

       40
       40
       -
       			name:           "Insufficient buffer length",

     

       44
       44
       +
       			name:           "Insufficient buffer length for Flags",

     

       41
       45
        
       			input:          []byte{0x12, 0x34, 0x81},

     

       42
       42
       -
       			expectedHeader: Header{},

     

       46
       46
       +
       			expectedHeader: Header{ID: 0x1234},

     

       43
       47
        
       			expectedOffset: 3,

     

       44
       44
       -
       			expectedErr:    &BufferOverflowError{Length: 3, Offset: 3},

     

       48
       48
       +
       			expectedErr:    &BufferOverflowError{},

     

       49
       49
       +
       			wantErrMsg:     "header decode: failed to read flags",

     

       45
       50
        
       		},

     

       46
       51
        
       		{

     

       47
       47
       -
       			name:           "Invalid ID",

     

       52
       52
       +
       			name:           "Insufficient buffer length for ID",

     

       48
       53
        
       			input:          []byte{0x12},

     

       49
       54
        
       			expectedHeader: Header{},

     

       50
       55
        
       			expectedOffset: 1,

     

       51
       51
       -
       			expectedErr:    &BufferOverflowError{Length: 1, Offset: 1},

     

       56
       56
       +
       			expectedErr:    &BufferOverflowError{},

     

       57
       57
       +
       			wantErrMsg:     "header decode: failed to read ID",

     

       52
       58
        
       		},

     

       53
       59
        
       		{

     

       54
       60
        
       			name:           "Missing QDCount",

     

       55
       61
        
       			input:          []byte{0x12, 0x34, 0x81, 0x80, 0x00},

     

       56
       56
       -
       			expectedHeader: Header{},

     

       62
       62
       +
       			expectedHeader: Header{ID: 0x1234},

     

       57
       63
        
       			expectedOffset: 5,

     

       58
       64
        
       			expectedErr:    &BufferOverflowError{},

     

       65
       65
       +
       			wantErrMsg:     "header decode: failed to read QDCount",

     

       59
       66
        
       		},

     

       60
       67
        
       		{

     

       61
       68
        
       			name:           "Missing ANCount",

     

       62
       62
       -
       			input:          []byte{0x12, 0x34, 0x81, 0x80, 0x00, 0x01},

     

       63
       63
       -
       			expectedHeader: Header{},

     

       64
       64
       -
       			expectedOffset: 6,

     

       69
       69
       +
       			input:          []byte{0x12, 0x34, 0x81, 0x80, 0x00, 0x01, 0x00},

     

       70
       70
       +
       			expectedHeader: Header{ID: 0x1234, QDCount: 1},

     

       71
       71
       +
       			expectedOffset: 7,

     

       65
       72
        
       			expectedErr:    &BufferOverflowError{},

     

       73
       73
       +
       			wantErrMsg:     "header decode: failed to read ANCount",

     

       66
       74
        
       		},

     

       67
       75
        
       		{

     

       68
       76
        
       			name:           "Missing NSCount",

     

       69
       69
       -
       			input:          []byte{0x12, 0x34, 0x81, 0x80, 0x00, 0x01, 0x00, 0x02},

     

       70
       70
       -
       			expectedHeader: Header{},

     

       71
       71
       -
       			expectedOffset: 8,

     

       77
       77
       +
       			input:          []byte{0x12, 0x34, 0x81, 0x80, 0x00, 0x01, 0x00, 0x02, 0x00},

     

       78
       78
       +
       			expectedHeader: Header{ID: 0x1234, QDCount: 1, ANCount: 2},

     

       79
       79
       +
       			expectedOffset: 9,

     

       72
       80
        
       			expectedErr:    &BufferOverflowError{},

     

       81
       81
       +
       			wantErrMsg:     "header decode: failed to read NSCount",

     

       73
       82
        
       		},

     

       74
       83
        
       		{

     

       75
       84
        
       			name:           "Missing ARCount",

     

       76
       76
       -
       			input:          []byte{0x12, 0x34, 0x81, 0x80, 0x00, 0x01, 0x00, 0x02, 0x00, 0x03},

     

       77
       77
       -
       			expectedHeader: Header{},

     

       78
       78
       -
       			expectedOffset: 10,

     

       85
       85
       +
       			input:          []byte{0x12, 0x34, 0x81, 0x80, 0x00, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00},

     

       86
       86
       +
       			expectedHeader: Header{ID: 0x1234, QDCount: 1, ANCount: 2, NSCount: 3},

     

       87
       87
       +
       			expectedOffset: 11,

     

       79
       88
        
       			expectedErr:    &BufferOverflowError{},

     

       89
       89
       +
       			wantErrMsg:     "header decode: failed to read ARCount",

     

       80
       90
        
       		},

     

       81
       91
        
       	}

     

       82
       92
        
       

     
···

       86
       96
        
       			offset, err := h.Decode(tt.input, 0)

     

       87
       97
        
       

     

       88
       98
        
       			if tt.expectedErr != nil {

     

       89
       89
       -
       				assert.Error(t, err)

     

       90
       90
       -
       				assert.IsType(t, tt.expectedErr, err)

     

       99
       99
       +
       				assert.Error(t, err, "Expected an error but got nil")

     

       100
       100
       +
       

     

       101
       101
       +
       				assert.True(t, errors.Is(err, tt.expectedErr), "Error type mismatch. Got %T, expected %T", err, tt.expectedErr)

     

       102
       102
       +
       

     

       103
       103
       +
       				if tt.wantErrMsg != "" {

     

       104
       104
       +
       					assert.ErrorContains(t, err, tt.wantErrMsg, "Wrapped error message mismatch")

     

       105
       105
       +
       				}

     

       106
       106
       +
       

     

       107
       107
       +
       				assert.Equal(t, tt.expectedOffset, offset, "Offset mismatch on error")

     

       91
       108
        
       			} else {

     

       92
       92
       -
       				assert.NoError(t, err)

     

       93
       93
       -
       				assert.Equal(t, tt.expectedHeader, *h)

     

       94
       94
       -
       			}

     

       109
       109
       +
       				assert.NoError(t, err, "Expected no error but got one")

     

       95
       110
        
       

     

       96
       96
       -
       			assert.Equal(t, tt.expectedOffset, offset)

     

       111
       111
       +
       				assert.Equal(t, tt.expectedHeader, *h, "Header content mismatch")

     

       112
       112
       +
       				assert.Equal(t, tt.expectedOffset, offset, "Offset mismatch on success")

     

       113
       113
       +
       			}

     

       97
       114
        
       		})

     

       98
       115
        
       	}

     

       99
       116
        
       }

     
···

       160
       177
        
       			}

     

       161
       178
        
       

     

       162
       179
        
       			h := &Header{}

     

       163
       163
       -
       			_, err := h.Decode(input, 0)

     

       180
       180
       +
       			offset, err := h.Decode(input, 0)

     

       164
       181
        
       

     

       165
       182
        
       			assert.NoError(t, err)

     

       166
       166
       -
       			assert.Equal(t, tt.expected.QR, h.QR)

     

       167
       167
       -
       			assert.Equal(t, tt.expected.OPCode, h.OPCode)

     

       168
       168
       -
       			assert.Equal(t, tt.expected.AA, h.AA)

     

       169
       169
       -
       			assert.Equal(t, tt.expected.TC, h.TC)

     

       170
       170
       -
       			assert.Equal(t, tt.expected.RD, h.RD)

     

       171
       171
       -
       			assert.Equal(t, tt.expected.RA, h.RA)

     

       172
       172
       -
       			assert.Equal(t, tt.expected.Z, h.Z)

     

       173
       173
       -
       			assert.Equal(t, tt.expected.RCode, h.RCode)

     

       183
       183
       +
       			assert.Equal(t, 12, offset, "Offset should be 12 after decoding full header")

     

       184
       184
       +
       

     

       185
       185
       +
       			assert.Equal(t, tt.expected.QR, h.QR, "QR flag mismatch")

     

       186
       186
       +
       			assert.Equal(t, tt.expected.OPCode, h.OPCode, "OPCode mismatch")

     

       187
       187
       +
       			assert.Equal(t, tt.expected.AA, h.AA, "AA flag mismatch")

     

       188
       188
       +
       			assert.Equal(t, tt.expected.TC, h.TC, "TC flag mismatch")

     

       189
       189
       +
       			assert.Equal(t, tt.expected.RD, h.RD, "RD flag mismatch")

     

       190
       190
       +
       			assert.Equal(t, tt.expected.RA, h.RA, "RA flag mismatch")

     

       191
       191
       +
       			assert.Equal(t, tt.expected.Z, h.Z, "Z value mismatch")

     

       192
       192
       +
       			assert.Equal(t, tt.expected.RCode, h.RCode, "RCode mismatch")

     

       174
       193
        
       		})

     

       175
       194
        
       	}

     

       176
       195
        
       }

     
···

       208
       227
        
       			},

     

       209
       228
        
       		},

     

       210
       229
        
       		{

     

       211
       211
       -
       			name: "No flags set",

     

       230
       230
       +
       			name: "No flags set, different counts",

     

       212
       231
        
       			header: Header{

     

       213
       232
        
       				ID:      0x5678,

     

       214
       233
        
       				QR:      false,

     
···

       234
       253
        
       			},

     

       235
       254
        
       		},

     

       236
       255
        
       		{

     

       237
       237
       -
       			name: "Mixed flags",

     

       256
       256
       +
       			name: "Mixed flags and counts",

     

       238
       257
        
       			header: Header{

     

       239
       258
        
       				ID:      0x9abc,

     

       240
       259
        
       				QR:      true,

     
···

       264
       283
        
       	for _, tt := range tests {

     

       265
       284
        
       		t.Run(tt.name, func(t *testing.T) {

     

       266
       285
        
       			encoded := tt.header.Encode()

     

       267
       267
       -
       			assert.Equal(t, tt.expected, encoded)

     

       286
       286
       +
       			assert.Equal(t, tt.expected, encoded, "Encoded header mismatch")

     

       268
       287
        
       		})

     

       269
       288
        
       	}

     

       270
       289
        
       }

     
···

       287
       306
        
       	}

     

       288
       307
        
       

     

       289
       308
        
       	encoded := originalHeader.Encode()

     

       309
       309
       +
       	assert.Len(t, encoded, 12, "Encoded header should be 12 bytes")

     

       290
       310
        
       

     

       291
       311
        
       	decodedHeader := &Header{}

     

       292
       312
        
       	offset, err := decodedHeader.Decode(encoded, 0)

     

       293
       313
        
       

     

       294
       294
       -
       	assert.NoError(t, err)

     

       295
       295
       -
       	assert.Equal(t, len(encoded), offset)

     

       296
       296
       -
       	assert.Equal(t, originalHeader, *decodedHeader)

     

       314
       314
       +
       	assert.NoError(t, err, "Decoding failed unexpectedly")

     

       315
       315
       +
       	assert.Equal(t, 12, offset, "Offset after decoding should be 12")

     

       316
       316
       +
       	assert.Equal(t, originalHeader, *decodedHeader, "Decoded header does not match original")

     

       297
       317
        
       }

     

       298
       318
        
       

     

       299
       319
        
       func TestHeaderEncodeFlagCombinations(t *testing.T) {

     
···

       316
       336
        
       	for _, tc := range testCases {

     

       317
       337
        
       		t.Run(tc.name, func(t *testing.T) {

     

       318
       338
        
       			encoded := tc.header.Encode()

     

       339
       339
       +
       			require.Len(t, encoded, 12, "Encoded header length invariant")

     

       340
       340
       +
       

     

       319
       341
        
       			flags := binary.BigEndian.Uint16(encoded[2:4])

     

       320
       320
       -
       			assert.Equal(t, tc.expected, flags)

     

       342
       342
       +
       			assert.Equal(t, tc.expected, flags, "Flags value mismatch")

     

       321
       343
        
       		})

     

       322
       344
        
       	}

     

       323
       345
        
       }

     
···

       327
       349
        
       		{0x12, 0x34, 0x81, 0x80, 0x00, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x04},

     

       328
       350
        
       		{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},

     

       329
       351
        
       		{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},

     

       352
       352
       +
       		{0x12, 0x34},

     

       353
       353
       +
       		{0x12, 0x34, 0x81, 0x80, 0x00},

     

       354
       354
       +
       		{},

     

       330
       355
        
       	}

     

       331
       356
        
       

     

       332
       357
        
       	for _, tc := range testcases {

     
···

       334
       359
        
       	}

     

       335
       360
        
       

     

       336
       361
        
       	f.Fuzz(func(t *testing.T, data []byte) {

     

       337
       337
       -
       		// limit to only 12 bytes

     

       338
       338
       -
       		if len(data) > 12 {

     

       339
       339
       -
       			data = data[0:12]

     

       340
       340
       -
       		}

     

       341
       341
       -
       

     

       342
       362
        
       		h := &Header{}

     

       343
       363
        
       		offset, err := h.Decode(data, 0)

     

       344
       364
        
       		if err != nil {

     

       345
       345
       -
       			switch err.(type) {

     

       346
       346
       -
       			case *BufferOverflowError, *InvalidLabelError:

     

       347
       347
       -
       				// these are expected error types

     

       348
       348
       -
       			default:

     

       349
       349
       -
       				t.Errorf("unexpected error type: %T", err)

     

       365
       365
       +
       			var bofErr *BufferOverflowError

     

       366
       366
       +
       			if !errors.As(err, &bofErr) {

     

       367
       367
       +
       				t.Errorf("FuzzDecodeHeader: expected BufferOverflowError or wrapped BOF, got %T: %v", err, err)

     

       368
       368
       +
       			}

     

       369
       369
       +
       			if offset > len(data) {

     

       370
       370
       +
       				t.Errorf("FuzzDecodeHeader: offset (%d) > data length (%d) on error", offset, len(data))

     

       350
       371
        
       			}

     

       351
       372
        
       			return

     

       352
       373
        
       		}

     

       353
       374
        
       

     

       354
       354
       -
       		if offset != len(data) {

     

       355
       355
       -
       			t.Errorf("offset (%d) does not match data length (%d)", offset, len(data))

     

       375
       375
       +
       		if len(data) < 12 {

     

       376
       376
       +
       			t.Errorf("FuzzDecodeHeader: decoded successfully but input length %d < 12", len(data))

     

       377
       377
       +
       			return

     

       378
       378
       +
       		}

     

       379
       379
       +
       		if offset != 12 {

     

       380
       380
       +
       			t.Errorf("FuzzDecodeHeader: successful decode offset (%d) != 12", offset)

     

       356
       381
        
       		}

     

       357
       382
        
       

     

       358
       383
        
       		if h.OPCode > 15 {

     

       359
       359
       -
       			t.Errorf("invalid OPCode: %d", h.OPCode)

     

       384
       384
       +
       			t.Errorf("FuzzDecodeHeader: invalid OPCode decoded: %d", h.OPCode)

     

       360
       385
        
       		}

     

       361
       361
       -
       

     

       362
       386
        
       		if h.Z > 7 {

     

       363
       363
       -
       			t.Errorf("invalid Z value: %d", h.Z)

     

       387
       387
       +
       			t.Errorf("FuzzDecodeHeader: invalid Z value decoded: %d", h.Z)

     

       364
       388
        
       		}

     

       365
       365
       -
       

     

       366
       389
        
       		if h.RCode > 15 {

     

       367
       367
       -
       			t.Errorf("invalid RCode: %d", h.RCode)

     

       390
       390
       +
       			t.Errorf("FuzzDecodeHeader: invalid RCode decoded: %d", h.RCode)

     

       368
       391
        
       		}

     

       369
       392
        
       

     

       370
       370
       -
       		encoded := h.Encode()

     

       371
       371
       -
       		if len(encoded) != len(data) {

     

       372
       372
       -
       			t.Errorf("encoded length (%d) does not match input length (%d)", len(encoded), len(data))

     

       373
       373
       -
       

     

       374
       374
       -
       			for i := 0; i < len(data); i++ {

     

       375
       375
       -
       				t.Errorf("mismatch at position: %d: encoded %02x, input: %02x", i, encoded[i], data[i])

     

       393
       393
       +
       		if len(data) >= 12 {

     

       394
       394
       +
       			encoded := h.Encode()

     

       395
       395
       +
       			if !bytes.Equal(encoded, data[:12]) {

     

       396
       396
       +
       				t.Errorf("FuzzDecodeHeader: encode/decode mismatch\nInput: %x\nEncoded: %x", data[:12], encoded)

     

       376
       397
        
       			}

     

       377
       398
        
       		}

     

       378
       399
        
       	})

+16 -8

question.go

···

       1
       1
        
       package magna

     

       2
       2
        
       

     

       3
       3
       -
       import "encoding/binary"

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"encoding/binary"

     

       5
       5
       +
       	"fmt"

     

       6
       6
       +
       )

     

       4
       7
        
       

     

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

     

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

     

       7
       10
        
       	var err error

     

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

     

       11
       11
       +
       	q.QName, offset, err = decodeDomain(buf, offset)

     

       9
       12
        
       	if err != nil {

     

       10
       10
       -
       		return offset, err

     

       13
       13
       +
       		return offset, fmt.Errorf("question decode: failed to decode QName: %w", err)

     

       11
       14
        
       	}

     

       12
       15
        
       

     

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

     

       14
       17
        
       	if err != nil {

     

       15
       15
       -
       		return offset, err

     

       18
       18
       +
       		return offset, fmt.Errorf("question decode: failed to decode QType for %s: %w", q.QName, err)

     

       16
       19
        
       	}

     

       17
       20
        
       

     

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

     

       19
       22
        
       	if err != nil {

     

       20
       20
       -
       		return offset, err

     

       23
       23
       +
       		return offset, fmt.Errorf("question decode: failed to decode QClass for %s: %w", q.QName, err)

     

       21
       24
        
       	}

     

       22
       25
        
       

     

       23
       26
        
       	q.QType = DNSType(qtype)

     
···

       26
       29
        
       }

     

       27
       30
        
       

     

       28
       31
        
       // 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]uint16) []byte {

     

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

     

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

     

       33
       33
       +
       	var err error

     

       34
       34
       +
       	bytes, err = encodeDomain(bytes, q.QName, offsets)

     

       35
       35
       +
       	if err != nil {

     

       36
       36
       +
       		return nil, fmt.Errorf("question encode: failed to encode QName %s: %w", q.QName, err)

     

       37
       37
       +
       	}

     

       38
       38
       +
       

     

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

     

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

     

       33
       33
       -
       	return bytes

     

       41
       41
       +
       	return bytes, nil

     

       34
       42
        
       }

+103 -82

question_test.go

···

       1
       1
        
       package magna

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"errors"

     

       4
       5
        
       	"testing"

     

       5
       6
        
       

     

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

     

       8
       8
       +
       	"github.com/stretchr/testify/require"

     

       7
       9
        
       )

     

       8
       10
        
       

     

       9
       11
        
       func TestQuestionDecode(t *testing.T) {

     
···

       13
       15
        
       		expectedOffset int

     

       14
       16
        
       		expected       Question

     

       15
       17
        
       		expectedErr    error

     

       18
       18
       +
       		wantErrMsg     string

     

       16
       19
        
       	}{

     

       17
       20
        
       		{

     

       18
       21
        
       			name:           "Valid question - example.com A IN",

     
···

       37
       40
        
       			expectedErr: nil,

     

       38
       41
        
       		},

     

       39
       42
        
       		{

     

       40
       40
       -
       			name:           "Invalid domain name",

     

       41
       41
       -
       			input:          []byte{255, 'i', 'n', 'v', 'a', 'l', 'i', 'd', 0, 0, 1, 0, 1},

     

       43
       43
       +
       			name:           "Invalid domain name - label too long",

     

       44
       44
       +
       			input:          []byte{64, 'i', 'n', 'v', 'a', 'l', 'i', 'd', 0, 0, 1, 0, 1},

     

       42
       45
        
       			expectedOffset: 13,

     

       43
       46
        
       			expected:       Question{},

     

       44
       44
       -
       			expectedErr:    &BufferOverflowError{},

     

       47
       47
       +
       			expectedErr:    &InvalidLabelError{},

     

       48
       48
       +
       			wantErrMsg:     "question decode: failed to decode QName: invalid domain label: length 64 exceeds maximum 63",

     

       49
       49
       +
       		},

     

       50
       50
       +
       		{

     

       51
       51
       +
       			name:           "Invalid domain name - compression loop",

     

       52
       52
       +
       			input:          []byte{0xC0, 0x00, 0, 1, 0, 1},

     

       53
       53
       +
       			expectedOffset: 6,

     

       54
       54
       +
       			expected:       Question{},

     

       55
       55
       +
       			expectedErr:    &DomainCompressionError{},

     

       56
       56
       +
       			wantErrMsg:     "question decode: failed to decode QName: invalid domain compression: pointer loop detected",

     

       45
       57
        
       		},

     

       46
       58
        
       		{

     

       47
       59
        
       			name:           "Insufficient buffer for QType",

     
···

       49
       61
        
       			expectedOffset: 14,

     

       50
       62
        
       			expected:       Question{QName: "example.com"},

     

       51
       63
        
       			expectedErr:    &BufferOverflowError{},

     

       64
       64
       +
       			wantErrMsg:     "question decode: failed to decode QType for example.com: buffer overflow",

     

       52
       65
        
       		},

     

       53
       66
        
       		{

     

       54
       67
        
       			name:           "Insufficient buffer for QClass",

     
···

       56
       69
        
       			expectedOffset: 16,

     

       57
       70
        
       			expected:       Question{QName: "example.com", QType: DNSType(1)},

     

       58
       71
        
       			expectedErr:    &BufferOverflowError{},

     

       72
       72
       +
       			wantErrMsg:     "question decode: failed to decode QClass for example.com: buffer overflow",

     

       59
       73
        
       		},

     

       60
       74
        
       	}

     

       61
       75
        
       

     
···

       64
       78
        
       			q := &Question{}

     

       65
       79
        
       			offset, err := q.Decode(tt.input, 0)

     

       66
       80
        
       

     

       67
       67
       -
       			assert.Equal(t, tt.expectedOffset, offset)

     

       68
       68
       -
       

     

       69
       81
        
       			if tt.expectedErr != nil {

     

       70
       70
       -
       				assert.Error(t, err)

     

       71
       71
       -
       				assert.IsType(t, tt.expectedErr, err)

     

       82
       82
       +
       				assert.Error(t, err, "Expected an error but got nil")

     

       83
       83
       +
       				assert.True(t, errors.Is(err, tt.expectedErr), "Error type mismatch. Got %T, expected %T", err, tt.expectedErr)

     

       84
       84
       +
       				if tt.wantErrMsg != "" {

     

       85
       85
       +
       					assert.ErrorContains(t, err, tt.wantErrMsg, "Wrapped error message mismatch")

     

       86
       86
       +
       				}

     

       87
       87
       +
       				assert.Equal(t, tt.expectedOffset, offset, "Offset mismatch on error")

     

       72
       88
        
       			} else {

     

       73
       73
       -
       				assert.NoError(t, err)

     

       74
       74
       -
       				assert.Equal(t, tt.expected, *q)

     

       89
       89
       +
       				assert.NoError(t, err, "Expected no error but got one")

     

       90
       90
       +
       				assert.Equal(t, tt.expected, *q, "Decoded question mismatch")

     

       91
       91
       +
       				assert.Equal(t, tt.expectedOffset, offset, "Offset mismatch on success")

     

       75
       92
        
       			}

     

       76
       93
        
       		})

     

       77
       94
        
       	}

     
···

       79
       96
        
       

     

       80
       97
        
       func TestQuestionEncode(t *testing.T) {

     

       81
       98
        
       	tests := []struct {

     

       82
       82
       -
       		name     string

     

       83
       83
       -
       		question Question

     

       84
       84
       -
       		offsets  map[string]uint16

     

       85
       85
       -
       		expected []byte

     

       99
       99
       +
       		name        string

     

       100
       100
       +
       		question    Question

     

       101
       101
       +
       		initialBuf  []byte

     

       102
       102
       +
       		offsets     map[string]uint16

     

       103
       103
       +
       		expected    []byte

     

       104
       104
       +
       		expectedErr error

     

       105
       105
       +
       		wantErrMsg  string

     

       106
       106
       +
       		newOffsets  map[string]uint16

     

       86
       107
        
       	}{

     

       87
       108
        
       		{

     

       88
       109
        
       			name: "Simple domain - example.com A IN",

     
···

       91
       112
        
       				QType:  DNSType(1),

     

       92
       113
        
       				QClass: DNSClass(1),

     

       93
       114
        
       			},

     

       94
       94
       -
       			offsets:  make(map[string]uint16),

     

       95
       95
       -
       			expected: []byte{7, 'e', 'x', 'a', 'm', 'p', 'l', 'e', 3, 'c', 'o', 'm', 0, 0, 1, 0, 1},

     

       115
       115
       +
       			initialBuf: nil,

     

       116
       116
       +
       			offsets:    make(map[string]uint16),

     

       117
       117
       +
       			expected:   []byte{7, 'e', 'x', 'a', 'm', 'p', 'l', 'e', 3, 'c', 'o', 'm', 0, 0, 1, 0, 1},

     

       118
       118
       +
       			newOffsets: map[string]uint16{"example.com": 0, "com": 8},

     

       96
       119
        
       		},

     

       97
       120
        
       		{

     

       98
       121
        
       			name: "Subdomain - subdomain.example.com AAAA IN",

     
···

       101
       124
        
       				QType:  DNSType(28),

     

       102
       125
        
       				QClass: DNSClass(1),

     

       103
       126
        
       			},

     

       104
       104
       -
       			offsets:  make(map[string]uint16),

     

       105
       105
       -
       			expected: []byte{9, 's', 'u', 'b', 'd', 'o', 'm', 'a', 'i', 'n', 7, 'e', 'x', 'a', 'm', 'p', 'l', 'e', 3, 'c', 'o', 'm', 0, 0, 28, 0, 1},

     

       127
       127
       +
       			initialBuf: nil,

     

       128
       128
       +
       			offsets:    make(map[string]uint16),

     

       129
       129
       +
       			expected:   []byte{9, 's', 'u', 'b', 'd', 'o', 'm', 'a', 'i', 'n', 7, 'e', 'x', 'a', 'm', 'p', 'l', 'e', 3, 'c', 'o', 'm', 0, 0, 28, 0, 1},

     

       130
       130
       +
       			newOffsets: map[string]uint16{"subdomain.example.com": 0, "example.com": 10, "com": 18},

     

       106
       131
        
       		},

     

       107
       132
        
       		{

     

       108
       133
        
       			name: "Different class - example.com MX CH",

     
···

       111
       136
        
       				QType:  DNSType(15),

     

       112
       137
        
       				QClass: DNSClass(3),

     

       113
       138
        
       			},

     

       114
       114
       -
       			offsets:  make(map[string]uint16),

     

       115
       115
       -
       			expected: []byte{7, 'e', 'x', 'a', 'm', 'p', 'l', 'e', 3, 'c', 'o', 'm', 0, 0, 15, 0, 3},

     

       139
       139
       +
       			initialBuf: nil,

     

       140
       140
       +
       			offsets:    make(map[string]uint16),

     

       141
       141
       +
       			expected:   []byte{7, 'e', 'x', 'a', 'm', 'p', 'l', 'e', 3, 'c', 'o', 'm', 0, 0, 15, 0, 3},

     

       142
       142
       +
       			newOffsets: map[string]uint16{"example.com": 0, "com": 8},

     

       116
       143
        
       		},

     

       117
       144
        
       		{

     

       118
       145
        
       			name: "Domain compression - example.com after subdomain.example.com",

     
···

       121
       148
        
       				QType:  DNSType(1),

     

       122
       149
        
       				QClass: DNSClass(1),

     

       123
       150
        
       			},

     

       151
       151
       +
       			initialBuf: nil,

     

       124
       152
        
       			offsets: map[string]uint16{

     

       125
       125
       -
       				"com":         22,

     

       126
       126
       -
       				"example.com": 19,

     

       153
       153
       +
       				"subdomain.example.com": 0,

     

       154
       154
       +
       				"example.com":           10,

     

       155
       155
       +
       				"com":                   18,

     

       156
       156
       +
       			},

     

       157
       157
       +
       			expected: []byte{0xC0, 0x0a, 0x00, 0x01, 0x00, 0x01},

     

       158
       158
       +
       			newOffsets: map[string]uint16{

     

       159
       159
       +
       				"subdomain.example.com": 0,

     

       160
       160
       +
       				"example.com":           10,

     

       161
       161
       +
       				"com":                   18,

     

       127
       162
        
       			},

     

       128
       128
       -
       			expected: []byte{0xC0, 0x13, 0x00, 0x01, 0x00, 0x01},

     

       163
       163
       +
       		},

     

       164
       164
       +
       		{

     

       165
       165
       +
       			name: "Encode with initial buffer",

     

       166
       166
       +
       			question: Question{

     

       167
       167
       +
       				QName:  "test.org",

     

       168
       168
       +
       				QType:  AType,

     

       169
       169
       +
       				QClass: IN,

     

       170
       170
       +
       			},

     

       171
       171
       +
       			initialBuf: []byte{0xAA, 0xBB},

     

       172
       172
       +
       			offsets:    make(map[string]uint16),

     

       173
       173
       +
       			expected:   []byte{0xAA, 0xBB, 4, 't', 'e', 's', 't', 3, 'o', 'r', 'g', 0, 0, 1, 0, 1},

     

       174
       174
       +
       			newOffsets: map[string]uint16{"test.org": 2, "org": 7},

     

       175
       175
       +
       		},

     

       176
       176
       +
       		{

     

       177
       177
       +
       			name: "Encode invalid domain - label too long",

     

       178
       178
       +
       			question: Question{

     

       179
       179
       +
       				QName:  "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.com",

     

       180
       180
       +
       				QType:  AType,

     

       181
       181
       +
       				QClass: IN,

     

       182
       182
       +
       			},

     

       183
       183
       +
       			initialBuf:  nil,

     

       184
       184
       +
       			offsets:     make(map[string]uint16),

     

       185
       185
       +
       			expected:    nil,

     

       186
       186
       +
       			expectedErr: &InvalidLabelError{},

     

       187
       187
       +
       			wantErrMsg:  "question encode: failed to encode QName",

     

       188
       188
       +
       			newOffsets:  map[string]uint16{},

     

       129
       189
        
       		},

     

       130
       190
        
       	}

     

       131
       191
        
       

     

       132
       192
        
       	for _, tt := range tests {

     

       133
       193
        
       		t.Run(tt.name, func(t *testing.T) {

     

       134
       134
       -
       			result := tt.question.Encode(nil, &tt.offsets)

     

       135
       135
       -
       			assert.Equal(t, tt.expected, result)

     

       194
       194
       +
       			currentOffsets := make(map[string]uint16)

     

       195
       195
       +
       			for k, v := range tt.offsets {

     

       196
       196
       +
       				currentOffsets[k] = v

     

       197
       197
       +
       			}

     

       136
       198
        
       

     

       137
       137
       -
       			if len(tt.offsets) == 0 {

     

       138
       138
       -
       				expectedOffsets := map[string]uint16{

     

       139
       139
       -
       					tt.question.QName: 0,

     

       140
       140
       -
       				}

     

       141
       141
       -
       				for i := 0; i < len(tt.question.QName); i++ {

     

       142
       142
       -
       					if tt.question.QName[i] == '.' {

     

       143
       143
       -
       						expectedOffsets[tt.question.QName[i+1:]] = uint16(i + 1)

     

       144
       144
       -
       					}

     

       199
       199
       +
       			result, err := tt.question.Encode(tt.initialBuf, &currentOffsets)

     

       200
       200
       +
       

     

       201
       201
       +
       			if tt.expectedErr != nil {

     

       202
       202
       +
       				assert.Error(t, err, "Expected an error but got nil")

     

       203
       203
       +
       				assert.True(t, errors.Is(err, tt.expectedErr), "Error type mismatch. Got %T, expected %T", err, tt.expectedErr)

     

       204
       204
       +
       				if tt.wantErrMsg != "" {

     

       205
       205
       +
       					assert.ErrorContains(t, err, tt.wantErrMsg, "Wrapped error message mismatch")

     

       145
       206
        
       				}

     

       146
       146
       -
       				assert.Equal(t, expectedOffsets, tt.offsets)

     

       207
       207
       +
       			} else {

     

       208
       208
       +
       				assert.NoError(t, err, "Expected no error but got one")

     

       209
       209
       +
       				assert.Equal(t, tt.expected, result, "Encoded question mismatch")

     

       210
       210
       +
       				assert.Equal(t, tt.newOffsets, currentOffsets, "Final offsets mismatch")

     

       147
       211
        
       			}

     

       148
       212
        
       		})

     

       149
       213
        
       	}

     
···

       183
       247
        
       	for _, tt := range tests {

     

       184
       248
        
       		t.Run(tt.name, func(t *testing.T) {

     

       185
       249
        
       			offsets := make(map[string]uint16)

     

       186
       186
       -
       			encoded := tt.question.Encode(nil, &offsets)

     

       250
       250
       +
       			encoded, err := tt.question.Encode(nil, &offsets)

     

       251
       251
       +
       			require.NoError(t, err, "Encoding failed")

     

       187
       252
        
       

     

       188
       253
        
       			decodedQuestion := &Question{}

     

       189
       189
       -
       			_, err := decodedQuestion.Decode(encoded, 0)

     

       254
       254
       +
       			offset, err := decodedQuestion.Decode(encoded, 0)

     

       190
       255
        
       

     

       191
       191
       -
       			assert.NoError(t, err)

     

       192
       192
       -
       			assert.Equal(t, tt.question, *decodedQuestion)

     

       256
       256
       +
       			assert.NoError(t, err, "Decoding failed")

     

       257
       257
       +
       			assert.Equal(t, len(encoded), offset, "Offset after decoding should match encoded length")

     

       258
       258
       +
       			assert.Equal(t, tt.question, *decodedQuestion, "Decoded question does not match original")

     

       193
       259
        
       		})

     

       194
       260
        
       	}

     

       195
       261
        
       }

     

       196
       196
       -
       

     

       197
       197
       -
       func TestQuestionEncodeWithExistingBuffer(t *testing.T) {

     

       198
       198
       -
       	question := Question{

     

       199
       199
       -
       		QName:  "example.com",

     

       200
       200
       -
       		QType:  DNSType(1),

     

       201
       201
       -
       		QClass: DNSClass(1),

     

       202
       202
       -
       	}

     

       203
       203
       -
       

     

       204
       204
       -
       	existingBuffer := []byte{0xFF, 0xFF, 0xFF, 0xFF}

     

       205
       205
       -
       	offsets := make(map[string]uint16)

     

       206
       206
       -
       

     

       207
       207
       -
       	result := question.Encode(existingBuffer, &offsets)

     

       208
       208
       -
       

     

       209
       209
       -
       	expected := append(

     

       210
       210
       -
       		existingBuffer,

     

       211
       211
       -
       		[]byte{7, 'e', 'x', 'a', 'm', 'p', 'l', 'e', 3, 'c', 'o', 'm', 0, 0, 1, 0, 1}...,

     

       212
       212
       -
       	)

     

       213
       213
       -
       

     

       214
       214
       -
       	assert.Equal(t, expected, result)

     

       215
       215
       -
       }

     

       216
       216
       -
       

     

       217
       217
       -
       func TestQuestionEncodeLongDomainName(t *testing.T) {

     

       218
       218
       -
       	longLabel := make([]byte, 63)

     

       219
       219
       -
       	for i := range longLabel {

     

       220
       220
       -
       		longLabel[i] = 'a'

     

       221
       221
       -
       	}

     

       222
       222
       -
       	longDomainName := string(longLabel) + "." + string(longLabel) + "." + string(longLabel) + "." + string(longLabel[:61])

     

       223
       223
       -
       

     

       224
       224
       -
       	question := Question{

     

       225
       225
       -
       		QName:  longDomainName,

     

       226
       226
       -
       		QType:  DNSType(1),

     

       227
       227
       -
       		QClass: DNSClass(1),

     

       228
       228
       -
       	}

     

       229
       229
       -
       

     

       230
       230
       -
       	offsets := make(map[string]uint16)

     

       231
       231
       -
       	encoded := question.Encode(nil, &offsets)

     

       232
       232
       -
       

     

       233
       233
       -
       	assert.Equal(t, 259, len(encoded))

     

       234
       234
       -
       

     

       235
       235
       -
       	decodedQuestion := &Question{}

     

       236
       236
       -
       	_, err := decodedQuestion.Decode(encoded, 0)

     

       237
       237
       -
       

     

       238
       238
       -
       	assert.NoError(t, err)

     

       239
       239
       -
       	assert.Equal(t, question, *decodedQuestion)

     

       240
       240
       -
       }

+16 -16

utils.go

···

       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}

     

       9
       9
       +
       	nextOffset := offset + 1

     

       10
       10
       +
       	if nextOffset > len(buf) {

     

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

     

       12
       12
        
       	}

     

       13
       13
        
       

     

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

     

       14
       14
       +
       	return buf[offset], nextOffset, 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}

     

       19
       19
       +
       	nextOffset := offset + 2

     

       20
       20
       +
       	if nextOffset > len(buf) {

     

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

     

       22
       22
        
       	}

     

       23
       23
        
       

     

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

     

       24
       24
       +
       	return binary.BigEndian.Uint16(buf[offset:]), nextOffset, 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}

     

       29
       29
       +
       	nextOffset := offset + 4

     

       30
       30
       +
       	if nextOffset > len(buf) {

     

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

     

       32
       32
        
       	}

     

       33
       33
        
       

     

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

     

       34
       34
       +
       	return binary.BigEndian.Uint32(buf[offset:]), nextOffset, 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}

     

       39
       39
       +
       	nextOffset := offset + length

     

       40
       40
       +
       	if nextOffset > len(buf) {

     

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

     

       42
       42
        
       	}

     

       43
       43
        
       

     

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

     

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

     

       45
       45
        
       }

+11

.golangci.toml

···

       1
       1
       +
       version = "2"

     

       2
       2
       +
       [linters.settings.govet]

     

       3
       3
       +
       enable_all = true

     

       4
       4
       +
       [linters.settings.staticcheck]

     

       5
       5
       +
       checks = ["all"]

     

       6
       6
       +
       [linters.settings.exhaustive]

     

       7
       7
       +
       check = ["switch"]

     

       8
       8
       +
       [linters.settings.exhaustruct]

     

       9
       9
       +
       [linters.settings.goconst]

     

       10
       10
       +
       [linters.settings.testifylint]

     

       11
       11
       +
       enable-all = true

Justfile

···

       1
       1
       +
       format:

     

       2
       2
       +
         go fmt ./...

     

       3
       3
       +
         gofumpt -l -w $(fd .go)

     

       4
       4
       +
       

     

       5
       5
       +
       verify:

     

       6
       6
       +
         go vet ./...

     

       7
       7
       +
         golangci-lint run

README.md

···

       1
       1
        
       # Magna

     

       2
       2
        
       

     

       3
       3
       +
       ## Contributing

     

       4
       4
       +
       Dependencies:

     

       5
       5
       +
       - go 1.24

     

       6
       6
       +
       - just

     

       7
       7
       +
       - golint-ci

     

       8
       8
       +
       

     

       3
       9
        
       this is a go package for packing/unpacking dns packets.

     

       4
       10
        
       

     

       5
       11
        
       > which we expect to be so popular that it would be a waste of wire space

types.go

···

       92
       92
        
       	X25Type           = 19

     

       93
       93
        
       	ISDNType          = 20

     

       94
       94
        
       	RTType            = 21

     

       95
       95
       +
       	AAAAType          = 28

     

       95
       96
        
       

     

       96
       97
        
       	OPTType = 41

     

       97
       98
        
       

     
···

       145
       146
        
       		return "ISDN"

     

       146
       147
        
       	case RTType:

     

       147
       148
        
       		return "RT"

     

       149
       149
       +
       	case AAAAType:

     

       150
       150
       +
       		return "AAAA"

     

       148
       151
        
       	case OPTType:

     

       149
       152
        
       		return "OPT"

     

       150
       153
        
       	case AXFRType:

     
···

       375
       378
        
       	IntermediateHost string

     

       376
       379
        
       }

     

       377
       380
        
       

     

       381
       381
       +
       type AAAA struct {

     

       382
       382
       +
       	Address net.IP

     

       383
       383
       +
       }

     

       384
       384
       +
       

     

       378
       385
        
       type EDNSOption struct {

     

       379
       386
        
       	Code uint16

     

       380
       387
        
       	Data []byte

+7 -1

.tangled/workflows/lint.yml

···

       1
       1
        
       when:

     

       2
       2
       -
         - event: ["push", "pull_request"]

     

       2
       2
       +
         - event: ["push", "pull_request", "manual"]

     

       3
       3
        
           branch: ["main"]

     

       4
       4
        
       

     

       5
       5
       +
       engine: "nixery"

     

       6
       6
       +
       

     

       7
       7
       +
       clone:

     

       8
       8
       +
         depth: 1

     

       9
       9
       +
         submodules: false

     

       10
       10
       +
       

     

       5
       11
        
       dependencies:

     

       6
       12
        
         nixpkgs:

     

       7
       13
        
           - go

+7 -2

.tangled/workflows/test.yml

···

       1
       1
        
       when:

     

       2
       2
       -
         - event: ["push", "pull_request"]

     

       2
       2
       +
         - event: ["push", "pull_request", "manual"]

     

       3
       3
        
           branch: ["main"]

     

       4
       4
       -
         - event: ["manual"]

     

       4
       4
       +
       

     

       5
       5
       +
       engine: "nixery"

     

       6
       6
       +
       

     

       7
       7
       +
       clone:

     

       8
       8
       +
         depth: 1

     

       9
       9
       +
         submodules: false

     

       5
       10
        
       

     

       6
       11
        
       dependencies:

     

       7
       12
        
         nixpkgs:

+18

.tangled/workflows/staticcheck.yml

···

       1
       1
       +
       when:

     

       2
       2
       +
         - event: ["push", "pull_request", "manual"]

     

       3
       3
       +
           branch: ["main"]

     

       4
       4
       +
       

     

       5
       5
       +
       engine: "nixery"

     

       6
       6
       +
       

     

       7
       7
       +
       clone:

     

       8
       8
       +
         depth: 1

     

       9
       9
       +
         submodules: false

     

       10
       10
       +
       

     

       11
       11
       +
       dependencies:

     

       12
       12
       +
         nixpkgs:

     

       13
       13
       +
           - go

     

       14
       14
       +
       

     

       15
       15
       +
       steps:

     

       16
       16
       +
         - name: "staticcheck"

     

       17
       17
       +
           command: |

     

       18
       18
       +
              go run honnef.co/go/tools/cmd/staticcheck@latest

Compare changes