comparing v0.0.1 and feature/ipv6 on seiso.moe/magna

+26

message.go

···

       7
       7
        
       

     

       8
       8
        
       // Decode decodes a DNS packet.

     

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

     

       10
       10
       +
       	// gets checked when parsing additional records

     

       11
       11
       +
       	m.HasEDNS = false

     

       12
       12
       +
       

     

       10
       13
        
       	offset, err := m.Header.Decode(buf, 0)

     

       11
       14
        
       	if err != nil {

     

       12
       15
        
       		return fmt.Errorf("failed to decode message header: %w", err)

     
···

       53
       56
        
       			return fmt.Errorf("failed to decode additional record #%d: %w", i+1, err)

     

       54
       57
        
       		}

     

       55
       58
        
       

     

       59
       59
       +
       		if rr.RType == OPTType {

     

       60
       60
       +
       			opt, ok := rr.RData.(*OPT)

     

       61
       61
       +
       			if !ok {

     

       62
       62
       +
       				// this should never fail

     

       63
       63
       +
       				return fmt.Errorf("unable to parse RData as OPT")

     

       64
       64
       +
       			}

     

       65
       65
       +
       

     

       66
       66
       +
       			m.HasEDNS = true

     

       67
       67
       +
       			m.ExtendedRCode = uint8(rr.TTL >> 24 & 0xFF000000)

     

       68
       68
       +
       			m.EDNSVersion = uint8((rr.TTL & 0x00FF0000) >> 16)

     

       69
       69
       +
       			m.EDNSFlags = uint16(rr.TTL & 0x0000FFFF)

     

       70
       70
       +
       			m.EDNSOptions = opt.Options

     

       71
       71
       +
       			m.UDPSize = uint16(rr.RClass)

     

       72
       72
       +
       		}

     

       73
       73
       +
       

     

       56
       74
        
       		m.Additional = append(m.Additional, rr)

     

       57
       75
        
       	}

     

       58
       76
        
       

     

       77
       77
       +
       	if !m.HasEDNS {

     

       78
       78
       +
       		m.ExtendedRCode = 0

     

       79
       79
       +
       		m.EDNSVersion = 0

     

       80
       80
       +
       		m.EDNSFlags = 0

     

       81
       81
       +
       		m.EDNSOptions = make([]EDNSOption, 0)

     

       82
       82
       +
       		m.UDPSize = 512 // default in rfc-1035 section 2.3.4.

     

       83
       83
       +
       	}

     

       84
       84
       +
       

     

       59
       85
        
       	return nil

     

       60
       86
        
       }

     

       61
       87

+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

+7

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

+1 -1

message_test.go

···

       226
       226
        
       					},

     

       227
       227
        
       				},

     

       228
       228
        
       				EDNSVersion: 0x64,

     

       229
       229
       -
       				UDPSize: 0x4d0,

     

       229
       229
       +
       				UDPSize:     0x4d0,

     

       230
       230
        
       			},

     

       231
       231
        
       		},

     

       232
       232
        
       	}

+6

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

+30 -1

resource_record.go

···

       26
       26
        
       		return nil, fmt.Errorf("A record: cannot encode non-IPv4 address %s", a.Address.String())

     

       27
       27
        
       	}

     

       28
       28
        
       

     

       29
       29
       -
       	return append(bytes, a.Address.To4()...), nil

     

       29
       29
       +
       	return append(bytes, ipv4...), nil

     

       30
       30
        
       }

     

       31
       31
        
       

     

       32
       32
        
       func (a A) String() string {

     
···

       751
       751
        
       	return fmt.Sprintf("%d %s", rt.Preference, rt.IntermediateHost)

     

       752
       752
        
       }

     

       753
       753
        
       

     

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

     

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

     

       756
       756
       +
       	if err != nil {

     

       757
       757
       +
       		return offset, fmt.Errorf("AAAA record: failed to read address data: %w", err)

     

       758
       758
       +
       	}

     

       759
       759
       +
       

     

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

     

       761
       761
       +
       	if a.Address.To16() == nil {

     

       762
       762
       +
       		return offset, fmt.Errorf("AAAA record: decoded data is not a valid IPv6 address: %v", bytes)

     

       763
       763
       +
       	}

     

       764
       764
       +
       	return offset, nil

     

       765
       765
       +
       }

     

       766
       766
       +
       

     

       767
       767
       +
       func (a *AAAA) Encode(bytes []byte, offsets *map[string]uint16) ([]byte, error) {

     

       768
       768
       +
       	ipv6 := a.Address.To16()

     

       769
       769
       +
       	// XXX: ipv6 encodes ipv4 so need to check its not ipv4

     

       770
       770
       +
       	if a.Address.To4() != nil || ipv6 == nil {

     

       771
       771
       +
       		return nil, fmt.Errorf("AAAA record: cannot encode non-IPv6 address %s", a.Address.String())

     

       772
       772
       +
       	}

     

       773
       773
       +
       

     

       774
       774
       +
       	return append(bytes, ipv6...), nil

     

       775
       775
       +
       }

     

       776
       776
       +
       

     

       777
       777
       +
       func (a AAAA) String() string {

     

       778
       778
       +
       	return a.Address.String()

     

       779
       779
       +
       }

     

       780
       780
       +
       

     

       754
       781
        
       func (opt *OPT) Decode(buf []byte, offset int, rdlength int) (int, error) {

     

       755
       782
        
       	// s := offset

     

       756
       783
        
       	opt.Options = make([]EDNSOption, 0)

     
···

       915
       942
        
       		r.RData = &ISDN{}

     

       916
       943
        
       	case 21:

     

       917
       944
        
       		r.RData = &RT{}

     

       945
       945
       +
       	case 28:

     

       946
       946
       +
       		r.RData = &AAAA{}

     

       918
       947
        
       	case 41:

     

       919
       948
        
       		r.RData = &OPT{}

     

       920
       949
        
       	default:

+30

resource_record_test.go

···

       516
       516
        
       		})

     

       517
       517
        
       	}

     

       518
       518
        
       }

     

       519
       519
       +
       

     

       520
       520
       +
       func TestAAAARecord(t *testing.T) {

     

       521
       521
       +
       	addr := net.ParseIP("2001:db8::1")

     

       522
       522
       +
       	rdataBytes := []byte(addr)

     

       523
       523
       +
       	aaaa := &AAAA{}

     

       524
       524
       +
       

     

       525
       525
       +
       	offset, err := aaaa.Decode([]byte{}, 0, 16)

     

       526
       526
       +
       	assert.Error(t, err, "Decode should fail with empty buffer")

     

       527
       527
       +
       	assert.True(t, errors.Is(err, &BufferOverflowError{}))

     

       528
       528
       +
       

     

       529
       529
       +
       	offset, err = aaaa.Decode(rdataBytes, 0, 16)

     

       530
       530
       +
       	assert.NoError(t, err)

     

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

     

       532
       532
       +
       	assert.Equal(t, addr, aaaa.Address)

     

       533
       533
       +
       

     

       534
       534
       +
       	_, err = aaaa.Decode([]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}, 0, 15)

     

       535
       535
       +
       	assert.Error(t, err)

     

       536
       536
       +
       	assert.Contains(t, err.Error(), "AAAA record:")

     

       537
       537
       +
       

     

       538
       538
       +
       	aaaaEncode := &AAAA{Address: addr}

     

       539
       539
       +
       	encoded := encodeRData(t, aaaaEncode)

     

       540
       540
       +
       	assert.Equal(t, rdataBytes, encoded)

     

       541
       541
       +
       

     

       542
       542
       +
       	ipv4 := net.ParseIP("192.168.1.1")

     

       543
       543
       +
       	aaaaEncodeInvalid := &AAAA{Address: ipv4}

     

       544
       544
       +
       	_, err = aaaaEncodeInvalid.Encode([]byte{}, &map[string]uint16{})

     

       545
       545
       +
       

     

       546
       546
       +
       	assert.Error(t, err)

     

       547
       547
       +
       	assert.Contains(t, err.Error(), "cannot encode non-IPv6 address")

     

       548
       548
       +
       }

Compare changes