pax_global_header00006660000000000000000000000064145544222160014517gustar00rootroot0000000000000052 comment=8f6dc23cab83c45e0c31890eb0a0bfb6d12b9909 golang-github-jsimonetti-rtnetlink-1.4.1/000077500000000000000000000000001455442221600204445ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/.github/000077500000000000000000000000001455442221600220045ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/.github/dependabot.yml000066400000000000000000000003611455442221600246340ustar00rootroot00000000000000--- version: 2 updates: - package-ecosystem: "github-actions" directory: "/" schedule: interval: "monthly" - package-ecosystem: gomod directory: "/" schedule: interval: daily time: "04:00" open-pull-requests-limit: 10 golang-github-jsimonetti-rtnetlink-1.4.1/.github/workflows/000077500000000000000000000000001455442221600240415ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/.github/workflows/go-test.yml000066400000000000000000000035501455442221600261510ustar00rootroot00000000000000on: [push, pull_request] name: Go jobs: macos_test: name: Test MacOS strategy: matrix: go-version: [1.20.x, 1.21.x] platform: [macos-latest] runs-on: ${{ matrix.platform }} steps: - name: Install Go uses: actions/setup-go@0c52d547c9bc32b1aa3301fd7a9cb496313a4491 # v5.0.0 with: go-version: ${{ matrix.go-version }} id: go - name: Checkout code uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1 - name: Download dependencies run: go mod download - name: Go Vet run: go vet ./... - name: Fuzz build run: go build -tags=gofuzz ./... - name: Test run: go test ./... linux_test: name: Test Linux Integration strategy: matrix: go-version: [1.20.x, 1.21.x] platform: [ubuntu-latest] runs-on: ${{ matrix.platform }} steps: - name: Install Go uses: actions/setup-go@0c52d547c9bc32b1aa3301fd7a9cb496313a4491 # v5.0.0 with: go-version: ${{ matrix.go-version }} id: go - name: Checkout code uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1 - name: Download dependencies run: go mod download - name: Go Vet run: go vet ./... - name: Fuzz build run: go build -tags=gofuzz ./... - name: Test Integration run: sudo -E env PATH=$PATH go test -v -tags=integration ./... govuln_check: name: Check for vulnerabilities strategy: matrix: go-version: [1.20.x, 1.21.x] platform: [ubuntu-latest] runs-on: ${{ matrix.platform }} steps: - name: Check for vulnerabilities id: govulncheck uses: golang/govulncheck-action@7da72f730e37eeaad891fcff0a532d27ed737cd4 with: cache: false go-version-input: ${{ matrix.go-version }} go-package: ./... golang-github-jsimonetti-rtnetlink-1.4.1/.github/workflows/golangci-lint.yml000066400000000000000000000012411455442221600273110ustar00rootroot00000000000000--- name: golangci-lint on: push: paths: - "go.sum" - "go.mod" - "**.go" - ".github/workflows/golangci-lint.yml" - ".golangci.yml" pull_request: jobs: golangci: name: lint runs-on: ubuntu-latest steps: - name: Checkout repository uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1 - name: install Go uses: actions/setup-go@0c52d547c9bc32b1aa3301fd7a9cb496313a4491 # v5.0.0 with: go-version: 1.21.x - name: Lint uses: golangci/golangci-lint-action@3a919529898de77ec3da873e3063ca4b10e7f5cc # v3.7.0 with: version: v1.54.2 golang-github-jsimonetti-rtnetlink-1.4.1/.gitignore000066400000000000000000000000221455442221600224260ustar00rootroot00000000000000rtnetlink-fuzz.zipgolang-github-jsimonetti-rtnetlink-1.4.1/.golangci.yml000066400000000000000000000005701455442221600230320ustar00rootroot00000000000000--- linters: enable: - gofmt - misspell - revive linters-settings: misspell: ignore-words: # Incorrect spelling used in CacheInfo struct. - Prefered revive: rules: # https://github.com/mgechev/revive/blob/master/RULES_DESCRIPTIONS.md#unused-parameter - name: unused-parameter severity: warning disabled: true golang-github-jsimonetti-rtnetlink-1.4.1/LICENSE.md000066400000000000000000000020751455442221600220540ustar00rootroot00000000000000MIT License =========== Copyright (C) 2016 Jeroen Simonetti Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. golang-github-jsimonetti-rtnetlink-1.4.1/Makefile.fuzz000066400000000000000000000015411455442221600231020ustar00rootroot00000000000000# Makefile for fuzzing # # Currently fuzzing only works inside $GOPATH # # Installing go-fuzz #$ go get github.com/dvyukov/go-fuzz/go-fuzz #$ go get github.com/dvyukov/go-fuzz/go-fuzz-build # (or) #$ make -f Makefile.fuzz install # # Start fuzzing: #$ make -f Makefile.fuzz fuzz # # Cleanup using: #$ make -f Makefile.fuzz clean .PHONY: install install: go get github.com/dvyukov/go-fuzz/go-fuzz go get github.com/dvyukov/go-fuzz/go-fuzz-build .PHONY: fuzz fuzz: go-fuzz-build -tags gofuzz echo go-fuzz -bin=./rtnetlink-fuzz.zip -workdir=testdata -func FuzzLinkMessage echo go-fuzz -bin=./rtnetlink-fuzz.zip -workdir=testdata -func FuzzAddressMessage echo go-fuzz -bin=./rtnetlink-fuzz.zip -workdir=testdata -func FuzzRouteMessage echo go-fuzz -bin=./rtnetlink-fuzz.zip -workdir=testdata -func FuzzNeighMessage .PHONY: clean clean: rm rtnetlink-fuzz.zip golang-github-jsimonetti-rtnetlink-1.4.1/README.md000066400000000000000000000035361455442221600217320ustar00rootroot00000000000000rtnetlink ![Linux Integration](https://github.com/jsimonetti/rtnetlink/workflows/Go/badge.svg) [![GoDoc](https://godoc.org/github.com/jsimonetti/rtnetlink?status.svg)](https://godoc.org/github.com/jsimonetti/rtnetlink) [![Go Report Card](https://goreportcard.com/badge/github.com/jsimonetti/rtnetlink)](https://goreportcard.com/report/github.com/jsimonetti/rtnetlink) ======= Package `rtnetlink` allows the kernel's routing tables to be read and altered. Network routes, IP addresses, Link parameters, Neighbor setups, Queueing disciplines, Traffic classes and Packet classifiers may all be controlled. It is based on netlink messages. A convenient, high-level API wrapper is available using package [`rtnl`](https://godoc.org/github.com/jsimonetti/rtnetlink/rtnl). The base `rtnetlink` library explicitly only exposes a limited low-level API to rtnetlink. It is not the intention (nor wish) to create an iproute2 replacement. ### Debugging and netlink errors Unfortunately the errors generated by the kernels netlink interface are not very great. When in doubt about your message structure it can always be useful to look at the message send by iproute2 using `strace -f -esendmsg /bin/ip` or similar. Another (and possibly even more flexible) way would be using `nlmon` and `wireshark`. nlmod is a special kernel module which allows you to capture all netlink (not just rtnetlink) traffic inside the kernel. Be aware that this might be overwhelming on a system with a lot of netlink traffic. ``` # modprobe nlmon # ip link add type nlmon # ip link set nlmon0 up ``` At this point use wireshark or tcpdump on the nlmon0 interface to view all netlink traffic. Have a look at the examples for common uses of rtnetlink. If you have any questions or you'd like some guidance, please join us on [Gophers Slack](https://invite.slack.golangbridge.org) in the `#networking` channel! golang-github-jsimonetti-rtnetlink-1.4.1/address.go000066400000000000000000000145321455442221600224250ustar00rootroot00000000000000package rtnetlink import ( "errors" "fmt" "net" "github.com/jsimonetti/rtnetlink/internal/unix" "github.com/mdlayher/netlink" ) var ( // errInvalidaddressMessage is returned when a AddressMessage is malformed. errInvalidAddressMessage = errors.New("rtnetlink AddressMessage is invalid or too short") ) var _ Message = &AddressMessage{} // A AddressMessage is a route netlink address message. type AddressMessage struct { // Address family (current unix.AF_INET or unix.AF_INET6) Family uint8 // Prefix length PrefixLength uint8 // Contains address flags Flags uint8 // Address Scope Scope uint8 // Interface index Index uint32 // Optional attributes which are appended when not nil. Attributes *AddressAttributes } // MarshalBinary marshals a AddressMessage into a byte slice. func (m *AddressMessage) MarshalBinary() ([]byte, error) { b := make([]byte, unix.SizeofIfAddrmsg) b[0] = m.Family b[1] = m.PrefixLength b[2] = m.Flags b[3] = m.Scope nativeEndian.PutUint32(b[4:8], m.Index) if m.Attributes == nil { // No attributes to encode. return b, nil } ae := netlink.NewAttributeEncoder() err := m.Attributes.encode(ae) if err != nil { return nil, err } a, err := ae.Encode() if err != nil { return nil, err } return append(b, a...), nil } // UnmarshalBinary unmarshals the contents of a byte slice into a AddressMessage. func (m *AddressMessage) UnmarshalBinary(b []byte) error { l := len(b) if l < unix.SizeofIfAddrmsg { return errInvalidAddressMessage } m.Family = uint8(b[0]) m.PrefixLength = uint8(b[1]) m.Flags = uint8(b[2]) m.Scope = uint8(b[3]) m.Index = nativeEndian.Uint32(b[4:8]) if l > unix.SizeofIfAddrmsg { ad, err := netlink.NewAttributeDecoder(b[unix.SizeofIfAddrmsg:]) if err != nil { return err } var aa AddressAttributes if err := aa.decode(ad); err != nil { return err } // Must consume errors from decoder before returning. if err := ad.Err(); err != nil { return fmt.Errorf("invalid address message attributes: %v", err) } m.Attributes = &aa } return nil } // rtMessage is an empty method to sattisfy the Message interface. func (*AddressMessage) rtMessage() {} // AddressService is used to retrieve rtnetlink family information. type AddressService struct { c *Conn } // New creates a new address using the AddressMessage information. func (a *AddressService) New(req *AddressMessage) error { flags := netlink.Request | netlink.Create | netlink.Acknowledge | netlink.Excl _, err := a.c.Execute(req, unix.RTM_NEWADDR, flags) if err != nil { return err } return nil } // Delete removes an address using the AddressMessage information. func (a *AddressService) Delete(req *AddressMessage) error { flags := netlink.Request | netlink.Acknowledge _, err := a.c.Execute(req, unix.RTM_DELADDR, flags) if err != nil { return err } return nil } // List retrieves all addresses. func (a *AddressService) List() ([]AddressMessage, error) { req := AddressMessage{} flags := netlink.Request | netlink.Dump msgs, err := a.c.Execute(&req, unix.RTM_GETADDR, flags) if err != nil { return nil, err } addresses := make([]AddressMessage, len(msgs)) for i := range msgs { addresses[i] = *msgs[i].(*AddressMessage) } return addresses, nil } // AddressAttributes contains all attributes for an interface. type AddressAttributes struct { Address net.IP // Interface Ip address Local net.IP // Local Ip address Label string Broadcast net.IP // Broadcast Ip address Anycast net.IP // Anycast Ip address CacheInfo CacheInfo // Address information Multicast net.IP // Multicast Ip address Flags uint32 // Address flags } func (a *AddressAttributes) decode(ad *netlink.AttributeDecoder) error { for ad.Next() { switch ad.Type() { case unix.IFA_UNSPEC: // unused attribute case unix.IFA_ADDRESS: ad.Do(decodeIP(&a.Address)) case unix.IFA_LOCAL: ad.Do(decodeIP(&a.Local)) case unix.IFA_LABEL: a.Label = ad.String() case unix.IFA_BROADCAST: ad.Do(decodeIP(&a.Broadcast)) case unix.IFA_ANYCAST: ad.Do(decodeIP(&a.Anycast)) case unix.IFA_CACHEINFO: ad.Do(a.CacheInfo.decode) case unix.IFA_MULTICAST: ad.Do(decodeIP(&a.Multicast)) case unix.IFA_FLAGS: a.Flags = ad.Uint32() } } return nil } func (a *AddressAttributes) encode(ae *netlink.AttributeEncoder) error { ae.Uint16(unix.IFA_UNSPEC, 0) ae.Do(unix.IFA_ADDRESS, encodeIP(a.Address)) if a.Local != nil { ae.Do(unix.IFA_LOCAL, encodeIP(a.Local)) } if a.Broadcast != nil { ae.Do(unix.IFA_BROADCAST, encodeIP(a.Broadcast)) } if a.Anycast != nil { ae.Do(unix.IFA_ANYCAST, encodeIP(a.Anycast)) } if a.Multicast != nil { ae.Do(unix.IFA_MULTICAST, encodeIP(a.Multicast)) } if a.Label != "" { ae.String(unix.IFA_LABEL, a.Label) } ae.Uint32(unix.IFA_FLAGS, a.Flags) return nil } // CacheInfo contains address information type CacheInfo struct { Prefered uint32 Valid uint32 Created uint32 Updated uint32 } // decode decodes raw bytes into a CacheInfo's fields. func (c *CacheInfo) decode(b []byte) error { if len(b) != 16 { return fmt.Errorf("rtnetlink: incorrect CacheInfo size, want: 16, got: %d", len(b)) } c.Prefered = nativeEndian.Uint32(b[0:4]) c.Valid = nativeEndian.Uint32(b[4:8]) c.Created = nativeEndian.Uint32(b[8:12]) c.Updated = nativeEndian.Uint32(b[12:16]) return nil } // encodeIP is a helper for validating and encoding IPv4 and IPv6 addresses as // appropriate for the specified netlink attribute type. It should be used // with (*netlink.AttributeEncoder).Do. func encodeIP(ip net.IP) func() ([]byte, error) { return func() ([]byte, error) { // Don't allow nil or non 4/16-byte addresses. if ip == nil || ip.To16() == nil { return nil, fmt.Errorf("rtnetlink: cannot encode invalid IP address: %s", ip) } if ip4 := ip.To4(); ip4 != nil { // IPv4 address. return ip4, nil } // IPv6 address. return ip, nil } } // decodeIP is a helper for validating and decoding IPv4 and IPv6 addresses as // appropriate for the specified netlink attribute type. It should be used with // (*netlink.AttributeDecoder).Do. func decodeIP(ip *net.IP) func(b []byte) error { return func(b []byte) error { if l := len(b); l != 4 && l != 16 { return fmt.Errorf("rtnetlink: invalid IP address length: %d", l) } // We cannot retain b outside the closure, so make a copy into ip. *ip = make(net.IP, len(b)) copy(*ip, b) return nil } } golang-github-jsimonetti-rtnetlink-1.4.1/address_test.go000066400000000000000000000103551455442221600234630ustar00rootroot00000000000000package rtnetlink import ( "encoding/binary" "net" "testing" "github.com/google/go-cmp/cmp" "github.com/jsimonetti/rtnetlink/internal/unix" "github.com/mdlayher/netlink/nlenc" ) func TestAddressMessageMarshalBinary(t *testing.T) { skipBigEndian(t) tests := []struct { name string m Message b []byte err error }{ { name: "empty", m: &AddressMessage{}, b: []byte{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, }, }, { name: "no attributes", m: &AddressMessage{ Family: unix.AF_INET, PrefixLength: 8, Scope: 0, Index: 1, Flags: 0, }, b: []byte{ 0x02, 0x08, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, }, }, { name: "attributes", m: &AddressMessage{ Attributes: &AddressAttributes{ Address: net.IPv4(192, 0, 2, 1), Broadcast: net.IPv4(255, 255, 255, 255), Label: "lo", }, }, b: []byte{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x01, 0x00, 0xc0, 0x00, 0x02, 0x01, 0x08, 0x00, 0x04, 0x00, 0xff, 0xff, 0xff, 0xff, 0x07, 0x00, 0x03, 0x00, 0x6c, 0x6f, 0x00, 0x00, 0x08, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, }, }, { name: "no broadcast", m: &AddressMessage{ Attributes: &AddressAttributes{ Address: net.ParseIP("2001:db8::"), Label: "lo", }, }, b: []byte{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x01, 0x00, 0x20, 0x01, 0x0d, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x03, 0x00, 0x6c, 0x6f, 0x00, 0x00, 0x08, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, }, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { b, err := tt.m.MarshalBinary() if want, got := tt.err, err; want != got { t.Fatalf("unexpected error:\n- want: %v\n- got: %v", want, got) } if err != nil { return } if diff := cmp.Diff(tt.b, b); diff != "" { t.Fatalf("unexpected bytes (-want +got):\n%s", diff) } }) } } func TestAddressMessageUnmarshalBinary(t *testing.T) { skipBigEndian(t) tests := []struct { name string b []byte m Message ok bool }{ { name: "empty", }, { name: "short", b: make([]byte, 3), }, { name: "invalid attr", b: []byte{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x01, 0x00, 0xc0, 0x00, 0x02, 0x01, 0x08, 0x00, 0x06, 0x00, 0xff, 0xff, 0xff, 0xff, 0x08, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, }, }, { name: "data", b: []byte{ 0x02, 0x08, 0xfe, 0x01, 0x01, 0x00, 0x00, 0x00, 0x08, 0x00, 0x01, 0x00, 0x7f, 0x00, 0x00, 0x01, 0x08, 0x00, 0x02, 0x00, 0x7f, 0x00, 0x00, 0x01, 0x07, 0x00, 0x03, 0x00, 0x6c, 0x6f, 0x00, 0x00, 0x08, 0x00, 0x08, 0x00, 0x80, 0x00, 0x00, 0x00, 0x14, 0x00, 0x06, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x44, 0x01, 0x00, 0x00, 0x44, 0x01, 0x00, 0x00, }, m: &AddressMessage{ Family: 2, PrefixLength: 8, Flags: 0xfe, Scope: 1, Index: 1, Attributes: &AddressAttributes{ Address: net.IP{0x7f, 0x0, 0x0, 0x1}, Local: net.IP{0x7f, 0x0, 0x0, 0x1}, Label: "lo", Broadcast: net.IP(nil), Anycast: net.IP(nil), CacheInfo: CacheInfo{ Prefered: 0xffffffff, Valid: 0xffffffff, Created: 0x144, Updated: 0x144, }, Multicast: net.IP(nil), Flags: 0x80, }, }, ok: true, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { var m AddressMessage err := m.UnmarshalBinary(tt.b) if tt.ok && err != nil { t.Fatalf("failed to unmarshal binary: %v", err) } if !tt.ok && err == nil { t.Fatal("expected an error, but none occurred") } if err != nil { t.Logf("err: %v", err) return } if diff := cmp.Diff(tt.m, &m); diff != "" { t.Fatalf("unexpected AddressMessage (-want +got):\n%s", diff) } }) } } func skipBigEndian(t *testing.T) { if nlenc.NativeEndian() == binary.BigEndian { t.Skip("skipping test on big-endian system") } } golang-github-jsimonetti-rtnetlink-1.4.1/conn.go000066400000000000000000000121711455442221600217320ustar00rootroot00000000000000package rtnetlink import ( "encoding" "time" "github.com/jsimonetti/rtnetlink/internal/unix" "github.com/mdlayher/netlink" ) // A Conn is a route netlink connection. A Conn can be used to send and // receive route netlink messages to and from netlink. type Conn struct { c conn Link *LinkService Address *AddressService Route *RouteService Neigh *NeighService Rule *RuleService } var _ conn = &netlink.Conn{} // A conn is a netlink connection, which can be swapped for tests. type conn interface { Close() error Send(m netlink.Message) (netlink.Message, error) Receive() ([]netlink.Message, error) Execute(m netlink.Message) ([]netlink.Message, error) SetOption(option netlink.ConnOption, enable bool) error SetReadDeadline(t time.Time) error } // Dial dials a route netlink connection. Config specifies optional // configuration for the underlying netlink connection. If config is // nil, a default configuration will be used. func Dial(config *netlink.Config) (*Conn, error) { c, err := netlink.Dial(unix.NETLINK_ROUTE, config) if err != nil { return nil, err } return newConn(c), nil } // newConn creates a Conn that wraps an existing *netlink.Conn for // rtnetlink communications. It is used for testing. func newConn(c conn) *Conn { rtc := &Conn{ c: c, } rtc.Link = &LinkService{c: rtc} rtc.Address = &AddressService{c: rtc} rtc.Route = &RouteService{c: rtc} rtc.Neigh = &NeighService{c: rtc} rtc.Rule = &RuleService{c: rtc} return rtc } // Close closes the connection. func (c *Conn) Close() error { return c.c.Close() } // SetOption enables or disables a netlink socket option for the Conn. func (c *Conn) SetOption(option netlink.ConnOption, enable bool) error { return c.c.SetOption(option, enable) } // SetReadDeadline sets the read deadline associated with the connection. func (c *Conn) SetReadDeadline(t time.Time) error { return c.c.SetReadDeadline(t) } // Send sends a single Message to netlink, wrapping it in a netlink.Message // using the specified generic netlink family and flags. On success, Send // returns a copy of the netlink.Message with all parameters populated, for // later validation. func (c *Conn) Send(m Message, family uint16, flags netlink.HeaderFlags) (netlink.Message, error) { nm := netlink.Message{ Header: netlink.Header{ Type: netlink.HeaderType(family), Flags: flags, }, } mb, err := m.MarshalBinary() if err != nil { return netlink.Message{}, err } nm.Data = mb reqnm, err := c.c.Send(nm) if err != nil { return netlink.Message{}, err } return reqnm, nil } // Receive receives one or more Messages from netlink. The netlink.Messages // used to wrap each Message are available for later validation. func (c *Conn) Receive() ([]Message, []netlink.Message, error) { msgs, err := c.c.Receive() if err != nil { return nil, nil, err } rtmsgs, err := unpackMessages(msgs) if err != nil { return nil, nil, err } return rtmsgs, msgs, nil } // Execute sends a single Message to netlink using Send, receives one or more // replies using Receive, and then checks the validity of the replies against // the request using netlink.Validate. // // Execute acquires a lock for the duration of the function call which blocks // concurrent calls to Send and Receive, in order to ensure consistency between // generic netlink request/reply messages. // // See the documentation of Send, Receive, and netlink.Validate for details // about each function. func (c *Conn) Execute(m Message, family uint16, flags netlink.HeaderFlags) ([]Message, error) { nm, err := packMessage(m, family, flags) if err != nil { return nil, err } msgs, err := c.c.Execute(nm) if err != nil { return nil, err } return unpackMessages(msgs) } // Message is the interface used for passing around different kinds of rtnetlink messages type Message interface { encoding.BinaryMarshaler encoding.BinaryUnmarshaler rtMessage() } // packMessage packs a rtnetlink Message into a netlink.Message with the // appropriate rtnetlink family and netlink flags. func packMessage(m Message, family uint16, flags netlink.HeaderFlags) (netlink.Message, error) { nm := netlink.Message{ Header: netlink.Header{ Type: netlink.HeaderType(family), Flags: flags, }, } mb, err := m.MarshalBinary() if err != nil { return netlink.Message{}, err } nm.Data = mb return nm, nil } // unpackMessages unpacks rtnetlink Messages from a slice of netlink.Messages. func unpackMessages(msgs []netlink.Message) ([]Message, error) { lmsgs := make([]Message, 0, len(msgs)) for _, nm := range msgs { var m Message switch nm.Header.Type { case unix.RTM_GETLINK, unix.RTM_NEWLINK, unix.RTM_DELLINK: m = &LinkMessage{} case unix.RTM_GETADDR, unix.RTM_NEWADDR, unix.RTM_DELADDR: m = &AddressMessage{} case unix.RTM_GETROUTE, unix.RTM_NEWROUTE, unix.RTM_DELROUTE: m = &RouteMessage{} case unix.RTM_GETNEIGH, unix.RTM_NEWNEIGH, unix.RTM_DELNEIGH: m = &NeighMessage{} case unix.RTM_GETRULE, unix.RTM_NEWRULE, unix.RTM_DELRULE: m = &RuleMessage{} default: continue } if err := (m).UnmarshalBinary(nm.Data); err != nil { return nil, err } lmsgs = append(lmsgs, m) } return lmsgs, nil } golang-github-jsimonetti-rtnetlink-1.4.1/conn_test.go000066400000000000000000000116511455442221600227730ustar00rootroot00000000000000//go:build linux // +build linux package rtnetlink import ( "encoding" "fmt" "os" "reflect" "testing" "time" "github.com/mdlayher/netlink" "golang.org/x/sys/unix" ) func TestConnExecute(t *testing.T) { skipBigEndian(t) req := &LinkMessage{} wantnl := netlink.Message{ Header: netlink.Header{ Type: unix.RTM_GETLINK, Flags: netlink.Request, // Sequence and PID not set because we are mocking the underlying // netlink connection. }, Data: mustMarshal(req), } wantrt := []LinkMessage{ { Family: 0x101, Type: 0x0, Index: 0x4030201, Flags: 0x101, Change: 0x4030201, }, } c, tc := testConn(t) tc.receive = []netlink.Message{{ Header: netlink.Header{ Length: 16, Type: unix.RTM_GETLINK, // Sequence and PID not set because we are mocking the underlying // netlink connection. }, Data: []byte{ 0x01, 0x01, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x01, 0x01, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, }, }} msgs, err := c.Execute(req, unix.RTM_GETLINK, netlink.Request) if err != nil { t.Fatalf("failed to execute: %v", err) } links := make([]LinkMessage, 0, len(msgs)) for _, m := range msgs { link := (m).(*LinkMessage) links = append(links, *link) } if want, got := wantnl, tc.send; !reflect.DeepEqual(want, got) { t.Fatalf("unexpected request:\n- want: %#v\n- got: %#v", want, got) } if want, got := wantrt, links; !reflect.DeepEqual(want, got) { t.Fatalf("unexpected replies:\n- want: %#v\n- got: %#v", want, got) } } func TestConnSend(t *testing.T) { skipBigEndian(t) req := &LinkMessage{} c, tc := testConn(t) nlreq, err := c.Send(req, unix.RTM_GETLINK, netlink.Request) if err != nil { t.Fatalf("failed to send: %v", err) } reqb, err := req.MarshalBinary() if err != nil { t.Fatalf("failed to marshal request: %v", err) } want := netlink.Message{ Header: netlink.Header{ Type: unix.RTM_GETLINK, Flags: netlink.Request, }, Data: reqb, } if got := tc.send; !reflect.DeepEqual(want, got) { t.Fatalf("unexpected output message from Conn.Send:\n- want: %#v\n- got: %#v", want, got) } if got := nlreq; !reflect.DeepEqual(want, got) { t.Fatalf("unexpected modified message:\n- want: %#v\n- got: %#v", want, got) } } func TestConnReceive(t *testing.T) { skipBigEndian(t) c, tc := testConn(t) tc.receive = []netlink.Message{ { Header: netlink.Header{ Length: 16, Sequence: 1, Type: unix.RTM_GETLINK, PID: uint32(os.Getpid()), }, Data: []byte{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, }, }, { Header: netlink.Header{ Length: 16, Sequence: 1, Type: unix.RTM_GETLINK, PID: uint32(os.Getpid()), }, Data: []byte{ 0x02, 0x01, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x02, 0x01, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, }, }, } wantnl := tc.receive wantrt := []LinkMessage{ { Family: 0x0, Type: 0x0, Index: 0x0, Flags: 0x0, Change: 0x0, }, { Family: 0x102, Type: 0x0, Index: 0x4030201, Flags: 0x102, Change: 0x4030201, }, } rtmsgs, nlmsgs, err := c.Receive() if err != nil { t.Fatalf("failed to receive messages: %v", err) } links := make([]LinkMessage, 0, len(rtmsgs)) for _, m := range rtmsgs { link := (m).(*LinkMessage) links = append(links, *link) } if want, got := wantnl, nlmsgs; !reflect.DeepEqual(want, got) { t.Fatalf("unexpected netlink.Messages from Conn.Receive:\n- want: %#v\n- got: %#v", want, got) } if want, got := wantrt, links; !reflect.DeepEqual(want, got) { t.Fatalf("unexpected Messages from Conn.Receive:\n- want: %#v\n- got: %#v", want, got) } } func testConn(t *testing.T) (*Conn, *testNetlinkConn) { c := &testNetlinkConn{} return newConn(c), c } type testNetlinkConn struct { send netlink.Message receive []netlink.Message noopConn } func (c *testNetlinkConn) Send(m netlink.Message) (netlink.Message, error) { c.send = m return m, nil } func (c *testNetlinkConn) Receive() ([]netlink.Message, error) { return c.receive, nil } func (c *testNetlinkConn) Execute(m netlink.Message) ([]netlink.Message, error) { c.send = m return c.receive, nil } type noopConn struct{} func (c *noopConn) Close() error { return nil } func (c *noopConn) Send(_ netlink.Message) (netlink.Message, error) { return netlink.Message{}, nil } func (c *noopConn) Receive() ([]netlink.Message, error) { return nil, nil } func (c *noopConn) Execute(m netlink.Message) ([]netlink.Message, error) { return nil, nil } func (c *noopConn) SetOption(_ netlink.ConnOption, _ bool) error { return nil } func (c *noopConn) SetReadDeadline(t time.Time) error { return nil } func mustMarshal(m encoding.BinaryMarshaler) []byte { b, err := m.MarshalBinary() if err != nil { panic(fmt.Sprintf("failed to marshal binary: %v", err)) } return b } golang-github-jsimonetti-rtnetlink-1.4.1/doc.go000066400000000000000000000024121455442221600215370ustar00rootroot00000000000000// Package rtnetlink allows the kernel's routing tables to be read and altered. // Network routes, IP addresses, Link parameters, Neighbor setups, Queueing disciplines, // Traffic classes and Packet classifiers may all be controlled. // It is based on netlink messages. // // A convenient, high-level API wrapper is available using package rtnl: // https://godoc.org/github.com/jsimonetti/rtnetlink/rtnl. // // The base rtnetlink library xplicitly only exposes a limited low-level API to rtnetlink. // It is not the intention (nor wish) to create an iproute2 replacement. // // When in doubt about your message structure it can always be useful to look at the // message send by iproute2 using 'strace -f -esendmsg' or similar. // // Another (and possibly even more flexible) way would be using 'nlmon' and wireshark. // nlmod is a special kernel module which allows you to capture all (not just rtnetlink) // netlink traffic inside the kernel. Be aware that this might be overwhelming on a system // with a lot of netlink traffic. // // # modprobe nlmon // # ip link add type nlmon // # ip link set nlmon0 up // // At this point use wireshark or tcpdump on the nlmon0 interface to view all netlink traffic. // // Have a look at the examples for common uses of rtnetlink. package rtnetlink golang-github-jsimonetti-rtnetlink-1.4.1/endian.go000066400000000000000000000002601455442221600222270ustar00rootroot00000000000000package rtnetlink import ( "encoding/binary" "github.com/mdlayher/netlink/nlenc" ) var nativeEndian binary.ByteOrder func init() { nativeEndian = nlenc.NativeEndian() } golang-github-jsimonetti-rtnetlink-1.4.1/example_address_add_test.go000066400000000000000000000025221455442221600260030ustar00rootroot00000000000000//go:build linux // +build linux package rtnetlink_test import ( "encoding/binary" "log" "net" "github.com/jsimonetti/rtnetlink" "golang.org/x/sys/unix" ) // Add IP address '127.0.0.2/8' to an interface 'lo' func Example_addAddress() { // Gather the interface Index iface, _ := net.InterfaceByName("lo") // Get an ip address to add to the interface addr, cidr, _ := net.ParseCIDR("127.0.0.2/8") // Dial a connection to the rtnetlink socket conn, err := rtnetlink.Dial(nil) if err != nil { log.Fatal(err) } defer conn.Close() // Test for the right address family for addr family := unix.AF_INET6 to4 := cidr.IP.To4() if to4 != nil { family = unix.AF_INET } // Calculate the prefix length ones, _ := cidr.Mask.Size() // Calculate the broadcast IP // Only used when family is AF_INET var brd net.IP if to4 != nil { brd = make(net.IP, len(to4)) binary.BigEndian.PutUint32(brd, binary.BigEndian.Uint32(to4)|^binary.BigEndian.Uint32(net.IP(cidr.Mask).To4())) } // Send the message using the rtnetlink.Conn err = conn.Address.New(&rtnetlink.AddressMessage{ Family: uint8(family), PrefixLength: uint8(ones), Scope: unix.RT_SCOPE_UNIVERSE, Index: uint32(iface.Index), Attributes: &rtnetlink.AddressAttributes{ Address: addr, Local: addr, Broadcast: brd, }, }) log.Fatal(err) } golang-github-jsimonetti-rtnetlink-1.4.1/example_address_del_test.go000066400000000000000000000024431455442221600260210ustar00rootroot00000000000000//go:build linux // +build linux package rtnetlink_test import ( "encoding/binary" "log" "net" "github.com/jsimonetti/rtnetlink" "golang.org/x/sys/unix" ) // Delete IP address '127.0.0.2/8' from interface 'lo' func Example_deleteAddress() { // Gather the interface Index iface, _ := net.InterfaceByName("lo") // Get an ip address to delete from the interface addr, cidr, _ := net.ParseCIDR("127.0.0.2/8") // Dial a connection to the rtnetlink socket conn, err := rtnetlink.Dial(nil) if err != nil { log.Fatal(err) } defer conn.Close() // Test for the right address family for addr family := unix.AF_INET6 to4 := cidr.IP.To4() if to4 != nil { family = unix.AF_INET } // Calculate the prefix length ones, _ := cidr.Mask.Size() // Calculate the broadcast IP // Only used when family is AF_INET var brd net.IP if to4 != nil { brd = make(net.IP, len(to4)) binary.BigEndian.PutUint32(brd, binary.BigEndian.Uint32(to4)|^binary.BigEndian.Uint32(net.IP(cidr.Mask).To4())) } // Send the message using the rtnetlink.Conn err = conn.Address.Delete(&rtnetlink.AddressMessage{ Family: uint8(family), PrefixLength: uint8(ones), Index: uint32(iface.Index), Attributes: &rtnetlink.AddressAttributes{ Address: addr, Broadcast: brd, }, }) log.Fatal(err) } golang-github-jsimonetti-rtnetlink-1.4.1/example_address_list_test.go000066400000000000000000000017111455442221600262250ustar00rootroot00000000000000//go:build linux // +build linux package rtnetlink_test import ( "log" "net" "github.com/jsimonetti/rtnetlink" "golang.org/x/sys/unix" ) // List all IPv4 addresses configured on interface 'lo' func Example_listAddress() { // Gather the interface Index iface, _ := net.InterfaceByName("lo") // Get an ip address to add to the interface family := uint8(unix.AF_INET) // Dial a connection to the rtnetlink socket conn, err := rtnetlink.Dial(nil) if err != nil { log.Fatal(err) } defer conn.Close() // Request a list of addresses msg, err := conn.Address.List() if err != nil { log.Fatal(err) } // Filter out the wanted messages and put them in the 'addr' slice. var addr []rtnetlink.AddressMessage for _, v := range msg { add := true if iface != nil && v.Index != uint32(iface.Index) { add = false } if family != 0 && v.Family != family { add = false } if add { addr = append(addr, v) } } log.Printf("%#v", addr) } golang-github-jsimonetti-rtnetlink-1.4.1/example_link_list_test.go000066400000000000000000000006111455442221600255330ustar00rootroot00000000000000package rtnetlink_test import ( "log" "github.com/jsimonetti/rtnetlink" ) // List all interfaces func Example_listLink() { // Dial a connection to the rtnetlink socket conn, err := rtnetlink.Dial(nil) if err != nil { log.Fatal(err) } defer conn.Close() // Request a list of interfaces msg, err := conn.Link.List() if err != nil { log.Fatal(err) } log.Printf("%#v", msg) } golang-github-jsimonetti-rtnetlink-1.4.1/example_link_setdown_test.go000066400000000000000000000015301455442221600262440ustar00rootroot00000000000000package rtnetlink_test import ( "log" "net" "github.com/jsimonetti/rtnetlink" ) // Set the operational state an interface to Down func Example_setLinkDown() { // Gather the interface Index iface, _ := net.InterfaceByName("dummy0") // Dial a connection to the rtnetlink socket conn, err := rtnetlink.Dial(nil) if err != nil { log.Fatal(err) } defer conn.Close() // Request the details of the interface msg, err := conn.Link.Get(uint32(iface.Index)) if err != nil { log.Fatal(err) } state := msg.Attributes.OperationalState // If the link is already down, return immediately if state == rtnetlink.OperStateDown { return } // Set the interface operationally Down err = conn.Link.Set(&rtnetlink.LinkMessage{ Family: 0x0, Type: msg.Type, Index: uint32(iface.Index), Flags: 0x0, Change: 0x1, }) log.Fatal(err) } golang-github-jsimonetti-rtnetlink-1.4.1/example_link_sethwaddr_test.go000066400000000000000000000015451455442221600265540ustar00rootroot00000000000000package rtnetlink_test import ( "log" "net" "github.com/jsimonetti/rtnetlink" ) // Set the hw address of an interface func Example_setLinkHWAddr() { // Gather the interface Index iface, _ := net.InterfaceByName("dummy0") // Get a hw addr to set the interface to hwAddr, _ := net.ParseMAC("ce:9c:5b:98:55:9c") // Dial a connection to the rtnetlink socket conn, err := rtnetlink.Dial(nil) if err != nil { log.Fatal(err) } defer conn.Close() // Request the details of the interface msg, err := conn.Link.Get(uint32(iface.Index)) if err != nil { log.Fatal(err) } // Set the hw address of the interfaces err = conn.Link.Set(&rtnetlink.LinkMessage{ Family: 0x0, Type: msg.Type, Index: uint32(iface.Index), Flags: msg.Flags, Change: msg.Change, Attributes: &rtnetlink.LinkAttributes{ Address: hwAddr, }, }) log.Fatal(err) } golang-github-jsimonetti-rtnetlink-1.4.1/example_link_setup_test.go000066400000000000000000000017131455442221600257240ustar00rootroot00000000000000//go:build linux // +build linux package rtnetlink_test import ( "log" "net" "github.com/jsimonetti/rtnetlink" "golang.org/x/sys/unix" ) // Set the operational state an interface to Up func Example_setLinkUp() { // Gather the interface Index iface, _ := net.InterfaceByName("dummy0") // Dial a connection to the rtnetlink socket conn, err := rtnetlink.Dial(nil) if err != nil { log.Fatal(err) } defer conn.Close() // Request the details of the interface msg, err := conn.Link.Get(uint32(iface.Index)) if err != nil { log.Fatal(err) } state := msg.Attributes.OperationalState // If the link is already up, return immediately if state == rtnetlink.OperStateUp || state == rtnetlink.OperStateUnknown { return } // Set the interface operationally UP err = conn.Link.Set(&rtnetlink.LinkMessage{ Family: unix.AF_UNSPEC, Type: msg.Type, Index: uint32(iface.Index), Flags: unix.IFF_UP, Change: unix.IFF_UP, }) log.Fatal(err) } golang-github-jsimonetti-rtnetlink-1.4.1/example_neigh_list_test.go000066400000000000000000000016531455442221600256770ustar00rootroot00000000000000//go:build linux // +build linux package rtnetlink_test import ( "log" "net" "github.com/jsimonetti/rtnetlink" "golang.org/x/sys/unix" ) // List all neighbors on interface 'lo' func Example_listNeighbors() { // Gather the interface Index iface, _ := net.InterfaceByName("lo") // Get an ip address to add to the interface family := uint8(unix.AF_INET) // Dial a connection to the rtnetlink socket conn, err := rtnetlink.Dial(nil) if err != nil { log.Fatal(err) } defer conn.Close() // Request all neighbors msg, err := conn.Neigh.List() if err != nil { log.Fatal(err) } // Filter neighbors by family and interface index var neigh []rtnetlink.NeighMessage for _, v := range msg { add := true if iface != nil && v.Index != uint32(iface.Index) { add = false } if family != 0 && v.Family != uint16(family) { add = false } if add { neigh = append(neigh, v) } } log.Printf("%#v", neigh) } golang-github-jsimonetti-rtnetlink-1.4.1/example_route_add_test.go000066400000000000000000000016711455442221600255200ustar00rootroot00000000000000//go:build linux // +build linux package rtnetlink_test import ( "log" "net" "github.com/jsimonetti/rtnetlink" "golang.org/x/sys/unix" ) // Add a route func Example_addRoute() { // Gather the interface Index iface, _ := net.InterfaceByName("lo") // Get a route to add _, dst, _ := net.ParseCIDR("192.168.0.0/16") // Get a gw to use gw := net.ParseIP("127.0.0.1") // Dial a connection to the rtnetlink socket conn, err := rtnetlink.Dial(nil) if err != nil { log.Fatal(err) } defer conn.Close() attr := rtnetlink.RouteAttributes{ Dst: dst.IP, OutIface: uint32(iface.Index), } if gw == nil { attr.Gateway = gw } ones, _ := dst.Mask.Size() err = conn.Route.Add(&rtnetlink.RouteMessage{ Family: unix.AF_INET, Table: unix.RT_TABLE_MAIN, Protocol: unix.RTPROT_BOOT, Scope: unix.RT_SCOPE_LINK, Type: unix.RTN_UNICAST, DstLength: uint8(ones), Attributes: attr, }) log.Fatal(err) } golang-github-jsimonetti-rtnetlink-1.4.1/example_rule_list_test.go000066400000000000000000000006441455442221600255530ustar00rootroot00000000000000package rtnetlink_test import ( "log" "github.com/jsimonetti/rtnetlink" ) // List all rules func Example_listRule() { // Dial a connection to the rtnetlink socket conn, err := rtnetlink.Dial(nil) if err != nil { log.Fatal(err) } defer conn.Close() // Request a list of rules rules, err := conn.Rule.List() if err != nil { log.Fatal(err) } for _, rule := range rules { log.Printf("%+v", rule) } } golang-github-jsimonetti-rtnetlink-1.4.1/fuzz-shell.nix000066400000000000000000000010421455442221600232640ustar00rootroot00000000000000with import { }; pkgs.mkShell { name = "go-fuzz"; buildInputs = [ go ]; shellHook = '' echo "Fuzz with commands:" echo "" echo "go test -fuzz=AddressMessage - will start fuzzing Address Messages" echo "go test -fuzz=LinkMessage - will start fuzzing Link Messages" echo "go test -fuzz=NeighMessage - will start fuzzing Neigh Messages" echo "go test -fuzz=RouteMessage - will start fuzzing Route Messages" echo "go test -fuzz=RuleMessage - will start fuzzing Rule Messages" echo "" ''; } golang-github-jsimonetti-rtnetlink-1.4.1/fuzz_test.go000066400000000000000000000017411455442221600230330ustar00rootroot00000000000000//go:build go1.18 // +build go1.18 package rtnetlink import "testing" // FuzzLinkMessage will fuzz a LinkMessage func FuzzLinkMessage(f *testing.F) { f.Fuzz(func(t *testing.T, data []byte) { m := &LinkMessage{} _ = m.UnmarshalBinary(data) }) } // FuzzAddressMessage will fuzz an AddressMessage func FuzzAddressMessage(f *testing.F) { f.Fuzz(func(t *testing.T, data []byte) { m := &LinkMessage{} _ = m.UnmarshalBinary(data) }) } // FuzzNeighMessage will fuzz a NeighMessage func FuzzNeighMessage(f *testing.F) { f.Fuzz(func(t *testing.T, data []byte) { m := &LinkMessage{} _ = m.UnmarshalBinary(data) }) } // FuzzRouteMessage will fuzz a RouteMessage func FuzzRouteMessage(f *testing.F) { f.Fuzz(func(t *testing.T, data []byte) { m := &LinkMessage{} _ = m.UnmarshalBinary(data) }) } // FuzzRuleMessage will fuzz a RuleMessage func FuzzRuleMessage(f *testing.F) { f.Fuzz(func(t *testing.T, data []byte) { m := &RuleMessage{} _ = m.UnmarshalBinary(data) }) } golang-github-jsimonetti-rtnetlink-1.4.1/go.mod000066400000000000000000000006651455442221600215610ustar00rootroot00000000000000module github.com/jsimonetti/rtnetlink go 1.20 require ( github.com/cilium/ebpf v0.12.3 github.com/google/go-cmp v0.6.0 github.com/mdlayher/netlink v1.7.2 golang.org/x/sys v0.16.0 ) require ( github.com/josharian/native v1.1.0 // indirect github.com/mdlayher/socket v0.4.1 // indirect golang.org/x/exp v0.0.0-20230224173230-c95f2b4c22f2 // indirect golang.org/x/net v0.17.0 // indirect golang.org/x/sync v0.1.0 // indirect ) golang-github-jsimonetti-rtnetlink-1.4.1/go.sum000066400000000000000000000034561455442221600216070ustar00rootroot00000000000000github.com/cilium/ebpf v0.12.3 h1:8ht6F9MquybnY97at+VDZb3eQQr8ev79RueWeVaEcG4= github.com/cilium/ebpf v0.12.3/go.mod h1:TctK1ivibvI3znr66ljgi4hqOT8EYQjz1KWBfb1UVgM= github.com/frankban/quicktest v1.14.5 h1:dfYrrRyLtiqT9GyKXgdh+k4inNeTvmGbuSgZ3lx3GhA= github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= github.com/josharian/native v1.1.0 h1:uuaP0hAbW7Y4l0ZRQ6C9zfb7Mg1mbFKry/xzDAfmtLA= github.com/josharian/native v1.1.0/go.mod h1:7X/raswPFr05uY3HiLlYeyQntB6OO7E/d2Cu7qoaN2w= github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= github.com/mdlayher/netlink v1.7.2 h1:/UtM3ofJap7Vl4QWCPDGXY8d3GIY2UGSDbK+QWmY8/g= github.com/mdlayher/netlink v1.7.2/go.mod h1:xraEF7uJbxLhc5fpHL4cPe221LI2bdttWlU+ZGLfQSw= github.com/mdlayher/socket v0.4.1 h1:eM9y2/jlbs1M615oshPQOHZzj6R6wMT7bX5NPiQvn2U= github.com/mdlayher/socket v0.4.1/go.mod h1:cAqeGjoufqdxWkD7DkpyS+wcefOtmu5OQ8KuoJGIReA= github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8= golang.org/x/exp v0.0.0-20230224173230-c95f2b4c22f2 h1:Jvc7gsqn21cJHCmAWx0LiimpP18LZmUxkT5Mp7EZ1mI= golang.org/x/exp v0.0.0-20230224173230-c95f2b4c22f2/go.mod h1:CxIveKay+FTh1D0yPZemJVgC/95VzuuOLq5Qi4xnoYc= golang.org/x/net v0.17.0 h1:pVaXccu2ozPjCXewfr1S7xza/zcXTity9cCdXQYSjIM= golang.org/x/net v0.17.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE= golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o= golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sys v0.16.0 h1:xWw16ngr6ZMtmxDyKyIgsE93KNKz5HKmMa3b8ALHidU= golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang-github-jsimonetti-rtnetlink-1.4.1/internal/000077500000000000000000000000001455442221600222605ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/internal/unix/000077500000000000000000000000001455442221600232435ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/internal/unix/types_linux.go000066400000000000000000000157001455442221600261600ustar00rootroot00000000000000//go:build linux // +build linux package unix import ( linux "golang.org/x/sys/unix" ) const ( AF_INET = linux.AF_INET AF_INET6 = linux.AF_INET6 AF_UNSPEC = linux.AF_UNSPEC NETLINK_ROUTE = linux.NETLINK_ROUTE SizeofIfAddrmsg = linux.SizeofIfAddrmsg SizeofIfInfomsg = linux.SizeofIfInfomsg SizeofNdMsg = linux.SizeofNdMsg SizeofRtMsg = linux.SizeofRtMsg SizeofRtNexthop = linux.SizeofRtNexthop RTM_NEWADDR = linux.RTM_NEWADDR RTM_DELADDR = linux.RTM_DELADDR RTM_GETADDR = linux.RTM_GETADDR RTM_NEWLINK = linux.RTM_NEWLINK RTM_DELLINK = linux.RTM_DELLINK RTM_GETLINK = linux.RTM_GETLINK RTM_SETLINK = linux.RTM_SETLINK RTM_NEWROUTE = linux.RTM_NEWROUTE RTM_DELROUTE = linux.RTM_DELROUTE RTM_GETROUTE = linux.RTM_GETROUTE RTM_NEWNEIGH = linux.RTM_NEWNEIGH RTM_DELNEIGH = linux.RTM_DELNEIGH RTM_GETNEIGH = linux.RTM_GETNEIGH IFA_UNSPEC = linux.IFA_UNSPEC IFA_ADDRESS = linux.IFA_ADDRESS IFA_LOCAL = linux.IFA_LOCAL IFA_LABEL = linux.IFA_LABEL IFA_BROADCAST = linux.IFA_BROADCAST IFA_ANYCAST = linux.IFA_ANYCAST IFA_CACHEINFO = linux.IFA_CACHEINFO IFA_MULTICAST = linux.IFA_MULTICAST IFA_FLAGS = linux.IFA_FLAGS IFF_UP = linux.IFF_UP IFF_BROADCAST = linux.IFF_BROADCAST IFF_LOOPBACK = linux.IFF_LOOPBACK IFF_POINTOPOINT = linux.IFF_POINTOPOINT IFF_MULTICAST = linux.IFF_MULTICAST IFLA_UNSPEC = linux.IFLA_UNSPEC IFLA_ADDRESS = linux.IFLA_ADDRESS IFLA_BROADCAST = linux.IFLA_BROADCAST IFLA_IFNAME = linux.IFLA_IFNAME IFLA_MTU = linux.IFLA_MTU IFLA_LINK = linux.IFLA_LINK IFLA_QDISC = linux.IFLA_QDISC IFLA_OPERSTATE = linux.IFLA_OPERSTATE IFLA_STATS = linux.IFLA_STATS IFLA_STATS64 = linux.IFLA_STATS64 IFLA_TXQLEN = linux.IFLA_TXQLEN IFLA_GROUP = linux.IFLA_GROUP IFLA_LINKINFO = linux.IFLA_LINKINFO IFLA_LINKMODE = linux.IFLA_LINKMODE IFLA_IFALIAS = linux.IFLA_IFALIAS IFLA_MASTER = linux.IFLA_MASTER IFLA_CARRIER = linux.IFLA_CARRIER IFLA_CARRIER_CHANGES = linux.IFLA_CARRIER_CHANGES IFLA_CARRIER_UP_COUNT = linux.IFLA_CARRIER_UP_COUNT IFLA_CARRIER_DOWN_COUNT = linux.IFLA_CARRIER_DOWN_COUNT IFLA_PHYS_PORT_ID = linux.IFLA_PHYS_PORT_ID IFLA_PHYS_SWITCH_ID = linux.IFLA_PHYS_SWITCH_ID IFLA_PHYS_PORT_NAME = linux.IFLA_PHYS_PORT_NAME IFLA_INFO_KIND = linux.IFLA_INFO_KIND IFLA_INFO_SLAVE_KIND = linux.IFLA_INFO_SLAVE_KIND IFLA_INFO_DATA = linux.IFLA_INFO_DATA IFLA_INFO_SLAVE_DATA = linux.IFLA_INFO_SLAVE_DATA IFLA_XDP = linux.IFLA_XDP IFLA_XDP_FD = linux.IFLA_XDP_FD IFLA_XDP_ATTACHED = linux.IFLA_XDP_ATTACHED IFLA_XDP_FLAGS = linux.IFLA_XDP_FLAGS IFLA_XDP_PROG_ID = linux.IFLA_XDP_PROG_ID IFLA_XDP_EXPECTED_FD = linux.IFLA_XDP_EXPECTED_FD XDP_FLAGS_DRV_MODE = linux.XDP_FLAGS_DRV_MODE XDP_FLAGS_SKB_MODE = linux.XDP_FLAGS_SKB_MODE XDP_FLAGS_HW_MODE = linux.XDP_FLAGS_HW_MODE XDP_FLAGS_MODES = linux.XDP_FLAGS_MODES XDP_FLAGS_MASK = linux.XDP_FLAGS_MASK XDP_FLAGS_REPLACE = linux.XDP_FLAGS_REPLACE XDP_FLAGS_UPDATE_IF_NOEXIST = linux.XDP_FLAGS_UPDATE_IF_NOEXIST LWTUNNEL_ENCAP_MPLS = linux.LWTUNNEL_ENCAP_MPLS MPLS_IPTUNNEL_DST = linux.MPLS_IPTUNNEL_DST MPLS_IPTUNNEL_TTL = linux.MPLS_IPTUNNEL_TTL NDA_UNSPEC = linux.NDA_UNSPEC NDA_DST = linux.NDA_DST NDA_LLADDR = linux.NDA_LLADDR NDA_CACHEINFO = linux.NDA_CACHEINFO NDA_IFINDEX = linux.NDA_IFINDEX RTA_UNSPEC = linux.RTA_UNSPEC RTA_DST = linux.RTA_DST RTA_ENCAP = linux.RTA_ENCAP RTA_ENCAP_TYPE = linux.RTA_ENCAP_TYPE RTA_PREFSRC = linux.RTA_PREFSRC RTA_GATEWAY = linux.RTA_GATEWAY RTA_OIF = linux.RTA_OIF RTA_PRIORITY = linux.RTA_PRIORITY RTA_TABLE = linux.RTA_TABLE RTA_MARK = linux.RTA_MARK RTA_EXPIRES = linux.RTA_EXPIRES RTA_METRICS = linux.RTA_METRICS RTA_MULTIPATH = linux.RTA_MULTIPATH RTA_PREF = linux.RTA_PREF RTAX_ADVMSS = linux.RTAX_ADVMSS RTAX_FEATURES = linux.RTAX_FEATURES RTAX_INITCWND = linux.RTAX_INITCWND RTAX_INITRWND = linux.RTAX_INITRWND RTAX_MTU = linux.RTAX_MTU NTF_PROXY = linux.NTF_PROXY RTN_UNICAST = linux.RTN_UNICAST RT_TABLE_MAIN = linux.RT_TABLE_MAIN RTPROT_BOOT = linux.RTPROT_BOOT RTPROT_STATIC = linux.RTPROT_STATIC RT_SCOPE_UNIVERSE = linux.RT_SCOPE_UNIVERSE RT_SCOPE_HOST = linux.RT_SCOPE_HOST RT_SCOPE_LINK = linux.RT_SCOPE_LINK RTM_NEWRULE = linux.RTM_NEWRULE RTM_GETRULE = linux.RTM_GETRULE RTM_DELRULE = linux.RTM_DELRULE FRA_UNSPEC = linux.FRA_UNSPEC FRA_DST = linux.FRA_DST FRA_SRC = linux.FRA_SRC FRA_IIFNAME = linux.FRA_IIFNAME FRA_GOTO = linux.FRA_GOTO FRA_UNUSED2 = linux.FRA_UNUSED2 FRA_PRIORITY = linux.FRA_PRIORITY FRA_UNUSED3 = linux.FRA_UNUSED3 FRA_UNUSED4 = linux.FRA_UNUSED4 FRA_UNUSED5 = linux.FRA_UNUSED5 FRA_FWMARK = linux.FRA_FWMARK FRA_FLOW = linux.FRA_FLOW FRA_TUN_ID = linux.FRA_TUN_ID FRA_SUPPRESS_IFGROUP = linux.FRA_SUPPRESS_IFGROUP FRA_SUPPRESS_PREFIXLEN = linux.FRA_SUPPRESS_PREFIXLEN FRA_TABLE = linux.FRA_TABLE FRA_FWMASK = linux.FRA_FWMASK FRA_OIFNAME = linux.FRA_OIFNAME FRA_PAD = linux.FRA_PAD FRA_L3MDEV = linux.FRA_L3MDEV FRA_UID_RANGE = linux.FRA_UID_RANGE FRA_PROTOCOL = linux.FRA_PROTOCOL FRA_IP_PROTO = linux.FRA_IP_PROTO FRA_SPORT_RANGE = linux.FRA_SPORT_RANGE FRA_DPORT_RANGE = linux.FRA_DPORT_RANGE ) golang-github-jsimonetti-rtnetlink-1.4.1/internal/unix/types_other.go000066400000000000000000000115631455442221600261450ustar00rootroot00000000000000//go:build !linux // +build !linux package unix const ( AF_INET = 0x2 AF_INET6 = 0xa AF_UNSPEC = 0x0 NETLINK_ROUTE = 0x0 SizeofIfAddrmsg = 0x8 SizeofIfInfomsg = 0x10 SizeofNdMsg = 0xc SizeofRtMsg = 0xc SizeofRtNexthop = 0x8 RTM_NEWADDR = 0x14 RTM_DELADDR = 0x15 RTM_GETADDR = 0x16 RTM_NEWLINK = 0x10 RTM_DELLINK = 0x11 RTM_GETLINK = 0x12 RTM_SETLINK = 0x13 RTM_NEWROUTE = 0x18 RTM_DELROUTE = 0x19 RTM_GETROUTE = 0x1a RTM_NEWNEIGH = 0x1c RTM_DELNEIGH = 0x1d RTM_GETNEIGH = 0x1e IFA_UNSPEC = 0x0 IFA_ADDRESS = 0x1 IFA_LOCAL = 0x2 IFA_LABEL = 0x3 IFA_BROADCAST = 0x4 IFA_ANYCAST = 0x5 IFA_CACHEINFO = 0x6 IFA_MULTICAST = 0x7 IFA_FLAGS = 0x8 IFF_UP = 0x1 IFF_BROADCAST = 0x2 IFF_LOOPBACK = 0x8 IFF_POINTOPOINT = 0x10 IFF_MULTICAST = 0x1000 IFLA_UNSPEC = 0x0 IFLA_ADDRESS = 0x1 IFLA_BROADCAST = 0x2 IFLA_IFNAME = 0x3 IFLA_MTU = 0x4 IFLA_LINK = 0x5 IFLA_QDISC = 0x6 IFLA_OPERSTATE = 0x10 IFLA_STATS = 0x7 IFLA_STATS64 = 0x17 IFLA_TXQLEN = 0xd IFLA_GROUP = 0x1b IFLA_LINKINFO = 0x12 IFLA_LINKMODE = 0x11 IFLA_IFALIAS = 0x14 IFLA_MASTER = 0xa IFLA_CARRIER = 0x21 IFLA_CARRIER_CHANGES = 0x23 IFLA_CARRIER_UP_COUNT = 0x2f IFLA_CARRIER_DOWN_COUNT = 0x30 IFLA_PHYS_PORT_ID = 0x22 IFLA_PHYS_SWITCH_ID = 0x24 IFLA_PHYS_PORT_NAME = 0x26 IFLA_INFO_KIND = 0x1 IFLA_INFO_SLAVE_KIND = 0x4 IFLA_INFO_DATA = 0x2 IFLA_INFO_SLAVE_DATA = 0x5 IFLA_XDP = 0x2b IFLA_XDP_FD = 0x1 IFLA_XDP_ATTACHED = 0x2 IFLA_XDP_FLAGS = 0x3 IFLA_XDP_PROG_ID = 0x4 IFLA_XDP_EXPECTED_FD = 0x8 XDP_FLAGS_DRV_MODE = 0x4 XDP_FLAGS_SKB_MODE = 0x2 XDP_FLAGS_HW_MODE = 0x8 XDP_FLAGS_MODES = 0xe XDP_FLAGS_MASK = 0x1f XDP_FLAGS_REPLACE = 0x10 XDP_FLAGS_UPDATE_IF_NOEXIST = 0x1 LWTUNNEL_ENCAP_MPLS = 0x1 MPLS_IPTUNNEL_DST = 0x1 MPLS_IPTUNNEL_TTL = 0x2 NDA_UNSPEC = 0x0 NDA_DST = 0x1 NDA_LLADDR = 0x2 NDA_CACHEINFO = 0x3 NDA_IFINDEX = 0x8 RTA_UNSPEC = 0x0 RTA_DST = 0x1 RTA_ENCAP = 0x16 RTA_ENCAP_TYPE = 0x15 RTA_PREFSRC = 0x7 RTA_GATEWAY = 0x5 RTA_OIF = 0x4 RTA_PRIORITY = 0x6 RTA_TABLE = 0xf RTA_MARK = 0x10 RTA_EXPIRES = 0x17 RTA_METRICS = 0x8 RTA_MULTIPATH = 0x9 RTA_PREF = 0x14 RTAX_ADVMSS = 0x8 RTAX_FEATURES = 0xc RTAX_INITCWND = 0xb RTAX_INITRWND = 0xe RTAX_MTU = 0x2 NTF_PROXY = 0x8 RTN_UNICAST = 0x1 RT_TABLE_MAIN = 0xfe RTPROT_BOOT = 0x3 RTPROT_STATIC = 0x4 RT_SCOPE_UNIVERSE = 0x0 RT_SCOPE_HOST = 0xfe RT_SCOPE_LINK = 0xfd RTM_NEWRULE = 0x20 RTM_GETRULE = 0x22 RTM_DELRULE = 0x21 FRA_UNSPEC = 0x0 FRA_DST = 0x1 FRA_SRC = 0x2 FRA_IIFNAME = 0x3 FRA_GOTO = 0x4 FRA_UNUSED2 = 0x5 FRA_PRIORITY = 0x6 FRA_UNUSED3 = 0x7 FRA_UNUSED4 = 0x8 FRA_UNUSED5 = 0x9 FRA_FWMARK = 0xa FRA_FLOW = 0xb FRA_TUN_ID = 0xc FRA_SUPPRESS_IFGROUP = 0xd FRA_SUPPRESS_PREFIXLEN = 0xe FRA_TABLE = 0xf FRA_FWMASK = 0x10 FRA_OIFNAME = 0x11 FRA_PAD = 0x12 FRA_L3MDEV = 0x13 FRA_UID_RANGE = 0x14 FRA_PROTOCOL = 0x15 FRA_IP_PROTO = 0x16 FRA_SPORT_RANGE = 0x17 FRA_DPORT_RANGE = 0x18 ) golang-github-jsimonetti-rtnetlink-1.4.1/link.go000066400000000000000000000435001455442221600217320ustar00rootroot00000000000000package rtnetlink import ( "errors" "fmt" "net" "github.com/jsimonetti/rtnetlink/internal/unix" "github.com/mdlayher/netlink" ) var ( // errInvalidLinkMessage is returned when a LinkMessage is malformed. errInvalidLinkMessage = errors.New("rtnetlink LinkMessage is invalid or too short") // errInvalidLinkMessageAttr is returned when link attributes are malformed. errInvalidLinkMessageAttr = errors.New("rtnetlink LinkMessage has a wrong attribute data length") ) var _ Message = &LinkMessage{} // A LinkMessage is a route netlink link message. type LinkMessage struct { // Always set to AF_UNSPEC (0) Family uint16 // Device Type Type uint16 // Unique interface index, using a nonzero value with // NewLink will instruct the kernel to create a // device with the given index (kernel 3.7+ required) Index uint32 // Contains device flags, see netdevice(7) Flags uint32 // Change Flags, specifies which flags will be affected by the Flags field Change uint32 // Attributes List Attributes *LinkAttributes } // MarshalBinary marshals a LinkMessage into a byte slice. func (m *LinkMessage) MarshalBinary() ([]byte, error) { b := make([]byte, unix.SizeofIfInfomsg) b[0] = 0 // Family b[1] = 0 // reserved nativeEndian.PutUint16(b[2:4], m.Type) nativeEndian.PutUint32(b[4:8], m.Index) nativeEndian.PutUint32(b[8:12], m.Flags) nativeEndian.PutUint32(b[12:16], m.Change) if m.Attributes != nil { ae := netlink.NewAttributeEncoder() ae.ByteOrder = nativeEndian err := m.Attributes.encode(ae) if err != nil { return nil, err } a, err := ae.Encode() if err != nil { return nil, err } return append(b, a...), nil } return b, nil } // UnmarshalBinary unmarshals the contents of a byte slice into a LinkMessage. func (m *LinkMessage) UnmarshalBinary(b []byte) error { l := len(b) if l < unix.SizeofIfInfomsg { return errInvalidLinkMessage } m.Family = nativeEndian.Uint16(b[0:2]) m.Type = nativeEndian.Uint16(b[2:4]) m.Index = nativeEndian.Uint32(b[4:8]) m.Flags = nativeEndian.Uint32(b[8:12]) m.Change = nativeEndian.Uint32(b[12:16]) if l > unix.SizeofIfInfomsg { m.Attributes = &LinkAttributes{} ad, err := netlink.NewAttributeDecoder(b[16:]) if err != nil { return err } ad.ByteOrder = nativeEndian err = m.Attributes.decode(ad) if err != nil { return err } } return nil } // rtMessage is an empty method to sattisfy the Message interface. func (*LinkMessage) rtMessage() {} // LinkService is used to retrieve rtnetlink family information. type LinkService struct { c *Conn } // execute executes the request and returns the messages as a LinkMessage slice func (l *LinkService) execute(m Message, family uint16, flags netlink.HeaderFlags) ([]LinkMessage, error) { msgs, err := l.c.Execute(m, family, flags) links := make([]LinkMessage, len(msgs)) for i := range msgs { links[i] = *msgs[i].(*LinkMessage) } return links, err } // New creates a new interface using the LinkMessage information. func (l *LinkService) New(req *LinkMessage) error { flags := netlink.Request | netlink.Create | netlink.Acknowledge | netlink.Excl _, err := l.execute(req, unix.RTM_NEWLINK, flags) return err } // Delete removes an interface by index. func (l *LinkService) Delete(index uint32) error { req := &LinkMessage{ Index: index, } flags := netlink.Request | netlink.Acknowledge _, err := l.c.Execute(req, unix.RTM_DELLINK, flags) return err } // Get retrieves interface information by index. func (l *LinkService) Get(index uint32) (LinkMessage, error) { req := &LinkMessage{ Index: index, } flags := netlink.Request | netlink.DumpFiltered links, err := l.execute(req, unix.RTM_GETLINK, flags) if len(links) != 1 { return LinkMessage{}, fmt.Errorf("too many/little matches, expected 1, actual %d", len(links)) } return links[0], err } // Set sets interface attributes according to the LinkMessage information. // // ref: https://lwn.net/Articles/236919/ // We explicitly use RTM_NEWLINK to set link attributes instead of // RTM_SETLINK because: // - using RTM_SETLINK is actually an old rtnetlink API, not supporting most // attributes common today // - using RTM_NEWLINK is the preferred way to create AND update links // - RTM_NEWLINK is backward compatible to RTM_SETLINK func (l *LinkService) Set(req *LinkMessage) error { flags := netlink.Request | netlink.Acknowledge _, err := l.c.Execute(req, unix.RTM_NEWLINK, flags) return err } func (l *LinkService) list(kind string) ([]LinkMessage, error) { req := &LinkMessage{} if kind != "" { req.Attributes = &LinkAttributes{ Info: &LinkInfo{Kind: kind}, } } flags := netlink.Request | netlink.Dump return l.execute(req, unix.RTM_GETLINK, flags) } // ListByKind retrieves all interfaces of a specific kind. func (l *LinkService) ListByKind(kind string) ([]LinkMessage, error) { return l.list(kind) } // List retrieves all interfaces. func (l *LinkService) List() ([]LinkMessage, error) { return l.list("") } // LinkAttributes contains all attributes for an interface. type LinkAttributes struct { Address net.HardwareAddr // Interface L2 address Alias *string // Interface alias name Broadcast net.HardwareAddr // L2 broadcast address Carrier *uint8 // Current physical link state of the interface. CarrierChanges *uint32 // Number of times the link has seen a change from UP to DOWN and vice versa CarrierUpCount *uint32 // Number of times the link has been up CarrierDownCount *uint32 // Number of times the link has been down Index *uint32 // System-wide interface unique index identifier Info *LinkInfo // Detailed Interface Information LinkMode *uint8 // Interface link mode MTU uint32 // MTU of the device Name string // Device name NetDevGroup *uint32 // Interface network device group OperationalState OperationalState // Interface operation state PhysPortID *string // Interface unique physical port identifier within the NIC PhysPortName *string // Interface physical port name within the NIC PhysSwitchID *string // Unique physical switch identifier of a switch this port belongs to QueueDisc string // Queueing discipline Master *uint32 // Master device index (0 value un-enslaves) Stats *LinkStats // Interface Statistics Stats64 *LinkStats64 // Interface Statistics (64 bits version) TxQueueLen *uint32 // Interface transmit queue len in number of packets Type uint32 // Link type XDP *LinkXDP // Express Data Patch Information } // OperationalState represents an interface's operational state. type OperationalState uint8 // Constants that represent operational state of an interface // // Adapted from https://elixir.bootlin.com/linux/v4.19.2/source/include/uapi/linux/if.h#L166 const ( OperStateUnknown OperationalState = iota // status could not be determined OperStateNotPresent // down, due to some missing component (typically hardware) OperStateDown // down, either administratively or due to a fault OperStateLowerLayerDown // down, due to lower-layer interfaces OperStateTesting // operationally down, in some test mode OperStateDormant // down, waiting for some external event OperStateUp // interface is in a state to send and receive packets ) // unmarshalBinary unmarshals the contents of a byte slice into a LinkMessage. func (a *LinkAttributes) decode(ad *netlink.AttributeDecoder) error { for ad.Next() { switch ad.Type() { case unix.IFLA_UNSPEC: // unused attribute case unix.IFLA_ADDRESS: l := len(ad.Bytes()) if l < 4 || l > 32 { return errInvalidLinkMessageAttr } a.Address = ad.Bytes() case unix.IFLA_IFALIAS: v := ad.String() a.Alias = &v case unix.IFLA_BROADCAST: l := len(ad.Bytes()) if l < 4 || l > 32 { return errInvalidLinkMessageAttr } a.Broadcast = ad.Bytes() case unix.IFLA_CARRIER: v := ad.Uint8() a.Carrier = &v case unix.IFLA_CARRIER_CHANGES: v := ad.Uint32() a.CarrierChanges = &v case unix.IFLA_CARRIER_UP_COUNT: v := ad.Uint32() a.CarrierUpCount = &v case unix.IFLA_CARRIER_DOWN_COUNT: v := ad.Uint32() a.CarrierDownCount = &v case unix.IFLA_GROUP: v := ad.Uint32() a.NetDevGroup = &v case unix.IFLA_MTU: a.MTU = ad.Uint32() case unix.IFLA_IFNAME: a.Name = ad.String() case unix.IFLA_LINK: a.Type = ad.Uint32() case unix.IFLA_LINKINFO: a.Info = &LinkInfo{} ad.Nested(a.Info.decode) case unix.IFLA_LINKMODE: v := ad.Uint8() a.LinkMode = &v case unix.IFLA_MASTER: v := ad.Uint32() a.Master = &v case unix.IFLA_OPERSTATE: a.OperationalState = OperationalState(ad.Uint8()) case unix.IFLA_PHYS_PORT_ID: v := ad.String() a.PhysPortID = &v case unix.IFLA_PHYS_SWITCH_ID: v := ad.String() a.PhysSwitchID = &v case unix.IFLA_PHYS_PORT_NAME: v := ad.String() a.PhysPortName = &v case unix.IFLA_QDISC: a.QueueDisc = ad.String() case unix.IFLA_STATS: a.Stats = &LinkStats{} err := a.Stats.unmarshalBinary(ad.Bytes()) if err != nil { return err } case unix.IFLA_STATS64: a.Stats64 = &LinkStats64{} err := a.Stats64.unmarshalBinary(ad.Bytes()) if err != nil { return err } case unix.IFLA_TXQLEN: v := ad.Uint32() a.TxQueueLen = &v case unix.IFLA_XDP: a.XDP = &LinkXDP{} ad.Nested(a.XDP.decode) } } return nil } // MarshalBinary marshals a LinkAttributes into a byte slice. func (a *LinkAttributes) encode(ae *netlink.AttributeEncoder) error { ae.Uint16(unix.IFLA_UNSPEC, 0) ae.String(unix.IFLA_IFNAME, a.Name) ae.Uint32(unix.IFLA_LINK, a.Type) ae.String(unix.IFLA_QDISC, a.QueueDisc) if a.MTU != 0 { ae.Uint32(unix.IFLA_MTU, a.MTU) } if len(a.Address) != 0 { ae.Bytes(unix.IFLA_ADDRESS, a.Address) } if len(a.Broadcast) != 0 { ae.Bytes(unix.IFLA_BROADCAST, a.Broadcast) } if a.OperationalState != OperStateUnknown { ae.Uint8(unix.IFLA_OPERSTATE, uint8(a.OperationalState)) } if a.Info != nil { nae := netlink.NewAttributeEncoder() nae.ByteOrder = ae.ByteOrder err := a.Info.encode(nae) if err != nil { return err } b, err := nae.Encode() if err != nil { return err } ae.Bytes(unix.IFLA_LINKINFO, b) } if a.XDP != nil { nae := netlink.NewAttributeEncoder() nae.ByteOrder = ae.ByteOrder err := a.XDP.encode(nae) if err != nil { return err } b, err := nae.Encode() if err != nil { return err } ae.Bytes(unix.IFLA_XDP, b) } if a.Master != nil { ae.Uint32(unix.IFLA_MASTER, *a.Master) } return nil } // LinkStats contains packet statistics type LinkStats struct { RXPackets uint32 // total packets received TXPackets uint32 // total packets transmitted RXBytes uint32 // total bytes received TXBytes uint32 // total bytes transmitted RXErrors uint32 // bad packets received TXErrors uint32 // packet transmit problems RXDropped uint32 // no space in linux buffers TXDropped uint32 // no space available in linux Multicast uint32 // multicast packets received Collisions uint32 // detailed rx_errors: RXLengthErrors uint32 RXOverErrors uint32 // receiver ring buff overflow RXCRCErrors uint32 // recved pkt with crc error RXFrameErrors uint32 // recv'd frame alignment error RXFIFOErrors uint32 // recv'r fifo overrun RXMissedErrors uint32 // receiver missed packet // detailed tx_errors TXAbortedErrors uint32 TXCarrierErrors uint32 TXFIFOErrors uint32 TXHeartbeatErrors uint32 TXWindowErrors uint32 // for cslip etc RXCompressed uint32 TXCompressed uint32 RXNoHandler uint32 // dropped, no handler found } // unmarshalBinary unmarshals the contents of a byte slice into a LinkMessage. func (a *LinkStats) unmarshalBinary(b []byte) error { l := len(b) if l != 92 && l != 96 { return fmt.Errorf("incorrect LinkMessage size, want: 92 or 96, got: %d", len(b)) } a.RXPackets = nativeEndian.Uint32(b[0:4]) a.TXPackets = nativeEndian.Uint32(b[4:8]) a.RXBytes = nativeEndian.Uint32(b[8:12]) a.TXBytes = nativeEndian.Uint32(b[12:16]) a.RXErrors = nativeEndian.Uint32(b[16:20]) a.TXErrors = nativeEndian.Uint32(b[20:24]) a.RXDropped = nativeEndian.Uint32(b[24:28]) a.TXDropped = nativeEndian.Uint32(b[28:32]) a.Multicast = nativeEndian.Uint32(b[32:36]) a.Collisions = nativeEndian.Uint32(b[36:40]) a.RXLengthErrors = nativeEndian.Uint32(b[40:44]) a.RXOverErrors = nativeEndian.Uint32(b[44:48]) a.RXCRCErrors = nativeEndian.Uint32(b[48:52]) a.RXFrameErrors = nativeEndian.Uint32(b[52:56]) a.RXFIFOErrors = nativeEndian.Uint32(b[56:60]) a.RXMissedErrors = nativeEndian.Uint32(b[60:64]) a.TXAbortedErrors = nativeEndian.Uint32(b[64:68]) a.TXCarrierErrors = nativeEndian.Uint32(b[68:72]) a.TXFIFOErrors = nativeEndian.Uint32(b[72:76]) a.TXHeartbeatErrors = nativeEndian.Uint32(b[76:80]) a.TXWindowErrors = nativeEndian.Uint32(b[80:84]) a.RXCompressed = nativeEndian.Uint32(b[84:88]) a.TXCompressed = nativeEndian.Uint32(b[88:92]) if l == 96 { // kernel 4.6+ a.RXNoHandler = nativeEndian.Uint32(b[92:96]) } return nil } // LinkStats64 contains packet statistics type LinkStats64 struct { RXPackets uint64 // total packets received TXPackets uint64 // total packets transmitted RXBytes uint64 // total bytes received TXBytes uint64 // total bytes transmitted RXErrors uint64 // bad packets received TXErrors uint64 // packet transmit problems RXDropped uint64 // no space in linux buffers TXDropped uint64 // no space available in linux Multicast uint64 // multicast packets received Collisions uint64 // detailed rx_errors: RXLengthErrors uint64 RXOverErrors uint64 // receiver ring buff overflow RXCRCErrors uint64 // recved pkt with crc error RXFrameErrors uint64 // recv'd frame alignment error RXFIFOErrors uint64 // recv'r fifo overrun RXMissedErrors uint64 // receiver missed packet // detailed tx_errors TXAbortedErrors uint64 TXCarrierErrors uint64 TXFIFOErrors uint64 TXHeartbeatErrors uint64 TXWindowErrors uint64 // for cslip etc RXCompressed uint64 TXCompressed uint64 RXNoHandler uint64 // dropped, no handler found RXOtherhostDropped uint64 // Number of packets dropped due to mismatch in destination MAC address. } // unmarshalBinary unmarshals the contents of a byte slice into a LinkMessage. func (a *LinkStats64) unmarshalBinary(b []byte) error { l := len(b) if l != 184 && l != 192 && l != 200 { return fmt.Errorf("incorrect size, want: 184 or 192 or 200") } a.RXPackets = nativeEndian.Uint64(b[0:8]) a.TXPackets = nativeEndian.Uint64(b[8:16]) a.RXBytes = nativeEndian.Uint64(b[16:24]) a.TXBytes = nativeEndian.Uint64(b[24:32]) a.RXErrors = nativeEndian.Uint64(b[32:40]) a.TXErrors = nativeEndian.Uint64(b[40:48]) a.RXDropped = nativeEndian.Uint64(b[48:56]) a.TXDropped = nativeEndian.Uint64(b[56:64]) a.Multicast = nativeEndian.Uint64(b[64:72]) a.Collisions = nativeEndian.Uint64(b[72:80]) a.RXLengthErrors = nativeEndian.Uint64(b[80:88]) a.RXOverErrors = nativeEndian.Uint64(b[88:96]) a.RXCRCErrors = nativeEndian.Uint64(b[96:104]) a.RXFrameErrors = nativeEndian.Uint64(b[104:112]) a.RXFIFOErrors = nativeEndian.Uint64(b[112:120]) a.RXMissedErrors = nativeEndian.Uint64(b[120:128]) a.TXAbortedErrors = nativeEndian.Uint64(b[128:136]) a.TXCarrierErrors = nativeEndian.Uint64(b[136:144]) a.TXFIFOErrors = nativeEndian.Uint64(b[144:152]) a.TXHeartbeatErrors = nativeEndian.Uint64(b[152:160]) a.TXWindowErrors = nativeEndian.Uint64(b[160:168]) a.RXCompressed = nativeEndian.Uint64(b[168:176]) a.TXCompressed = nativeEndian.Uint64(b[176:184]) if l > 191 { // kernel 4.6+ a.RXNoHandler = nativeEndian.Uint64(b[184:192]) } if l > 199 { // kernel 5.19+ a.RXOtherhostDropped = nativeEndian.Uint64(b[192:200]) } return nil } // LinkInfo contains data for specific network types type LinkInfo struct { Kind string // Driver name Data []byte // Driver specific configuration stored as nested Netlink messages SlaveKind string // Slave driver name SlaveData []byte // Slave driver specific configuration } func (i *LinkInfo) decode(ad *netlink.AttributeDecoder) error { for ad.Next() { switch ad.Type() { case unix.IFLA_INFO_KIND: i.Kind = ad.String() case unix.IFLA_INFO_SLAVE_KIND: i.SlaveKind = ad.String() case unix.IFLA_INFO_DATA: i.Data = ad.Bytes() case unix.IFLA_INFO_SLAVE_DATA: i.SlaveData = ad.Bytes() } } return nil } func (i *LinkInfo) encode(ae *netlink.AttributeEncoder) error { ae.String(unix.IFLA_INFO_KIND, i.Kind) ae.Bytes(unix.IFLA_INFO_DATA, i.Data) if len(i.SlaveData) > 0 { ae.String(unix.IFLA_INFO_SLAVE_KIND, i.SlaveKind) ae.Bytes(unix.IFLA_INFO_SLAVE_DATA, i.SlaveData) } return nil } // LinkXDP holds Express Data Path specific information type LinkXDP struct { FD int32 ExpectedFD int32 Attached uint8 Flags uint32 ProgID uint32 } func (xdp *LinkXDP) decode(ad *netlink.AttributeDecoder) error { for ad.Next() { switch ad.Type() { case unix.IFLA_XDP_FD: xdp.FD = ad.Int32() case unix.IFLA_XDP_EXPECTED_FD: xdp.ExpectedFD = ad.Int32() case unix.IFLA_XDP_ATTACHED: xdp.Attached = ad.Uint8() case unix.IFLA_XDP_FLAGS: xdp.Flags = ad.Uint32() case unix.IFLA_XDP_PROG_ID: xdp.ProgID = ad.Uint32() } } return nil } func (xdp *LinkXDP) encode(ae *netlink.AttributeEncoder) error { ae.Int32(unix.IFLA_XDP_FD, xdp.FD) ae.Int32(unix.IFLA_XDP_EXPECTED_FD, xdp.ExpectedFD) ae.Uint32(unix.IFLA_XDP_FLAGS, xdp.Flags) // XDP_ATtACHED and XDP_PROG_ID are things that only can return from the kernel, // not be send, so we don't encode them. // source: https://elixir.bootlin.com/linux/v5.10.15/source/net/core/rtnetlink.c#L2894 return nil } golang-github-jsimonetti-rtnetlink-1.4.1/link_live_test.go000066400000000000000000000222461455442221600240140ustar00rootroot00000000000000//go:build integration // +build integration package rtnetlink import ( "bytes" "fmt" "testing" "github.com/cilium/ebpf" "github.com/cilium/ebpf/asm" "golang.org/x/sys/unix" ) func getKernelVersion() (kernel, major, minor int, err error) { var uname unix.Utsname if err := unix.Uname(&uname); err != nil { return 0, 0, 0, err } end := bytes.IndexByte(uname.Release[:], 0) versionStr := uname.Release[:end] if count, _ := fmt.Sscanf(string(versionStr), "%d.%d.%d", &kernel, &major, &minor); count < 2 { err = fmt.Errorf("failed to parse kernel version from: %q", string(versionStr)) } return } // kernelMinReq checks if the runtime kernel is sufficient // for the test func kernelMinReq(t *testing.T, kernel, major int) { k, m, _, err := getKernelVersion() if err != nil { t.Fatalf("failed to get host kernel version: %v", err) } if k < kernel || k == kernel && m < major { t.Skipf("host kernel (%d.%d) does not meet test's minimum required version: (%d.%d)", k, m, kernel, major) } } // SetupDummyInterface create a dummy interface for testing and returns its // properties func SetupDummyInterface(conn *Conn, name string) (*LinkMessage, error) { // construct dummy interface to test XDP program against if err := conn.Link.New(&LinkMessage{ Family: unix.AF_UNSPEC, Index: 1001, Flags: unix.IFF_UP, Attributes: &LinkAttributes{ Name: name, Info: &LinkInfo{Kind: "dummy"}, }, }); err != nil { return nil, err } // get info for the dummy interface interf, err := conn.Link.Get(1001) if err != nil { conn.Link.Delete(interf.Index) return nil, err } return &interf, err } func GetBPFPrograms() (int32, int32, error) { // load a BPF test program. If it fails error out of the tests // and clean up dummy interface. The program loads XDP_PASS // into the return value register. bpfProgram := &ebpf.ProgramSpec{ Type: ebpf.XDP, Instructions: asm.Instructions{ asm.LoadImm(asm.R0, int64(2), asm.DWord), asm.Return(), }, License: "MIT", } prog1, err := ebpf.NewProgram(bpfProgram) if err != nil { return 0, 0, err } prog2, err := ebpf.NewProgram(bpfProgram) if err != nil { return 0, 0, err } // Use the file descriptor of the programs return int32(prog1.FD()), int32(prog2.FD()), nil } // SendXDPMsg sends a XDP netlink msg with the specified LinkXDP properties func SendXPDMsg(conn *Conn, ifIndex uint32, xdp *LinkXDP) error { message := LinkMessage{ Family: unix.AF_UNSPEC, Index: ifIndex, Attributes: &LinkAttributes{ XDP: xdp, }, } return conn.Link.Set(&message) } // GetXDPProperties returns the XDP attach, XDP prog ID and errors when the // interface could not be fetched func GetXDPProperties(conn *Conn, ifIndex uint32) (uint8, uint32, error) { interf, err := conn.Link.Get(ifIndex) if err != nil { return 0, 0, err } return interf.Attributes.XDP.Attached, interf.Attributes.XDP.ProgID, nil } func TestLinkXDPAttach(t *testing.T) { // BPF loading requires a high RLIMIT_MEMLOCK. n := uint64(1024 * 1024 * 10) err := unix.Setrlimit(unix.RLIMIT_MEMLOCK, &unix.Rlimit{Cur: n, Max: n}) if err != nil { t.Fatalf("failed to increase RLIMIT_MEMLOCK: %v", err) } // establish a netlink connections conn, err := Dial(nil) if err != nil { t.Fatalf("failed to establish netlink socket: %v", err) } defer conn.Close() // setup dummy interface for the test interf, err := SetupDummyInterface(conn, "dummyXDPAttach") if err != nil { t.Fatalf("failed to setup dummy interface: %v", err) } defer conn.Link.Delete(interf.Index) // get a BPF program progFD1, progFD2, err := GetBPFPrograms() if err != nil { t.Fatalf("failed to load bpf programs: %v", err) } tests := []struct { name string xdp *LinkXDP }{ { name: "with FD, no expected FD", xdp: &LinkXDP{ FD: progFD1, Flags: unix.XDP_FLAGS_SKB_MODE, }, }, { name: "with FD, expected FD == FD", xdp: &LinkXDP{ FD: progFD1, ExpectedFD: progFD1, Flags: unix.XDP_FLAGS_SKB_MODE, }, }, { name: "with FD, expected FD != FD", xdp: &LinkXDP{ FD: progFD1, ExpectedFD: progFD2, Flags: unix.XDP_FLAGS_SKB_MODE, }, }, { name: "with FD, expected FD < 0", xdp: &LinkXDP{ FD: progFD1, ExpectedFD: -1, Flags: unix.XDP_FLAGS_SKB_MODE, }, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { // attach the BPF program to the link err = SendXPDMsg(conn, interf.Index, tt.xdp) if err != nil { t.Fatalf("failed to attach XDP program to link: %v", err) } // validate the XDP properites of the link attached, progID, err := GetXDPProperties(conn, interf.Index) if err != nil { t.Fatalf("failed to get XDP properties from the link: %v", err) } if attached != unix.XDP_FLAGS_SKB_MODE { t.Fatalf("XDP attached state does not match. Got: %d, wanted: %d", attached, unix.XDP_FLAGS_SKB_MODE) } if attached == unix.XDP_FLAGS_SKB_MODE && progID == 0 { t.Fatalf("XDP program should be attached but program ID is 0") } }) } } func TestLinkXDPClear(t *testing.T) { // BPF loading requires a high RLIMIT_MEMLOCK. n := uint64(1024 * 1024 * 10) err := unix.Setrlimit(unix.RLIMIT_MEMLOCK, &unix.Rlimit{Cur: n, Max: n}) if err != nil { t.Fatalf("failed to increase RLIMIT_MEMLOCK: %v", err) } // establish a netlink connections conn, err := Dial(nil) if err != nil { t.Fatalf("failed to establish netlink socket: %v", err) } defer conn.Close() // setup dummy interface for the test interf, err := SetupDummyInterface(conn, "dummyXDPClear") if err != nil { t.Fatalf("failed to setup dummy interface: %v", err) } defer conn.Link.Delete(interf.Index) // get a BPF program progFD1, _, err := GetBPFPrograms() if err != nil { t.Fatalf("failed to load bpf programs: %v", err) } // attach the BPF program to the link err = SendXPDMsg(conn, interf.Index, &LinkXDP{ FD: progFD1, Flags: unix.XDP_FLAGS_SKB_MODE, }) if err != nil { t.Fatalf("failed to attach XDP program to link: %v", err) } // clear the BPF program from the link err = SendXPDMsg(conn, interf.Index, &LinkXDP{ FD: -1, Flags: unix.XDP_FLAGS_SKB_MODE, }) if err != nil { t.Fatalf("failed to clear XDP program to link: %v", err) } attached, progID, err := GetXDPProperties(conn, interf.Index) if err != nil { t.Fatalf("failed to get XDP program ID 1 from interface: %v", err) } if progID != 0 { t.Fatalf("there is still a program loaded, while we cleared the link") } if attached != 0 { t.Fatalf( "XDP attached state does not match. Got: %d, wanted: %d\nThere should be no program loaded", attached, 0, ) } } func TestLinkXDPReplace(t *testing.T) { // As of kernel version 5.7, the use of EXPECTED_FD and XDP_FLAGS_REPLACE // is supported. We check here if the test host kernel fills this // requirement. If the requirement is not met, we skip this test and // output a notice. Running the code on a kernel version lower then 5.7 // will throw an "invalid argument" error. // source kernel 5.6: // https://elixir.bootlin.com/linux/v5.6/source/net/core/dev.c#L8662 // source kernel 5.7: // https://elixir.bootlin.com/linux/v5.7/source/net/core/dev.c#L8674 kernelMinReq(t, 5, 7) // BPF loading requires a high RLIMIT_MEMLOCK. n := uint64(1024 * 1024 * 10) err := unix.Setrlimit(unix.RLIMIT_MEMLOCK, &unix.Rlimit{Cur: n, Max: n}) if err != nil { t.Fatalf("failed to increase RLIMIT_MEMLOCK: %v", err) } // establish a netlink connections conn, err := Dial(nil) if err != nil { t.Fatalf("failed to establish netlink socket: %v", err) } defer conn.Close() // setup dummy interface for the test interf, err := SetupDummyInterface(conn, "dummyXDPReplace") if err != nil { t.Fatalf("failed to setup dummy interface: %v", err) } defer conn.Link.Delete(interf.Index) // get BPF programs progFD1, progFD2, err := GetBPFPrograms() if err != nil { t.Fatalf("failed to load bpf programs: %v", err) } err = SendXPDMsg(conn, interf.Index, &LinkXDP{ FD: progFD1, Flags: unix.XDP_FLAGS_SKB_MODE, }) if err != nil { t.Fatalf("failed to attach XDP program 1 to link: %v", err) } _, progID1, err := GetXDPProperties(conn, interf.Index) if err != nil { t.Fatalf("failed to get XDP program ID 1 from interface: %v", err) } err = SendXPDMsg(conn, interf.Index, &LinkXDP{ FD: progFD2, ExpectedFD: progFD2, Flags: unix.XDP_FLAGS_SKB_MODE | unix.XDP_FLAGS_REPLACE, }) if err == nil { t.Fatalf("replaced XDP program while expected FD did not match: %v", err) } _, progID2, err := GetXDPProperties(conn, interf.Index) if err != nil { t.Fatalf("failed to get XDP program ID 2 from interface: %v", err) } if progID2 != progID1 { t.Fatal("XDP prog ID does not match previous program ID, which it should") } err = SendXPDMsg(conn, interf.Index, &LinkXDP{ FD: progFD2, ExpectedFD: progFD1, Flags: unix.XDP_FLAGS_SKB_MODE | unix.XDP_FLAGS_REPLACE, }) if err != nil { t.Fatalf("could not replace XDP program: %v", err) } _, progID2, err = GetXDPProperties(conn, interf.Index) if err != nil { t.Fatalf("failed to get XDP program ID 2 from interface: %v", err) } if progID2 == progID1 { t.Fatal("XDP prog ID does match previous program ID, which it shouldn't") } } golang-github-jsimonetti-rtnetlink-1.4.1/link_test.go000066400000000000000000000560041455442221600227740ustar00rootroot00000000000000package rtnetlink import ( "bytes" "fmt" "reflect" "testing" "golang.org/x/sys/unix" ) func TestLinkMessageMarshalBinary(t *testing.T) { skipBigEndian(t) tests := []struct { name string m Message b []byte err error }{ { name: "empty", m: &LinkMessage{}, b: []byte{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, }, }, { name: "no attributes", m: &LinkMessage{ Family: 0, Type: 1, Index: 2, Flags: 0, Change: 0, }, b: []byte{ 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, }, }, { name: "no attributes with flags", m: &LinkMessage{ Family: 0, Type: 1, Index: 2, Flags: unix.IFF_UP, Change: 0, }, b: []byte{ 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, }, }, { name: "attributes", m: &LinkMessage{ Attributes: &LinkAttributes{ Address: []byte{0x40, 0x41, 0x42, 0x43, 0x44, 0x45}, Broadcast: []byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff}, Name: "lo", }, }, b: []byte{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x03, 0x00, 0x6c, 0x6f, 0x00, 0x00, 0x08, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x01, 0x00, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x00, 0x00, 0x0a, 0x00, 0x02, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, }, }, { name: "attributes ipip", m: &LinkMessage{ Attributes: &LinkAttributes{ Address: []byte{10, 0, 0, 1}, Broadcast: []byte{255, 255, 255, 255}, Name: "ipip", }, }, b: []byte{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x03, 0x00, 0x69, 0x70, 0x69, 0x70, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x01, 0x00, 0x0a, 0x00, 0x00, 0x01, 0x08, 0x00, 0x02, 0x00, 0xff, 0xff, 0xff, 0xff, }, }, { name: "info", m: &LinkMessage{ Attributes: &LinkAttributes{ Address: []byte{0, 0, 0, 0, 0, 0}, Broadcast: []byte{0, 0, 0, 0, 0, 0}, Name: "lo", Info: &LinkInfo{ Kind: "data", Data: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9}, SlaveKind: "foo", SlaveData: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9}, }, }, }, b: []byte{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x03, 0x00, 0x6c, 0x6f, 0x00, 0x00, 0x08, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x12, 0x00, 0x09, 0x00, 0x01, 0x00, 0x64, 0x61, 0x74, 0x61, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x02, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x00, 0x00, 0x00, 0x08, 0x00, 0x04, 0x00, 0x66, 0x6f, 0x6f, 0x00, 0x0d, 0x00, 0x05, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x00, 0x00, 0x00, }, }, { name: "operational state", m: &LinkMessage{ Attributes: &LinkAttributes{ Address: []byte{10, 0, 0, 1}, Broadcast: []byte{255, 255, 255, 255}, Name: "ipip", OperationalState: OperStateUp, }, }, b: []byte{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x03, 0x00, 0x69, 0x70, 0x69, 0x70, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x01, 0x00, 0x0a, 0x00, 0x00, 0x01, 0x08, 0x00, 0x02, 0x00, 0xff, 0xff, 0xff, 0xff, 0x05, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, }, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { b, err := tt.m.MarshalBinary() if want, got := tt.err, err; want != got { t.Fatalf("unexpected error:\n- want: %v\n- got: %v", want, got) } if err != nil { return } if want, got := tt.b, b; !bytes.Equal(want, got) { t.Fatalf("unexpected Message bytes:\n- want: [%# x]\n- got: [%# x]", want, got) } }) } } func TestLinkMessageUnmarshalBinary(t *testing.T) { skipBigEndian(t) var val_uint8_1 uint8 = 1 var val_uint32_1 uint32 = 1 var val_string_3c string = "rtl" tests := []struct { name string b []byte m Message err error }{ { name: "empty", err: errInvalidLinkMessage, }, { name: "short", b: make([]byte, 3), err: errInvalidLinkMessage, }, { name: "invalid attr", b: []byte{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x01, 0x00, 0x04, 0x00, 0x02, 0x00, 0x05, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, }, err: errInvalidLinkMessageAttr, }, { name: "zero value", b: []byte{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, }, m: &LinkMessage{ Attributes: &LinkAttributes{ Address: []byte{0, 0, 0, 0, 0, 0}, Broadcast: []byte{0, 0, 0, 0, 0, 0}, }, }, }, { name: "no data", b: []byte{ 0x00, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, }, m: &LinkMessage{ Family: 0, Type: 1, Index: 2, Flags: 0, Change: 0, Attributes: &LinkAttributes{ Address: []byte{0, 0, 0, 0, 0, 0}, Broadcast: []byte{0, 0, 0, 0, 0, 0}, }, }, }, { name: "data", b: []byte{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x03, 0x00, 0x6c, 0x6f, 0x00, 0x00, 0x08, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, }, m: &LinkMessage{ Attributes: &LinkAttributes{ Address: []byte{0, 0, 0, 0, 0, 0}, Broadcast: []byte{0, 0, 0, 0, 0, 0}, Name: "lo", }, }, }, { name: "attributes", b: []byte{ // Kernel structure 16 bytes // struct ifinfomsg { // unsigned char ifi_family; // unsigned char __ifi_pad; // unsigned short ifi_type; /* ARPHRD_* */ // int ifi_index; /* Link index */ // unsigned ifi_flags; /* IFF_* flags */ // unsigned ifi_change; /* IFF_* change mask */ // }; 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Kernel structure 4 bytes header + data // struct nlattr { // __u16 nla_len; // __u16 nla_type; // }; 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // IFLA_UNSPEC 0x08, 0x00, 0x01, 0x00, 0x0a, 0x00, 0x00, 0x01, // IFLA_ADDRESS 0x08, 0x00, 0x02, 0x00, 0xff, 0xff, 0xff, 0xff, // IFLA_BROADCAST 0x08, 0x00, 0x03, 0x00, 0x72, 0x74, 0x6c, 0x00, // IFLA_IFNAME 0x08, 0x00, 0x14, 0x00, 0x72, 0x74, 0x6c, 0x00, // IFLA_IFALIAS 0x05, 0x00, 0x21, 0x00, 0x01, 0x00, 0x00, 0x00, // IFLA_CARRIER 0x08, 0x00, 0x23, 0x00, 0x01, 0x00, 0x00, 0x00, // IFLA_CARRIER_CHANGES 0x08, 0x00, 0x2f, 0x00, 0x01, 0x00, 0x00, 0x00, // IFLA_CARRIER_UP_COUNT 0x08, 0x00, 0x30, 0x00, 0x01, 0x00, 0x00, 0x00, // IFLA_CARRIER_DOWN_COUNT 0x08, 0x00, 0x1b, 0x00, 0x01, 0x00, 0x00, 0x00, // IFLA_GROUP 0x08, 0x00, 0x05, 0x00, 0x01, 0x00, 0x00, 0x00, // IFLA_LINK 0x05, 0x00, 0x11, 0x00, 0x01, 0x00, 0x00, 0x00, // IFLA_LINKMODE 0x08, 0x00, 0x0a, 0x00, 0x01, 0x00, 0x00, 0x00, // IFLA_MASTER 0x08, 0x00, 0x04, 0x00, 0x01, 0x00, 0x00, 0x00, // IFLA_MTU 0x05, 0x00, 0x10, 0x00, 0x06, 0x00, 0x00, 0x00, // IFLA_OPERSTATE 0x08, 0x00, 0x22, 0x00, 0x72, 0x74, 0x6c, 0x00, // IFLA_PHYS_PORT_ID 0x08, 0x00, 0x24, 0x00, 0x72, 0x74, 0x6c, 0x00, // IFLA_PHYS_SWITCH_ID 0x08, 0x00, 0x26, 0x00, 0x72, 0x74, 0x6c, 0x00, // IFLA_PHYS_PORT_NAME 0x08, 0x00, 0x06, 0x00, 0x72, 0x74, 0x6c, 0x00, // IFLA_QDISC 0x08, 0x00, 0x0d, 0x00, 0x01, 0x00, 0x00, 0x00, // IFLA_TXQLEN }, m: &LinkMessage{ Attributes: &LinkAttributes{ Alias: &val_string_3c, Address: []byte{10, 0, 0, 1}, Broadcast: []byte{255, 255, 255, 255}, Name: val_string_3c, Carrier: &val_uint8_1, CarrierChanges: &val_uint32_1, CarrierUpCount: &val_uint32_1, CarrierDownCount: &val_uint32_1, Master: &val_uint32_1, LinkMode: &val_uint8_1, MTU: 1, NetDevGroup: &val_uint32_1, OperationalState: OperStateUp, // uint8 (6) PhysPortID: &val_string_3c, PhysSwitchID: &val_string_3c, PhysPortName: &val_string_3c, QueueDisc: val_string_3c, TxQueueLen: &val_uint32_1, Type: 1, }, }, }, { name: "info", b: []byte{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x03, 0x00, 0x6c, 0x6f, 0x00, 0x00, 0x08, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x12, 0x00, 0x09, 0x00, 0x01, 0x00, 0x64, 0x61, 0x74, 0x61, 0x00, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x02, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x00, 0x00, 0x00, 0x08, 0x00, 0x04, 0x00, 0x66, 0x6f, 0x6f, 0x00, 0x0d, 0x00, 0x05, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x00, 0x00, 0x00, }, m: &LinkMessage{ Attributes: &LinkAttributes{ Address: []byte{0, 0, 0, 0, 0, 0}, Broadcast: []byte{0, 0, 0, 0, 0, 0}, Name: "lo", Info: &LinkInfo{ Kind: "data", Data: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9}, SlaveKind: "foo", SlaveData: []byte{1, 2, 3, 4, 5, 6, 7, 8, 9}, }, }, }, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { m := &LinkMessage{} err := (m).UnmarshalBinary(tt.b) if want, got := tt.err, err; want != got { t.Fatalf("unexpected error:\n- want: %v\n- got: %v", want, got) } if err != nil { return } if want, got := tt.m, m; !reflect.DeepEqual(want, got) { t.Fatalf("unexpected Message:\n- want: %#v\n- got: %#v", want, got) } }) } } func TestLinkStatsUnmarshalBinary(t *testing.T) { skipBigEndian(t) tests := []struct { name string b []byte m *LinkStats err error }{ { name: "empty", err: fmt.Errorf("incorrect LinkMessage size, want: 92 or 96, got: 0"), }, { name: "invalid < 92", b: make([]byte, 91), err: fmt.Errorf("incorrect LinkMessage size, want: 92 or 96, got: 91"), }, { name: "invalid > 96", b: make([]byte, 97), err: fmt.Errorf("incorrect LinkMessage size, want: 92 or 96, got: 97"), }, { name: "invalid > 92 < 96", b: make([]byte, 93), err: fmt.Errorf("incorrect LinkMessage size, want: 92 or 96, got: 93"), }, { name: "kernel <4.6", b: []byte{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, }, m: &LinkStats{ RXPackets: 0, TXPackets: 0, RXBytes: 0, TXBytes: 0, RXErrors: 0, TXErrors: 0, RXDropped: 0, TXDropped: 0, Multicast: 0, Collisions: 0, RXLengthErrors: 0, RXOverErrors: 0, RXCRCErrors: 0, RXFrameErrors: 0, RXFIFOErrors: 0, RXMissedErrors: 0, TXAbortedErrors: 0, TXCarrierErrors: 0, TXFIFOErrors: 0, TXHeartbeatErrors: 0, TXWindowErrors: 0, RXCompressed: 0, TXCompressed: 0, }, }, { name: "kernel 4.6+", b: []byte{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, }, m: &LinkStats{ RXPackets: 0, TXPackets: 0, RXBytes: 0, TXBytes: 0, RXErrors: 0, TXErrors: 0, RXDropped: 0, TXDropped: 0, Multicast: 0, Collisions: 0, RXLengthErrors: 0, RXOverErrors: 0, RXCRCErrors: 0, RXFrameErrors: 0, RXFIFOErrors: 0, RXMissedErrors: 0, TXAbortedErrors: 0, TXCarrierErrors: 0, TXFIFOErrors: 0, TXHeartbeatErrors: 0, TXWindowErrors: 0, RXCompressed: 0, TXCompressed: 0, RXNoHandler: 0, }, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { m := &LinkStats{} err := (m).unmarshalBinary(tt.b) if err != nil { if want, got := fmt.Sprintf("%s", tt.err), fmt.Sprintf("%s", err); want != got { t.Fatalf("unexpected error:\n- want: %v\n- got: %v", want, got) } return } if want, got := tt.m, m; !reflect.DeepEqual(want, got) { t.Fatalf("unexpected Message:\n- want: %#v\n- got: %#v", want, got) } }) } } func TestLinkStats64UnmarshalBinary(t *testing.T) { skipBigEndian(t) tests := []struct { name string b []byte m *LinkStats64 err error }{ { name: "empty", err: fmt.Errorf("incorrect size, want: 184 or 192 or 200"), }, { name: "invalid < 184", b: make([]byte, 183), err: fmt.Errorf("incorrect size, want: 184 or 192 or 200"), }, { name: "invalid > 184 < 192", b: make([]byte, 188), err: fmt.Errorf("incorrect size, want: 184 or 192 or 200"), }, { name: "invalid > 192 < 200", b: make([]byte, 193), err: fmt.Errorf("incorrect size, want: 184 or 192 or 200"), }, { name: "invalid > 200", b: make([]byte, 201), err: fmt.Errorf("incorrect size, want: 184 or 192 or 200"), }, { name: "kernel <4.6", b: []byte{ 0x50, 0xb6, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0xc9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa9, 0x41, 0xcd, 0x09, 0x00, 0x00, 0x00, 0x00, 0x96, 0x96, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, }, m: &LinkStats64{ RXPackets: 0x1b650, TXPackets: 0xc906, RXBytes: 0x9cd41a9, TXBytes: 0x2a9696, RXErrors: 0x0, TXErrors: 0x0, RXDropped: 0x0, TXDropped: 0x0, Multicast: 0x0, Collisions: 0x0, RXLengthErrors: 0x0, RXOverErrors: 0x0, RXCRCErrors: 0x0, RXFrameErrors: 0x0, RXFIFOErrors: 0x0, RXMissedErrors: 0x0, TXAbortedErrors: 0x0, TXCarrierErrors: 0x0, TXFIFOErrors: 0x0, TXHeartbeatErrors: 0x0, TXWindowErrors: 0x0, RXCompressed: 0x0, TXCompressed: 0x0, }, }, { name: "kernel 4.6+", b: []byte{ 0x50, 0xb6, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0xc9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa9, 0x41, 0xcd, 0x09, 0x00, 0x00, 0x00, 0x00, 0x96, 0x96, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, }, m: &LinkStats64{ RXPackets: 0x1b650, TXPackets: 0xc906, RXBytes: 0x9cd41a9, TXBytes: 0x2a9696, RXErrors: 0x0, TXErrors: 0x0, RXDropped: 0x0, TXDropped: 0x0, Multicast: 0x0, Collisions: 0x0, RXLengthErrors: 0x0, RXOverErrors: 0x0, RXCRCErrors: 0x0, RXFrameErrors: 0x0, RXFIFOErrors: 0x0, RXMissedErrors: 0x0, TXAbortedErrors: 0x0, TXCarrierErrors: 0x0, TXFIFOErrors: 0x0, TXHeartbeatErrors: 0x0, TXWindowErrors: 0x0, RXCompressed: 0x0, TXCompressed: 0x0, RXNoHandler: 0x1, }, }, { name: "kernel 5.19+", b: []byte{ 0x50, 0xb6, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0xc9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa9, 0x41, 0xcd, 0x09, 0x00, 0x00, 0x00, 0x00, 0x96, 0x96, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, }, m: &LinkStats64{ RXPackets: 0x1b650, TXPackets: 0xc906, RXBytes: 0x9cd41a9, TXBytes: 0x2a9696, RXErrors: 0x0, TXErrors: 0x0, RXDropped: 0x0, TXDropped: 0x0, Multicast: 0x0, Collisions: 0x0, RXLengthErrors: 0x0, RXOverErrors: 0x0, RXCRCErrors: 0x0, RXFrameErrors: 0x0, RXFIFOErrors: 0x0, RXMissedErrors: 0x0, TXAbortedErrors: 0x0, TXCarrierErrors: 0x0, TXFIFOErrors: 0x0, TXHeartbeatErrors: 0x0, TXWindowErrors: 0x0, RXCompressed: 0x0, TXCompressed: 0x0, RXNoHandler: 0x1, RXOtherhostDropped: 0x2, }, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { m := &LinkStats64{} err := (m).unmarshalBinary(tt.b) if err != nil { if want, got := fmt.Sprintf("%s", tt.err), fmt.Sprintf("%s", err); want != got { t.Fatalf("unexpected error:\n- want: %v\n- got: %v", want, got) } return } if want, got := tt.m, m; !reflect.DeepEqual(want, got) { t.Fatalf("unexpected Message:\n- want: %#v\n- got: %#v", want, got) } }) } } golang-github-jsimonetti-rtnetlink-1.4.1/neigh.go000066400000000000000000000114241455442221600220670ustar00rootroot00000000000000package rtnetlink import ( "errors" "fmt" "net" "github.com/jsimonetti/rtnetlink/internal/unix" "github.com/mdlayher/netlink" ) var ( // errInvalidNeighMessage is returned when a LinkMessage is malformed. errInvalidNeighMessage = errors.New("rtnetlink NeighMessage is invalid or too short") ) var _ Message = &NeighMessage{} // A NeighMessage is a route netlink neighbor message. type NeighMessage struct { // Always set to AF_UNSPEC (0) Family uint16 // Unique interface index Index uint32 // Neighbor State is a bitmask of neighbor states (see rtnetlink(7)) State uint16 // Neighbor flags Flags uint8 // Neighbor type Type uint8 // Attributes List Attributes *NeighAttributes } // MarshalBinary marshals a NeighMessage into a byte slice. func (m *NeighMessage) MarshalBinary() ([]byte, error) { b := make([]byte, unix.SizeofNdMsg) b[0] = uint8(m.Family) // bytes 2-4 are padding nativeEndian.PutUint32(b[4:8], m.Index) nativeEndian.PutUint16(b[8:10], m.State) b[10] = m.Flags b[11] = m.Type if m.Attributes != nil { ae := netlink.NewAttributeEncoder() ae.ByteOrder = nativeEndian err := m.Attributes.encode(ae) if err != nil { return nil, err } a, err := ae.Encode() if err != nil { return nil, err } return append(b, a...), nil } return b, nil } // UnmarshalBinary unmarshals the contents of a byte slice into a NeighMessage. func (m *NeighMessage) UnmarshalBinary(b []byte) error { l := len(b) if l < unix.SizeofNdMsg { return errInvalidNeighMessage } m.Family = uint16(b[0]) m.Index = nativeEndian.Uint32(b[4:8]) m.State = nativeEndian.Uint16(b[8:10]) m.Flags = b[10] m.Type = b[11] if l > unix.SizeofNdMsg { m.Attributes = &NeighAttributes{} ad, err := netlink.NewAttributeDecoder(b[unix.SizeofNdMsg:]) if err != nil { return err } ad.ByteOrder = nativeEndian err = m.Attributes.decode(ad) if err != nil { return err } } return nil } // rtMessage is an empty method to sattisfy the Message interface. func (*NeighMessage) rtMessage() {} // NeighService is used to retrieve rtnetlink family information. type NeighService struct { c *Conn } // New creates a new interface using the LinkMessage information. func (l *NeighService) New(req *NeighMessage) error { flags := netlink.Request | netlink.Create | netlink.Acknowledge | netlink.Excl _, err := l.c.Execute(req, unix.RTM_NEWNEIGH, flags) if err != nil { return err } return nil } // Delete removes an neighbor entry by index. func (l *NeighService) Delete(index uint32) error { req := &NeighMessage{} flags := netlink.Request | netlink.Acknowledge _, err := l.c.Execute(req, unix.RTM_DELNEIGH, flags) if err != nil { return err } return nil } // List retrieves all neighbors. func (l *NeighService) List() ([]NeighMessage, error) { req := NeighMessage{} flags := netlink.Request | netlink.Dump msgs, err := l.c.Execute(&req, unix.RTM_GETNEIGH, flags) if err != nil { return nil, err } neighs := make([]NeighMessage, len(msgs)) for i := range msgs { neighs[i] = *msgs[i].(*NeighMessage) } return neighs, nil } // NeighCacheInfo contains neigh information type NeighCacheInfo struct { Confirmed uint32 Used uint32 Updated uint32 RefCount uint32 } // UnmarshalBinary unmarshals the contents of a byte slice into a NeighMessage. func (n *NeighCacheInfo) unmarshalBinary(b []byte) error { if len(b) != 16 { return fmt.Errorf("incorrect size, want: 16, got: %d", len(b)) } n.Confirmed = nativeEndian.Uint32(b[0:4]) n.Used = nativeEndian.Uint32(b[4:8]) n.Updated = nativeEndian.Uint32(b[8:12]) n.RefCount = nativeEndian.Uint32(b[12:16]) return nil } // NeighAttributes contains all attributes for a neighbor. type NeighAttributes struct { Address net.IP // a neighbor cache n/w layer destination address LLAddress net.HardwareAddr // a neighbor cache link layer address CacheInfo *NeighCacheInfo // cache statistics IfIndex uint32 } func (a *NeighAttributes) decode(ad *netlink.AttributeDecoder) error { for ad.Next() { switch ad.Type() { case unix.NDA_UNSPEC: // unused attribute case unix.NDA_DST: a.Address = ad.Bytes() case unix.NDA_LLADDR: // Allow IEEE 802 MAC-48, EUI-48, EUI-64, or 20-octet // IP over InfiniBand link-layer addresses l := len(ad.Bytes()) if l == 0 { // Ignore empty addresses. continue } a.LLAddress = ad.Bytes() case unix.NDA_CACHEINFO: a.CacheInfo = &NeighCacheInfo{} err := a.CacheInfo.unmarshalBinary(ad.Bytes()) if err != nil { return err } case unix.NDA_IFINDEX: a.IfIndex = ad.Uint32() } } return nil } func (a *NeighAttributes) encode(ae *netlink.AttributeEncoder) error { ae.Uint16(unix.NDA_UNSPEC, 0) ae.Bytes(unix.NDA_DST, a.Address) ae.Bytes(unix.NDA_LLADDR, a.LLAddress) ae.Uint32(unix.NDA_IFINDEX, a.IfIndex) return nil } golang-github-jsimonetti-rtnetlink-1.4.1/neigh_test.go000066400000000000000000000107631455442221600231330ustar00rootroot00000000000000package rtnetlink import ( "bytes" "net" "testing" "github.com/google/go-cmp/cmp" "github.com/jsimonetti/rtnetlink/internal/unix" ) // Tests will only pass on little endian machines func TestNeighMessageMarshalBinary(t *testing.T) { skipBigEndian(t) tests := []struct { name string m Message b []byte err error }{ { name: "empty", m: &NeighMessage{}, b: []byte{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, }, }, { name: "no attributes", m: &NeighMessage{ Index: 2, State: 64, Type: unix.NTF_PROXY, }, b: []byte{ 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x08, }, }, { name: "attributes", m: &NeighMessage{ Index: 2, State: 64, Type: unix.NTF_PROXY, Attributes: &NeighAttributes{ Address: net.ParseIP("10.0.0.0"), LLAddress: []byte{0x33, 0x33, 0x00, 0x00, 0x00, 0x16}, IfIndex: 0, CacheInfo: &NeighCacheInfo{}, }, }, b: []byte{ 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x08, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x0a, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x02, 0x00, 0x33, 0x33, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x08, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, }, }, { name: "infiniband LL address", m: &NeighMessage{ Index: 2, State: 64, Type: unix.NTF_PROXY, Attributes: &NeighAttributes{ LLAddress: []byte{0x0, 0x0, 0x0, 0x0, 0xfe, 0x80, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x02, 0x0, 0x5e, 0x10, 0x0, 0x0, 0x0, 0x01}, }, }, b: []byte{ 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x08, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x01, 0x00, 0x18, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x5e, 0x10, 0x00, 0x00, 0x00, 0x01, 0x08, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, }, }, { name: "EUI-64 LL", m: &NeighMessage{ Index: 2, State: 64, Type: unix.NTF_PROXY, Attributes: &NeighAttributes{ LLAddress: []byte{0x0, 0x0, 0x0, 0x0, 0xfe, 0x80, 0x0, 0xd}, }, }, b: []byte{ 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x08, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x01, 0x00, 0x0c, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x80, 0x00, 0x0d, 0x08, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, }, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { b, err := tt.m.MarshalBinary() if want, got := tt.err, err; want != got { t.Fatalf("unexpected error:\n- want: %v\n- got: %v", want, got) } if err != nil { return } if want, got := tt.b, b; !bytes.Equal(want, got) { t.Fatalf("unexpected Message bytes:\n- want: [%# x]\n- got: [%# x]", want, got) } }) } } func TestNeighMessageUnmarshalBinary(t *testing.T) { skipBigEndian(t) tests := []struct { name string b []byte m Message a NeighAttributes err error }{ { name: "empty", err: errInvalidNeighMessage, }, { name: "short", b: make([]byte, 11), err: errInvalidNeighMessage, }, { name: "data", b: []byte{ 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x08, }, m: &NeighMessage{ Index: 2, State: 64, Type: unix.NTF_PROXY, }, }, { name: "Empty LLAddr", b: []byte{ 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x08, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x0a, 0x00, 0x00, 0x01, 0x04, 0x00, 0x02, 0x00, 0x08, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, }, m: &NeighMessage{ Index: 2, State: 64, Type: unix.NTF_PROXY, Attributes: &NeighAttributes{ Address: net.ParseIP("10.0.0.1"), LLAddress: nil, }, }, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { m := &NeighMessage{} err := (m).UnmarshalBinary(tt.b) if want, got := tt.err, err; want != got { t.Fatalf("unexpected error:\n- want: %v\n- got: %v", want, got) } if err != nil { return } if diff := cmp.Diff(tt.m, m); diff != "" { t.Fatalf("unexpected Message: %s\n(-want +got):\n%s", tt.name, diff) } }) } } golang-github-jsimonetti-rtnetlink-1.4.1/route.go000066400000000000000000000357041455442221600221420ustar00rootroot00000000000000package rtnetlink import ( "encoding/binary" "errors" "fmt" "net" "unsafe" "github.com/jsimonetti/rtnetlink/internal/unix" "github.com/mdlayher/netlink" ) var ( // errInvalidRouteMessage is returned when a RouteMessage is malformed. errInvalidRouteMessage = errors.New("rtnetlink RouteMessage is invalid or too short") // errInvalidRouteMessageAttr is returned when link attributes are malformed. errInvalidRouteMessageAttr = errors.New("rtnetlink RouteMessage has a wrong attribute data length") ) var _ Message = &RouteMessage{} type RouteMessage struct { Family uint8 // Address family (current unix.AF_INET or unix.AF_INET6) DstLength uint8 // Length of destination prefix SrcLength uint8 // Length of source prefix Tos uint8 // TOS filter Table uint8 // Routing table ID Protocol uint8 // Routing protocol Scope uint8 // Distance to the destination Type uint8 // Route type Flags uint32 Attributes RouteAttributes } func (m *RouteMessage) MarshalBinary() ([]byte, error) { b := make([]byte, unix.SizeofRtMsg) b[0] = m.Family b[1] = m.DstLength b[2] = m.SrcLength b[3] = m.Tos b[4] = m.Table b[5] = m.Protocol b[6] = m.Scope b[7] = m.Type nativeEndian.PutUint32(b[8:12], m.Flags) ae := netlink.NewAttributeEncoder() err := m.Attributes.encode(ae) if err != nil { return nil, err } a, err := ae.Encode() if err != nil { return nil, err } return append(b, a...), nil } func (m *RouteMessage) UnmarshalBinary(b []byte) error { l := len(b) if l < unix.SizeofRtMsg { return errInvalidRouteMessage } m.Family = uint8(b[0]) m.DstLength = uint8(b[1]) m.SrcLength = uint8(b[2]) m.Tos = uint8(b[3]) m.Table = uint8(b[4]) m.Protocol = uint8(b[5]) m.Scope = uint8(b[6]) m.Type = uint8(b[7]) m.Flags = nativeEndian.Uint32(b[8:12]) if l > unix.SizeofRtMsg { ad, err := netlink.NewAttributeDecoder(b[unix.SizeofRtMsg:]) if err != nil { return err } var ra RouteAttributes if err := ra.decode(ad); err != nil { return err } // Must consume errors from decoder before returning. if err := ad.Err(); err != nil { return fmt.Errorf("invalid route message attributes: %v", err) } m.Attributes = ra } return nil } // rtMessage is an empty method to sattisfy the Message interface. func (*RouteMessage) rtMessage() {} type RouteService struct { c *Conn } func (r *RouteService) execute(m Message, family uint16, flags netlink.HeaderFlags) ([]RouteMessage, error) { msgs, err := r.c.Execute(m, family, flags) routes := make([]RouteMessage, len(msgs)) for i := range msgs { routes[i] = *msgs[i].(*RouteMessage) } return routes, err } // Add new route func (r *RouteService) Add(req *RouteMessage) error { flags := netlink.Request | netlink.Create | netlink.Acknowledge | netlink.Excl _, err := r.c.Execute(req, unix.RTM_NEWROUTE, flags) return err } // Replace or add new route func (r *RouteService) Replace(req *RouteMessage) error { flags := netlink.Request | netlink.Create | netlink.Replace | netlink.Acknowledge _, err := r.c.Execute(req, unix.RTM_NEWROUTE, flags) return err } // Delete existing route func (r *RouteService) Delete(req *RouteMessage) error { flags := netlink.Request | netlink.Acknowledge _, err := r.c.Execute(req, unix.RTM_DELROUTE, flags) return err } // Get Route(s) func (r *RouteService) Get(req *RouteMessage) ([]RouteMessage, error) { flags := netlink.Request | netlink.DumpFiltered return r.execute(req, unix.RTM_GETROUTE, flags) } // List all routes func (r *RouteService) List() ([]RouteMessage, error) { flags := netlink.Request | netlink.Dump return r.execute(&RouteMessage{}, unix.RTM_GETROUTE, flags) } type RouteAttributes struct { Dst net.IP Src net.IP Gateway net.IP OutIface uint32 Priority uint32 Table uint32 Mark uint32 Pref *uint8 Expires *uint32 Metrics *RouteMetrics Multipath []NextHop } func (a *RouteAttributes) decode(ad *netlink.AttributeDecoder) error { for ad.Next() { switch ad.Type() { case unix.RTA_UNSPEC: // unused attribute case unix.RTA_DST: ad.Do(decodeIP(&a.Dst)) case unix.RTA_PREFSRC: ad.Do(decodeIP(&a.Src)) case unix.RTA_GATEWAY: ad.Do(decodeIP(&a.Gateway)) case unix.RTA_OIF: a.OutIface = ad.Uint32() case unix.RTA_PRIORITY: a.Priority = ad.Uint32() case unix.RTA_TABLE: a.Table = ad.Uint32() case unix.RTA_MARK: a.Mark = ad.Uint32() case unix.RTA_EXPIRES: timeout := ad.Uint32() a.Expires = &timeout case unix.RTA_METRICS: a.Metrics = &RouteMetrics{} ad.Nested(a.Metrics.decode) case unix.RTA_MULTIPATH: ad.Do(a.parseMultipath) case unix.RTA_PREF: pref := ad.Uint8() a.Pref = &pref } } return nil } func (a *RouteAttributes) encode(ae *netlink.AttributeEncoder) error { if a.Dst != nil { ae.Do(unix.RTA_DST, encodeIP(a.Dst)) } if a.Src != nil { ae.Do(unix.RTA_PREFSRC, encodeIP(a.Src)) } if a.Gateway != nil { ae.Do(unix.RTA_GATEWAY, encodeIP(a.Gateway)) } if a.OutIface != 0 { ae.Uint32(unix.RTA_OIF, a.OutIface) } if a.Priority != 0 { ae.Uint32(unix.RTA_PRIORITY, a.Priority) } if a.Table != 0 { ae.Uint32(unix.RTA_TABLE, a.Table) } if a.Mark != 0 { ae.Uint32(unix.RTA_MARK, a.Mark) } if a.Pref != nil { ae.Uint8(unix.RTA_PREF, *a.Pref) } if a.Expires != nil { ae.Uint32(unix.RTA_EXPIRES, *a.Expires) } if a.Metrics != nil { ae.Nested(unix.RTA_METRICS, a.Metrics.encode) } if len(a.Multipath) > 0 { ae.Do(unix.RTA_MULTIPATH, a.encodeMultipath) } return nil } // RouteMetrics holds some advanced metrics for a route type RouteMetrics struct { AdvMSS uint32 Features uint32 InitCwnd uint32 InitRwnd uint32 MTU uint32 } func (rm *RouteMetrics) decode(ad *netlink.AttributeDecoder) error { for ad.Next() { switch ad.Type() { case unix.RTAX_ADVMSS: rm.AdvMSS = ad.Uint32() case unix.RTAX_FEATURES: rm.Features = ad.Uint32() case unix.RTAX_INITCWND: rm.InitCwnd = ad.Uint32() case unix.RTAX_INITRWND: rm.InitRwnd = ad.Uint32() case unix.RTAX_MTU: rm.MTU = ad.Uint32() } } // ad.Err call handled by Nested method in calling attribute decoder. return nil } func (rm *RouteMetrics) encode(ae *netlink.AttributeEncoder) error { if rm.AdvMSS != 0 { ae.Uint32(unix.RTAX_ADVMSS, rm.AdvMSS) } if rm.Features != 0 { ae.Uint32(unix.RTAX_FEATURES, rm.Features) } if rm.InitCwnd != 0 { ae.Uint32(unix.RTAX_INITCWND, rm.InitCwnd) } if rm.InitRwnd != 0 { ae.Uint32(unix.RTAX_INITRWND, rm.InitRwnd) } if rm.MTU != 0 { ae.Uint32(unix.RTAX_MTU, rm.MTU) } return nil } // TODO(mdlayher): probably eliminate Length field from the API to avoid the // caller possibly tampering with it since we can compute it. // RTNextHop represents the netlink rtnexthop struct (not an attribute) type RTNextHop struct { Length uint16 // length of this hop including nested values Flags uint8 // flags defined in rtnetlink.h line 311 Hops uint8 IfIndex uint32 // the interface index number } // NextHop wraps struct rtnexthop to provide access to nested attributes type NextHop struct { Hop RTNextHop // a rtnexthop struct Gateway net.IP // that struct's nested Gateway attribute MPLS []MPLSNextHop // Any MPLS next hops for a route. } func (a *RouteAttributes) encodeMultipath() ([]byte, error) { var b []byte for _, nh := range a.Multipath { // Encode the attributes first so their total length can be used to // compute the length of each (rtnexthop, attributes) pair. ae := netlink.NewAttributeEncoder() if nh.Gateway != nil { ae.Do(unix.RTA_GATEWAY, encodeIP(nh.Gateway)) } if len(nh.MPLS) > 0 { // TODO(mdlayher): validation over different encapsulation types, // and ensure that only one can be set. ae.Uint16(unix.RTA_ENCAP_TYPE, unix.LWTUNNEL_ENCAP_MPLS) ae.Nested(unix.RTA_ENCAP, nh.encodeEncap) } ab, err := ae.Encode() if err != nil { return nil, err } // Assume the caller wants the length updated so they don't have to // keep track of it themselves when encoding attributes. nh.Hop.Length = unix.SizeofRtNexthop + uint16(len(ab)) var nhb [unix.SizeofRtNexthop]byte copy( nhb[:], (*(*[unix.SizeofRtNexthop]byte)(unsafe.Pointer(&nh.Hop)))[:], ) // rtnexthop first, then attributes. b = append(b, nhb[:]...) b = append(b, ab...) } return b, nil } // parseMultipath consumes RTA_MULTIPATH data into RouteAttributes. func (a *RouteAttributes) parseMultipath(b []byte) error { // We cannot retain b after the function returns, so make a copy of the // bytes up front for the multipathParser. buf := make([]byte, len(b)) copy(buf, b) // Iterate until no more bytes remain in the buffer or an error occurs. mpp := &multipathParser{b: buf} for mpp.Next() { // Each iteration reads a fixed length RTNextHop structure immediately // followed by its associated netlink attributes with optional data. nh := NextHop{Hop: mpp.RTNextHop()} if err := nh.decode(mpp.AttributeDecoder()); err != nil { return err } // Stop iteration early if the data was malformed, or otherwise append // this NextHop to the Multipath field. if err := mpp.Err(); err != nil { return err } a.Multipath = append(a.Multipath, nh) } // Check the error when Next returns false. return mpp.Err() } // decode decodes netlink attribute values into a NextHop. func (nh *NextHop) decode(ad *netlink.AttributeDecoder) error { if ad == nil { // Invalid decoder, do nothing. return nil } // If encapsulation is present, we won't know how to deal with it until we // identify the right type and then later parse the nested attribute bytes. var ( encapType uint16 encapBuf []byte ) for ad.Next() { switch ad.Type() { case unix.RTA_ENCAP: encapBuf = ad.Bytes() case unix.RTA_ENCAP_TYPE: encapType = ad.Uint16() case unix.RTA_GATEWAY: ad.Do(decodeIP(&nh.Gateway)) } } if err := ad.Err(); err != nil { return err } if encapType != 0 && encapBuf != nil { // Found encapsulation, start decoding it from the buffer. return nh.decodeEncap(encapType, encapBuf) } return nil } // An MPLSNextHop is a route next hop using MPLS encapsulation. type MPLSNextHop struct { Label int TrafficClass int BottomOfStack bool TTL uint8 } // TODO(mdlayher): MPLSNextHop TTL vs MPLS_IPTUNNEL_TTL. What's the difference? // encodeEncap encodes netlink attribute values related to encapsulation from // a NextHop. func (nh *NextHop) encodeEncap(ae *netlink.AttributeEncoder) error { // TODO: this only handles MPLS encapsulation as that is all we support. // Allocate enough space for an MPLS label stack. var ( i int b = make([]byte, 4*len(nh.MPLS)) ) for _, mnh := range nh.MPLS { // Pack the following: // - label: 20 bits // - traffic class: 3 bits // - bottom-of-stack: 1 bit // - TTL: 8 bits binary.BigEndian.PutUint32(b[i:i+4], uint32(mnh.Label)<<12) b[i+2] |= byte(mnh.TrafficClass) << 1 if mnh.BottomOfStack { b[i+2] |= 1 } b[i+3] = mnh.TTL // Advance in the buffer to begin storing the next label. i += 4 } // Finally store the output bytes. ae.Bytes(unix.MPLS_IPTUNNEL_DST, b) return nil } // decodeEncap decodes netlink attribute values related to encapsulation into a // NextHop. func (nh *NextHop) decodeEncap(typ uint16, b []byte) error { if typ != unix.LWTUNNEL_ENCAP_MPLS { // TODO: handle other encapsulation types as needed. return nil } // MPLS labels are stored as big endian bytes. ad, err := netlink.NewAttributeDecoder(b) if err != nil { return err } for ad.Next() { switch ad.Type() { case unix.MPLS_IPTUNNEL_DST: // Every 4 bytes stores another MPLS label, so make sure the stored // bytes are divisible by exactly 4. b := ad.Bytes() if len(b)%4 != 0 { return errInvalidRouteMessageAttr } for i := 0; i < len(b); i += 4 { n := binary.BigEndian.Uint32(b[i : i+4]) // For reference, see: // https://en.wikipedia.org/wiki/Multiprotocol_Label_Switching#Operation nh.MPLS = append(nh.MPLS, MPLSNextHop{ Label: int(n) >> 12, TrafficClass: int(n & 0xe00 >> 9), BottomOfStack: n&0x100 != 0, TTL: uint8(n & 0xff), }) } } } return ad.Err() } // A multipathParser parses packed RTNextHop and netlink attributes into // multipath attributes for an rtnetlink route. type multipathParser struct { // Any errors which occurred during parsing. err error // The underlying buffer and a pointer to the reading position. b []byte i int // The length of the next set of netlink attributes. alen int } // Next continues iteration until an error occurs or no bytes remain. func (mpp *multipathParser) Next() bool { if mpp.err != nil { return false } // Are there enough bytes left for another RTNextHop, or 0 for EOF? n := len(mpp.b[mpp.i:]) switch { case n == 0: // EOF. return false case n >= unix.SizeofRtNexthop: return true default: mpp.err = errInvalidRouteMessageAttr return false } } // Err returns any errors encountered while parsing. func (mpp *multipathParser) Err() error { return mpp.err } // RTNextHop parses the next RTNextHop structure from the buffer. func (mpp *multipathParser) RTNextHop() RTNextHop { if mpp.err != nil { return RTNextHop{} } if len(mpp.b)-mpp.i < unix.SizeofRtNexthop { // Out of bounds access, not enough data for a valid RTNextHop. mpp.err = errInvalidRouteMessageAttr return RTNextHop{} } // Consume an RTNextHop from the buffer by copying its bytes into an output // structure while also verifying that the size of each structure is equal // to avoid any out-of-bounds unsafe memory access. var rtnh RTNextHop next := mpp.b[mpp.i : mpp.i+unix.SizeofRtNexthop] if unix.SizeofRtNexthop != len(next) { panic("rtnetlink: invalid RTNextHop structure size, panicking to avoid out-of-bounds unsafe access") } copy( (*(*[unix.SizeofRtNexthop]byte)(unsafe.Pointer(&rtnh)))[:], (*(*[unix.SizeofRtNexthop]byte)(unsafe.Pointer(&next[0])))[:], ) if rtnh.Length < unix.SizeofRtNexthop { // Length value is invalid. mpp.err = errInvalidRouteMessageAttr return RTNextHop{} } // Compute the length of the next set of attributes using the Length value // in the RTNextHop, minus the size of that fixed length structure itself. // Then, advance the pointer to be ready to read those attributes. mpp.alen = int(rtnh.Length) - unix.SizeofRtNexthop mpp.i += unix.SizeofRtNexthop return rtnh } // AttributeDecoder returns a netlink.AttributeDecoder pointed at the next set // of netlink attributes from the buffer. func (mpp *multipathParser) AttributeDecoder() *netlink.AttributeDecoder { if mpp.err != nil { return nil } // Ensure the attributes length value computed while parsing the rtnexthop // fits within the actual slice. if len(mpp.b[mpp.i:]) < mpp.alen { mpp.err = errInvalidRouteMessageAttr return nil } // Consume the next set of netlink attributes from the buffer and advance // the pointer to the next RTNextHop or EOF once that is complete. ad, err := netlink.NewAttributeDecoder(mpp.b[mpp.i : mpp.i+mpp.alen]) if err != nil { mpp.err = err return nil } mpp.i += mpp.alen return ad } golang-github-jsimonetti-rtnetlink-1.4.1/route_test.go000066400000000000000000000233621455442221600231760ustar00rootroot00000000000000package rtnetlink import ( "net" "testing" "github.com/google/go-cmp/cmp" "github.com/jsimonetti/rtnetlink/internal/unix" ) // Tests will only pass on little endian machines func TestRouteMessageMarshalUnmarshalBinary(t *testing.T) { skipBigEndian(t) var ( timeout = uint32(255) pref = uint8(1) ) tests := []struct { name string m *RouteMessage b []byte }{ { name: "empty", m: &RouteMessage{}, b: []byte{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, }, }, { name: "no attributes", m: &RouteMessage{ Family: unix.AF_INET, DstLength: 8, Type: unix.RTN_UNICAST, }, b: []byte{ 0x02, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, }, }, { name: "full", m: &RouteMessage{ Family: 2, DstLength: 8, Table: unix.RT_TABLE_MAIN, Protocol: unix.RTPROT_STATIC, Scope: unix.RT_SCOPE_UNIVERSE, Type: unix.RTN_UNICAST, Attributes: RouteAttributes{ Dst: net.IPv4(10, 0, 0, 0), Src: net.IPv4(10, 100, 10, 1), Gateway: net.IPv4(10, 0, 0, 1), OutIface: 5, Priority: 1, Table: 2, Mark: 3, Pref: &pref, Expires: &timeout, Metrics: &RouteMetrics{ AdvMSS: 1, Features: 0xffffffff, InitCwnd: 2, InitRwnd: 3, MTU: 1500, }, Multipath: []NextHop{ { Hop: RTNextHop{ Length: 16, IfIndex: 1, }, Gateway: net.IPv4(10, 0, 0, 2), }, { Hop: RTNextHop{ Length: 16, IfIndex: 2, }, Gateway: net.IPv4(10, 0, 0, 3), }, }, }, }, b: []byte{ // RouteMessage struct literal // // Family 0x02, // DstLength 0x08, // SrcLength 0x00, // Tos 0x00, // Table 0xfe, // Protocol 0x04, // Scope 0x00, // Type 0x01, // Flags 0x00, 0x00, 0x00, 0x00, // RouteAttributes // 2 bytes length, 2 bytes type, N bytes value // // Dst 0x08, 0x00, 0x01, 0x00, 0x0a, 0x00, 0x00, 0x00, // Src 0x08, 0x00, 0x07, 0x00, 0x0a, 0x64, 0x0a, 0x01, // Gateway 0x08, 0x00, 0x05, 0x00, 0x0a, 0x00, 0x00, 0x01, // OutIface 0x08, 0x00, 0x04, 0x00, 0x05, 0x00, 0x00, 0x00, // Priority 0x08, 0x00, 0x06, 0x00, 0x01, 0x00, 0x00, 0x00, // Table 0x08, 0x00, 0x0f, 0x00, 0x02, 0x00, 0x00, 0x00, // Mark 0x08, 0x00, 0x10, 0x00, 0x03, 0x00, 0x00, 0x00, // Pref 0x05, 0x00, 0x14, 0x00, 0x01, 0x00, 0x00, 0x00, // Expires 0x08, 0x00, 0x17, 0x00, 0xff, 0x00, 0x00, 0x00, // RouteMetrics // Length must be manually adjusted as more fields are added. 0x2c, 0x00, 0x08, 0x80, // AdvMSS 0x08, 0x00, 0x08, 0x00, 0x01, 0x00, 0x00, 0x00, // Features 0x08, 0x00, 0x0c, 0x00, 0xff, 0xff, 0xff, 0xff, // InitCwnd 0x08, 0x00, 0x0b, 0x00, 0x02, 0x00, 0x00, 0x00, // InitRwnd 0x08, 0x00, 0x0e, 0x00, 0x03, 0x00, 0x00, 0x00, // MTU 0x08, 0x00, 0x02, 0x00, 0xdc, 0x05, 0x00, 0x00, // Multipath // // 2 bytes length, 2 bytes type, then repeated 8 byte rtnexthop // structures followed by their nested netlink attributes. 0x24, 0x00, 0x09, 0x00, // rtnexthop 0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, // rtnexthop attributes 0x08, 0x00, 0x05, 0x00, // Gateway 10, 0, 0, 2, // rtnexthop 0x10, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, // rtnexthop attributes 0x08, 0x00, 0x05, 0x00, // Gateway 10, 0, 0, 3, }, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { // It's important to be able to parse raw bytes into valid // structures so we start with that step first. After, we'll do a // marshaling round-trip to ensure that the structure's byte output // and parsed form match what is expected, while also comparing // against the expected fixtures throughout. var m1 RouteMessage if err := m1.UnmarshalBinary(tt.b); err != nil { t.Fatalf("failed to unmarshal first message from binary: %v", err) } if diff := cmp.Diff(tt.m, &m1); diff != "" { t.Fatalf("unexpected first message (-want +got):\n%s", diff) } b, err := m1.MarshalBinary() if err != nil { t.Fatalf("failed to marshal first message binary: %v", err) } if diff := cmp.Diff(tt.b, b); diff != "" { t.Fatalf("unexpected first message bytes (-want +got):\n%s", diff) } var m2 RouteMessage if err := m2.UnmarshalBinary(b); err != nil { t.Fatalf("failed to unmarshal second message from binary: %v", err) } if diff := cmp.Diff(&m1, &m2); diff != "" { t.Fatalf("unexpected parsed messages (-want +got):\n%s", diff) } }) } } func TestRouteMessageMarshalRoundTrip(t *testing.T) { skipBigEndian(t) // The above tests begin with unmarshaling raw bytes and are more // comprehensive, but due to the complexity of nested route message // attributes and structures, it has become rather difficult to maintain // over time. These tests will focus on a subset of that functionality to // ensure that marshaling and unmarshaling perform symmetrical operations // given a proper Go type as input, rather than raw bytes. tests := []struct { name string m *RouteMessage }{ { name: "multipath IPv4 MPLS", m: &RouteMessage{ Attributes: RouteAttributes{ Multipath: []NextHop{ { Hop: RTNextHop{ Length: 36, IfIndex: 1, }, Gateway: net.IPv4(10, 0, 0, 2), MPLS: []MPLSNextHop{{ Label: 1, TrafficClass: 1, BottomOfStack: true, TTL: 1, }}, }, { Hop: RTNextHop{ Length: 40, IfIndex: 2, }, Gateway: net.IPv4(10, 0, 0, 3), MPLS: []MPLSNextHop{ { Label: 1, TrafficClass: 1, TTL: 1, }, { Label: 2, TrafficClass: 2, BottomOfStack: true, TTL: 2, }, }, }, }, }, }, }, { name: "multipath IPv6 MPLS", m: &RouteMessage{ Attributes: RouteAttributes{ Multipath: []NextHop{ { Hop: RTNextHop{ Length: 48, IfIndex: 1, }, Gateway: net.ParseIP("2001:db8::1"), MPLS: []MPLSNextHop{{ Label: 1, TrafficClass: 1, BottomOfStack: true, TTL: 1, }}, }, { Hop: RTNextHop{ Length: 52, IfIndex: 2, }, Gateway: net.ParseIP("2001:db8::2"), MPLS: []MPLSNextHop{ { Label: 1, TrafficClass: 1, TTL: 1, }, { Label: 2, TrafficClass: 2, BottomOfStack: true, TTL: 2, }, }, }, }, }, }, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { // First do a marshaling and unmarshaling round trip to ensure // the inputs and outputs are identical. b1, err := tt.m.MarshalBinary() if err != nil { t.Fatalf("failed to marshal test message: %v", err) } var m RouteMessage if err := m.UnmarshalBinary(b1); err != nil { t.Fatalf("failed to unmarshal: %v", err) } if diff := cmp.Diff(tt.m, &m); diff != "" { t.Fatalf("unexpected RouteMessage after round-trip (-want +got):\n%s", diff) } // Then compare the results of the first marshaled bytes against // the newly marshaled bytes. b2, err := m.MarshalBinary() if err != nil { t.Fatalf("failed to marshal parsed message: %v", err) } if diff := cmp.Diff(b1, b2); diff != "" { t.Fatalf("unexpected final raw byte output (-want +got):\n%s", diff) } }) } } func TestRouteMessageUnmarshalBinaryErrors(t *testing.T) { skipBigEndian(t) tests := []struct { name string b []byte m Message }{ { name: "empty", }, { name: "short", b: make([]byte, 3), }, { name: "invalid attr", b: []byte{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x01, 0x00, 0x04, 0x00, 0x02, 0x00, 0x05, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, }, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { var m RouteMessage err := m.UnmarshalBinary(tt.b) if err == nil { t.Fatal("expected an error, but none occurred") } t.Logf("err: %v", err) }) } } func TestRouteMessageFuzz(t *testing.T) { skipBigEndian(t) tests := []struct { name string s string }{ // Strings in this test table are copied from go-fuzz crashers. { name: "short rtnexthop", s: "\xef\xbf\xea\x00\a\x00\xd1\xea\xf9A\b\xf9\b\x00\t\x00\xbfA\b\xf9" + "\b\x00\a\x00\xf9A\b\xf9\b\x00\a\x00\xbfA\b\xf9\b\x00\a\x00" + "\xd3\xea\xf9A\b\x00\a\u007f\xff\xff\xffA\b\x00\a\x00\xd3\xea\xf9A" + "\b\x00\a\x00\xbfA\b\xf9\b\x00\a\x00\xd3\xea\xf9A\b\x00\a\x00" + "\xd3\xea\xf9A\b\x00\a\x00\xbfA\b\xf9\b\x00\a\x00\xd3-\xbf\xbd", }, { name: "out of bounds attributes length", s: "000000000000\x14\x00\t\x000\xea00" + "000000000000", }, { name: "bad rtnexthop length", s: "000000000000!\x00\t\x00\b\x0000" + "0000\b\x00000000\x06\x00000000" + "00000", }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { var m RouteMessage if err := m.UnmarshalBinary([]byte(tt.s)); err == nil { t.Fatal("expected an error, but none occurred") } }) } } golang-github-jsimonetti-rtnetlink-1.4.1/rtnl/000077500000000000000000000000001455442221600214235ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/rtnl/addr.go000066400000000000000000000112561455442221600226710ustar00rootroot00000000000000package rtnl import ( "net" "github.com/jsimonetti/rtnetlink/internal/unix" "github.com/jsimonetti/rtnetlink" ) // AddrAdd associates an IP-address with an interface. // // iface, _ := net.InterfaceByName("lo") // conn.AddrAdd(iface, rtnl.MustParseAddr("127.0.0.1/8")) func (c *Conn) AddrAdd(ifc *net.Interface, addr *net.IPNet) error { af, err := addrFamily(addr.IP) if err != nil { return err } scope := addrScope(addr.IP) prefixlen, _ := addr.Mask.Size() tx := &rtnetlink.AddressMessage{ Family: uint8(af), PrefixLength: uint8(prefixlen), Scope: uint8(scope), Index: uint32(ifc.Index), Attributes: &rtnetlink.AddressAttributes{ Address: addr.IP, Local: addr.IP, }, } if ip4 := addr.IP.To4(); ip4 != nil { tx.Attributes.Broadcast = broadcastAddr(addr) tx.Attributes.Address = ip4 tx.Attributes.Local = ip4 } return c.Conn.Address.New(tx) } // AddrDel revokes an IP-address from an interface. // // iface, _ := net.InterfaceByName("lo") // conn.AddrDel(iface, rtnl.MustParseAddr("127.0.0.1/8")) func (c *Conn) AddrDel(ifc *net.Interface, addr *net.IPNet) error { af, err := addrFamily(addr.IP) if err != nil { return err } prefixlen, _ := addr.Mask.Size() rx, err := c.Addrs(ifc, af) if err != nil { return err } for _, v := range rx { plen, _ := v.Mask.Size() if plen == prefixlen && v.IP.Equal(addr.IP) { tx := &rtnetlink.AddressMessage{ Family: uint8(af), PrefixLength: uint8(prefixlen), Index: uint32(ifc.Index), Attributes: &rtnetlink.AddressAttributes{ Address: addr.IP, }, } if ip4 := addr.IP.To4(); ip4 != nil { tx.Attributes.Broadcast = broadcastAddr(addr) tx.Attributes.Address = ip4 } return c.Conn.Address.Delete(tx) } } return &net.AddrError{Err: "address not found", Addr: addr.IP.String()} } // Addrs returns IP addresses matching the interface and address family. // To retrieve all addresses configured for the system, run: // // conn.Addrs(nil, 0) func (c *Conn) Addrs(ifc *net.Interface, family int) (out []*net.IPNet, err error) { rx, err := c.Conn.Address.List() if err != nil { return nil, err } match := func(v *rtnetlink.AddressMessage, ifc *net.Interface, family int) bool { if ifc != nil && v.Index != uint32(ifc.Index) { return false } if family != 0 && v.Family != uint8(family) { return false } return true } for _, m := range rx { if match(&m, ifc, family) { bitlen := 8 * len(m.Attributes.Address) a := &net.IPNet{ IP: m.Attributes.Address, Mask: net.CIDRMask(int(m.PrefixLength), bitlen), } out = append(out, a) } } return } // ParseAddr parses a CIDR string into a host address and network mask. // This is a convenience wrapper around net.ParseCIDR(), which surprisingly // returns the network address and mask instead of the host address and mask. func ParseAddr(s string) (*net.IPNet, error) { addr, cidr, err := net.ParseCIDR(s) if err != nil { return nil, err } // Overwrite cidr's network address with the host address // parsed from the string representation. cidr.IP = addr if isSubnetAddr(cidr) { return nil, &net.AddrError{ Err: "attempted to parse a subnet address into a host address", Addr: cidr.IP.String(), } } return cidr, nil } // MustParseAddr wraps ParseAddr, but panics on error. // Use to conveniently parse a known-valid or hardcoded // address into a function argument. // // iface, _ := net.InterfaceByName("enp2s0") // conn.AddrDel(iface, rtnl.MustParseAddr("10.1.1.1/24")) func MustParseAddr(s string) *net.IPNet { n, err := ParseAddr(s) if err != nil { panic(err) } return n } func addrFamily(ip net.IP) (int, error) { if ip.To4() != nil { return unix.AF_INET, nil } if len(ip) == net.IPv6len { return unix.AF_INET6, nil } return 0, &net.AddrError{Err: "invalid IP address", Addr: ip.String()} } func addrScope(ip net.IP) int { if ip.IsGlobalUnicast() { return unix.RT_SCOPE_UNIVERSE } if ip.IsLoopback() { return unix.RT_SCOPE_HOST } return unix.RT_SCOPE_LINK } func broadcastAddr(ipnet *net.IPNet) net.IP { ip := ipnet.IP.To4() if ip == nil { return nil } mask := net.IP(ipnet.Mask).To4() n := len(ip) if n != len(mask) { return nil } out := make(net.IP, n) for i := 0; i < n; i++ { out[i] = ip[i] | ^mask[i] } return out } // isSubnetAddr returns true if ipnet is a network (subnet) address. // It applies ipnet's subnet mask onto itself and compares the result to the // value of ipnet's IP field. func isSubnetAddr(ipnet *net.IPNet) bool { // Addresses with /32 and /128 are always hosts. if ones, bits := ipnet.Mask.Size(); ones == bits { return false } if ipnet.IP.Mask(ipnet.Mask).Equal(ipnet.IP) { return true } return false } golang-github-jsimonetti-rtnetlink-1.4.1/rtnl/addr_live_test.go000066400000000000000000000045031455442221600247440ustar00rootroot00000000000000//go:build integration // +build integration package rtnl import ( "errors" "net" "syscall" "testing" "github.com/mdlayher/netlink" ) var errNoLoopback = errors.New("no loopback interface") func loopbackInterface(c *Conn) (*net.Interface, error) { links, err := c.Links() if err != nil { return nil, err } for _, ifc := range links { if ifc.Flags&net.FlagLoopback != 0 { return ifc, nil } } return nil, errNoLoopback } func interfaceHasAddr(c *Conn, ifc *net.Interface, addr *net.IPNet) (bool, error) { addrs, err := c.Addrs(ifc, 0) if err != nil { return false, err } for _, a := range addrs { if ipnetEqual(a, addr) { return true, nil } } return false, nil } func ipnetEqual(a, b *net.IPNet) bool { na, _ := a.Mask.Size() nb, _ := b.Mask.Size() return na == nb && a.IP.Equal(b.IP) } func TestLiveAddrs(t *testing.T) { c, err := Dial(nil) if err != nil { t.Fatal(err) } defer c.Close() addrs, err := c.Addrs(nil, 0) if err != nil { t.Fatal(err) } if len(addrs) == 0 { t.Skip("no network addresses") } for i, a := range addrs { t.Logf("* entry %d: %#v", i, a) if a == nil { t.Error("nil address result") continue } if a.IP.IsUnspecified() { t.Error("address unspecified") } if a.Mask == nil { t.Error("mask unspecified") } else { ones, bits := a.Mask.Size() if bits != 8*net.IPv4len && bits != 8*net.IPv6len { t.Error("bad mask length") } if ones == 0 || ones > bits { t.Error("bad prefix length") } } } } func TestLiveAddrAddDel(t *testing.T) { c, err := Dial(nil) if err != nil { t.Fatal(err) } defer c.Close() lo, err := loopbackInterface(c) if err != nil { t.Skip(err) } if lo == nil { t.Fatal("no error but nil result") } testip := MustParseAddr("127.0.0.99/32") c.AddrDel(lo, testip) // ok if fails if err := c.AddrAdd(lo, testip); err != nil { // requires specific privilege - skip the test if can't do if v, ok := err.(*netlink.OpError); ok && v.Err == syscall.EPERM { t.Skip("AddrAdd: ", err) } t.Fatal("AddrAdd:", err) } // if the above suceeded, everything below should do, too ok, err := interfaceHasAddr(c, lo, testip) if err != nil { t.Error(err) } else if !ok { t.Error("address reported as added but can't confirm") } if err := c.AddrDel(lo, testip); err != nil { t.Error("AddrDel: ", err) } } golang-github-jsimonetti-rtnetlink-1.4.1/rtnl/addr_test.go000066400000000000000000000027531455442221600237320ustar00rootroot00000000000000package rtnl import ( "net" "testing" ) func TestParseAddrs(t *testing.T) { tests := []struct { name string ipstr string ipnet net.IPNet err string }{ { name: "ipv6 subnet address", ipstr: "ff00::/64", err: "address ff00::: attempted to parse a subnet address into a host address", }, { name: "ipv4 subnet address", ipstr: "10.0.0.0/8", err: "address 10.0.0.0: attempted to parse a subnet address into a host address", }, { name: "ipv6 host address", ipstr: "ff00::1/64", ipnet: net.IPNet{ IP: net.IP{0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x1}, Mask: net.IPMask{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, }, }, { name: "ipv4 host address", ipstr: "10.0.0.1/8", ipnet: net.IPNet{ IP: net.IP{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0xff, 0xff, 0xa, 0x0, 0x0, 0x1}, Mask: net.IPMask{0xff, 0x0, 0x0, 0x0}, }, }, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { res, err := ParseAddr(tt.ipstr) if err != nil { if want, got := tt.err, err.Error(); want != got { t.Fatalf("unexpected error:\n- want: %v\n- got: %v", want, got) } return } if tt.err != "" { t.Fatalf("expected error:\n %s\nbut got nothing.. :(", tt.err) } if want, got := tt.ipnet, res; !want.IP.Equal(got.IP) { t.Fatalf("unexpected IP:\n- want: %+#v\n- got: %+#v", want, got) } }) } } golang-github-jsimonetti-rtnetlink-1.4.1/rtnl/conn.go000066400000000000000000000014231455442221600227070ustar00rootroot00000000000000// Package rtnl provides a convenient API on top of the rtnetlink library. package rtnl import ( "github.com/jsimonetti/rtnetlink" "github.com/mdlayher/netlink" ) // Conn represents the underlying netlink connection type Conn struct { Conn *rtnetlink.Conn // a route netlink connection } // Dial the netlink socket. Establishes a new connection. The typical initialisation is: // // conn, err := rtnl.Dial(nil) // if err != nil { // log.Fatal("can't establish netlink connection: ", err) // } // defer conn.Close() // // use conn for your calls func Dial(cfg *netlink.Config) (*Conn, error) { conn, err := rtnetlink.Dial(cfg) if err != nil { return nil, err } return &Conn{Conn: conn}, nil } // Close the connection. func (c *Conn) Close() error { return c.Conn.Close() } golang-github-jsimonetti-rtnetlink-1.4.1/rtnl/link.go000066400000000000000000000054651455442221600227210ustar00rootroot00000000000000package rtnl import ( "net" "github.com/jsimonetti/rtnetlink/internal/unix" "github.com/jsimonetti/rtnetlink" ) // Links return the list of interfaces available on the system. func (c *Conn) Links() (r []*net.Interface, err error) { rx, err := c.Conn.Link.List() if err != nil { return nil, err } for _, m := range rx { ifc := linkmsgToInterface(&m) r = append(r, ifc) } return r, nil } // LinkByIndex returns an interface by its index. Similar to net.InterfaceByIndex. func (c *Conn) LinkByIndex(ifindex int) (*net.Interface, error) { rx, err := c.Conn.Link.Get(uint32(ifindex)) if err != nil { return nil, err } return linkmsgToInterface(&rx), nil } func linkmsgToInterface(m *rtnetlink.LinkMessage) *net.Interface { ifc := &net.Interface{ Index: int(m.Index), MTU: int(m.Attributes.MTU), Name: m.Attributes.Name, HardwareAddr: m.Attributes.Address, Flags: linkFlags(m.Flags), } return ifc } func linkFlags(rawFlags uint32) net.Flags { var f net.Flags if rawFlags&unix.IFF_UP != 0 { f |= net.FlagUp } if rawFlags&unix.IFF_BROADCAST != 0 { f |= net.FlagBroadcast } if rawFlags&unix.IFF_LOOPBACK != 0 { f |= net.FlagLoopback } if rawFlags&unix.IFF_POINTOPOINT != 0 { f |= net.FlagPointToPoint } if rawFlags&unix.IFF_MULTICAST != 0 { f |= net.FlagMulticast } return f } // LinkSetHardwareAddr overrides the L2 address (MAC-address) for the interface. func (c *Conn) LinkSetHardwareAddr(ifc *net.Interface, hw net.HardwareAddr) error { rx, err := c.Conn.Link.Get(uint32(ifc.Index)) if err != nil { return err } tx := &rtnetlink.LinkMessage{ Family: unix.AF_UNSPEC, Type: rx.Type, Index: uint32(ifc.Index), Flags: rx.Flags, Change: 0, // rtnetlink(7) says it "should be always set to 0xFFFFFFFF" - BUG? Attributes: &rtnetlink.LinkAttributes{ Address: hw, // some attributes are always included in ../link.go:/LinkAttributes/+/MarshalBinary/ Name: rx.Attributes.Name, MTU: rx.Attributes.MTU, Type: rx.Attributes.Type, QueueDisc: rx.Attributes.QueueDisc, }, } return c.Conn.Link.Set(tx) } // LinkUp drives an inteface up, enabling the link. func (c *Conn) LinkUp(ifc *net.Interface) error { rx, err := c.Conn.Link.Get(uint32(ifc.Index)) if err != nil { return err } tx := &rtnetlink.LinkMessage{ Family: unix.AF_UNSPEC, Type: rx.Type, Index: uint32(ifc.Index), Flags: unix.IFF_UP, Change: unix.IFF_UP, } return c.Conn.Link.Set(tx) } // LinkDown takes an inteface down, disabling the link. func (c *Conn) LinkDown(ifc *net.Interface) error { rx, err := c.Conn.Link.Get(uint32(ifc.Index)) if err != nil { return err } tx := &rtnetlink.LinkMessage{ Family: unix.AF_UNSPEC, Type: rx.Type, Index: uint32(ifc.Index), Flags: 0, Change: unix.IFF_UP, } return c.Conn.Link.Set(tx) } golang-github-jsimonetti-rtnetlink-1.4.1/rtnl/links_live_test.go000066400000000000000000000040141455442221600251470ustar00rootroot00000000000000//go:build integration // +build integration package rtnl import ( "bytes" "net" "strconv" "testing" ) const ( hardwareAddrLen = 6 ) var hardwareAddrZero = net.HardwareAddr{0, 0, 0, 0, 0, 0} func hardwareAddrEqual(a, b net.HardwareAddr) bool { return bytes.Equal(a, b) } func hardwareAddrIsUnspecified(hw net.HardwareAddr) bool { return len(hw) != hardwareAddrLen || hardwareAddrEqual(hw, hardwareAddrZero) } // TestLinks tests the Live function returns sane results func TestLiveLinks(t *testing.T) { c, err := Dial(nil) if err != nil { t.Fatal(err) } defer c.Close() links, err := c.Links() if err != nil { t.Fatal(err) } if len(links) == 0 { t.Skip("no network interfaces") } ieth := 0 ilo := 0 for i, ifc := range links { t.Logf("* entry %d: %#v", i, ifc) if ifc.Index == 0 { t.Error("zero ifc.Index") } if ifc.MTU == 0 { t.Error("zero ifc.MTU") } if len(ifc.Name) == 0 { t.Error("zero-length ifc.Name") } if !hardwareAddrIsUnspecified(ifc.HardwareAddr) { ieth = ifc.Index } if ifc.Flags&net.FlagLoopback != 0 { ilo = ifc.Index } } if ieth == 0 { t.Skip("no interfaces with non-zero link-level address") } if ilo == 0 { t.Skip("no loopback interfaces") } t.Run("LinkByIndex", func(t *testing.T) { for i, ifindex := range []int{ilo, ieth} { t.Run(strconv.Itoa(i), func(t *testing.T) { ifc, err := c.LinkByIndex(ifindex) if err != nil { t.Fatal(err) } t.Logf("* %#v", ifc) if ifc.Index == 0 { t.Error("zero ifc.Index") } if ifc.Index != ifindex { t.Errorf("returned wronk interface (%d != %d)", ifc.Index, ifindex) } if ifc.MTU == 0 { t.Error("zero ifc.MTU") } if len(ifc.Name) == 0 { t.Error("zero-length ifc.Name") } if ifindex == ieth && hardwareAddrIsUnspecified(ifc.HardwareAddr) { t.Error("zero ifc.HardwareAddr, expected non-zero") } if ifindex == ilo && ifc.Flags&net.FlagLoopback == 0 { t.Error("no FlagLoopback in ifc.Flags, expected to be set") } }) } }) } golang-github-jsimonetti-rtnetlink-1.4.1/rtnl/neigh.go000066400000000000000000000023171455442221600230470ustar00rootroot00000000000000package rtnl import ( "net" "github.com/jsimonetti/rtnetlink" ) // Neigh represents a neighbour table entry (e.g. an entry in the ARP table) type Neigh struct { HwAddr net.HardwareAddr // Link-layer address IP net.IP // Network-layer address Interface *net.Interface // Network interface } // Neighbours lists entries from the neighbor table (e.g. the ARP table). func (c *Conn) Neighbours(ifc *net.Interface, family int) (r []*Neigh, err error) { rx, err := c.Conn.Neigh.List() if err != nil { return nil, err } match := func(v *rtnetlink.NeighMessage, ifc *net.Interface, family int) bool { if ifc != nil && v.Index != uint32(ifc.Index) { return false } if family != 0 && v.Family != uint16(family) { return false } return true } ifcache := map[int]*net.Interface{} for _, m := range rx { if !match(&m, ifc, family) { continue } ifindex := int(m.Index) iface, ok := ifcache[ifindex] if !ok { iface, err = c.LinkByIndex(ifindex) if err != nil { return nil, err } ifcache[ifindex] = iface } p := &Neigh{ HwAddr: m.Attributes.LLAddress, IP: m.Attributes.Address, Interface: iface, } r = append(r, p) } return r, nil } golang-github-jsimonetti-rtnetlink-1.4.1/rtnl/neigh_live_test.go000066400000000000000000000023041455442221600251210ustar00rootroot00000000000000//go:build integration // +build integration package rtnl import ( "net" "testing" ) func TestLiveNeighbours(t *testing.T) { c, err := Dial(nil) if err != nil { t.Fatal(err) } defer c.Close() // Trigger a DNS lookup, only for a side effect of pushing our gateway or NS onto the neighbour table net.LookupHost("github.com") neigtab, err := c.Neighbours(nil, 0) if err != nil { t.Fatal(err) } if len(neigtab) == 0 { t.Skip("no neighbours") } for i, e := range neigtab { t.Logf("* neighbour table entry [%d]: %v", i, e) if e.IP.IsUnspecified() { // This test doesn't seem to be very reliable // Disabling for now // t.Error("zero e.IP, expected non-zero") continue } if e.Interface == nil { t.Error("nil e.Interface, expected non-nil") continue } if len(e.Interface.Name) == 0 { t.Error("zero-length e.Interface.Name") } if e.IP.IsLoopback() { continue } if hardwareAddrIsUnspecified(e.HwAddr) { // This test doesn't seem to be very reliable // Disabling for now // t.Error("zero e.HwAddr, expected non-zero") } if hardwareAddrIsUnspecified(e.Interface.HardwareAddr) { t.Error("zero e.Interface.HardwareAddr, expected non-zero") } } } golang-github-jsimonetti-rtnetlink-1.4.1/rtnl/route.go000066400000000000000000000072311455442221600231130ustar00rootroot00000000000000package rtnl import ( "errors" "fmt" "net" "github.com/jsimonetti/rtnetlink/internal/unix" "github.com/jsimonetti/rtnetlink" ) // Route represents a route table entry type Route struct { Destination *net.IPNet Gateway net.IP Interface *net.Interface Metric uint32 } // generating route message func genRouteMessage(ifc *net.Interface, dst net.IPNet, gw net.IP, options ...RouteOption) (rm *rtnetlink.RouteMessage, err error) { opts := DefaultRouteOptions(ifc, dst, gw) for _, option := range options { option(opts) } af, err := addrFamily(dst.IP) if err != nil { return nil, err } // Determine scope var scope uint8 switch { case gw != nil: scope = unix.RT_SCOPE_UNIVERSE case len(dst.IP) == net.IPv6len && dst.IP.To4() == nil: scope = unix.RT_SCOPE_UNIVERSE default: // Set default scope to LINK scope = unix.RT_SCOPE_LINK } var srclen int if opts.Src != nil { srclen, _ = opts.Src.Mask.Size() opts.Attrs.Src = opts.Src.IP } dstlen, _ := dst.Mask.Size() tx := &rtnetlink.RouteMessage{ Family: uint8(af), Table: unix.RT_TABLE_MAIN, Protocol: unix.RTPROT_BOOT, Type: unix.RTN_UNICAST, Scope: scope, DstLength: uint8(dstlen), SrcLength: uint8(srclen), Attributes: opts.Attrs, } return tx, nil } // RouteAdd adds information about a network route. func (c *Conn) RouteAdd(ifc *net.Interface, dst net.IPNet, gw net.IP, options ...RouteOption) (err error) { rm, err := genRouteMessage(ifc, dst, gw, options...) if err != nil { return err } return c.Conn.Route.Add(rm) } // RouteReplace adds or replace information about a network route. func (c *Conn) RouteReplace(ifc *net.Interface, dst net.IPNet, gw net.IP, options ...RouteOption) (err error) { rm, err := genRouteMessage(ifc, dst, gw, options...) if err != nil { return err } return c.Conn.Route.Replace(rm) } // RouteDel deletes the route to the given destination. func (c *Conn) RouteDel(ifc *net.Interface, dst net.IPNet) error { af, err := addrFamily(dst.IP) if err != nil { return err } prefixlen, _ := dst.Mask.Size() attr := rtnetlink.RouteAttributes{ Dst: dst.IP, OutIface: uint32(ifc.Index), } tx := &rtnetlink.RouteMessage{ Family: uint8(af), Table: unix.RT_TABLE_MAIN, DstLength: uint8(prefixlen), Attributes: attr, } return c.Conn.Route.Delete(tx) } // RouteGet gets a single route to the given destination address. func (c *Conn) RouteGet(dst net.IP) (*Route, error) { list, err := c.RouteGetAll(dst) if err != nil { return nil, err } if len(list) == 0 { return nil, errors.New("route wrong length") } return list[0], nil } // RouteGetAll returns all routes to the given destination IP in the main routing table. func (c *Conn) RouteGetAll(dst net.IP) (ret []*Route, err error) { af, err := addrFamily(dst) if err != nil { return nil, err } attr := rtnetlink.RouteAttributes{ Dst: dst, } tx := &rtnetlink.RouteMessage{ Family: uint8(af), Table: unix.RT_TABLE_MAIN, Attributes: attr, } rx, err := c.Conn.Route.Get(tx) if err != nil { return nil, err } for _, rt := range rx { ifindex := int(rt.Attributes.OutIface) iface, err := c.LinkByIndex(ifindex) if err != nil { return nil, fmt.Errorf("failed to get link by interface index: %w", err) } _, dstNet, err := net.ParseCIDR(fmt.Sprintf("%s/%d", rt.Attributes.Dst.String(), rt.DstLength)) if err != nil { return nil, fmt.Errorf("failed to construct CIDR from route destination address and length: %w", err) } ret = append(ret, &Route{ Destination: dstNet, Gateway: rt.Attributes.Gateway, Interface: iface, Metric: rt.Attributes.Priority, }) } return ret, nil } golang-github-jsimonetti-rtnetlink-1.4.1/rtnl/route_live_test.go000066400000000000000000000014271455442221600251720ustar00rootroot00000000000000//go:build integration // +build integration package rtnl import ( "net" "testing" ) func TestLiveRoute(t *testing.T) { c, err := Dial(nil) if err != nil { t.Fatal(err) } defer c.Close() route, err := c.RouteGet(net.ParseIP("8.8.8.8")) if err != nil { t.Fatal(err) } t.Logf("got route: %v", route) if route.Gateway.IsUnspecified() { t.Error("zero route.Gateway, expected non-zero") } if route.Gateway.IsLoopback() { t.Error("lo route.Gatway, expected non lo") } if route.Interface == nil { t.Error("nil route.Interface, expected non-nil") } if len(route.Interface.Name) == 0 { t.Error("zero-length route.Interface.Name") } if hardwareAddrIsUnspecified(route.Interface.HardwareAddr) { t.Error("zero route.Interface.HardwareAddr, expected non-zero") } } golang-github-jsimonetti-rtnetlink-1.4.1/rtnl/route_options.go000066400000000000000000000016411455442221600246650ustar00rootroot00000000000000package rtnl import ( "net" "github.com/jsimonetti/rtnetlink" ) // RouteOptions is the functional options struct type RouteOptions struct { Src *net.IPNet Attrs rtnetlink.RouteAttributes } // RouteOption is the functional options func type RouteOption func(*RouteOptions) // DefaultRouteOptions defines the default route options. func DefaultRouteOptions(ifc *net.Interface, dst net.IPNet, gw net.IP) *RouteOptions { ro := &RouteOptions{ Src: nil, Attrs: rtnetlink.RouteAttributes{ Dst: dst.IP, OutIface: uint32(ifc.Index), }, } if gw != nil { ro.Attrs.Gateway = gw } return ro } // WithRouteSrc sets the src address. func WithRouteSrc(src *net.IPNet) RouteOption { return func(opts *RouteOptions) { opts.Src = src } } // WithRouteAttrs sets the attributes. func WithRouteAttrs(attrs rtnetlink.RouteAttributes) RouteOption { return func(opts *RouteOptions) { opts.Attrs = attrs } } golang-github-jsimonetti-rtnetlink-1.4.1/rule.go000066400000000000000000000213741455442221600217510ustar00rootroot00000000000000package rtnetlink import ( "bytes" "encoding/binary" "errors" "net" "github.com/jsimonetti/rtnetlink/internal/unix" "github.com/mdlayher/netlink" ) var ( // errInvalidRuleMessage is returned when a RuleMessage is malformed. errInvalidRuleMessage = errors.New("rtnetlink RuleMessage is invalid or too short") // errInvalidRuleAttribute is returned when a RuleMessage contains an unknown attribute. errInvalidRuleAttribute = errors.New("rtnetlink RuleMessage contains an unknown Attribute") ) var _ Message = &RuleMessage{} // A RuleMessage is a route netlink link message. type RuleMessage struct { // Address family Family uint8 // Length of destination prefix DstLength uint8 // Length of source prefix SrcLength uint8 // Rule TOS TOS uint8 // Routing table identifier Table uint8 // Rule action Action uint8 // Rule flags Flags uint32 // Attributes List Attributes *RuleAttributes } // MarshalBinary marshals a LinkMessage into a byte slice. func (m *RuleMessage) MarshalBinary() ([]byte, error) { b := make([]byte, 12) // fib_rule_hdr b[0] = m.Family b[1] = m.DstLength b[2] = m.SrcLength b[3] = m.TOS b[4] = m.Table b[7] = m.Action nativeEndian.PutUint32(b[8:12], m.Flags) if m.Attributes != nil { ae := netlink.NewAttributeEncoder() ae.ByteOrder = nativeEndian err := m.Attributes.encode(ae) if err != nil { return nil, err } a, err := ae.Encode() if err != nil { return nil, err } return append(b, a...), nil } return b, nil } // UnmarshalBinary unmarshals the contents of a byte slice into a LinkMessage. func (m *RuleMessage) UnmarshalBinary(b []byte) error { l := len(b) if l < 12 { return errInvalidRuleMessage } m.Family = b[0] m.DstLength = b[1] m.SrcLength = b[2] m.TOS = b[3] m.Table = b[4] // b[5] and b[6] are reserved fields m.Action = b[7] m.Flags = nativeEndian.Uint32(b[8:12]) if l > 12 { m.Attributes = &RuleAttributes{} ad, err := netlink.NewAttributeDecoder(b[12:]) if err != nil { return err } ad.ByteOrder = nativeEndian return m.Attributes.decode(ad) } return nil } // rtMessage is an empty method to sattisfy the Message interface. func (*RuleMessage) rtMessage() {} // RuleService is used to retrieve rtnetlink family information. type RuleService struct { c *Conn } func (r *RuleService) execute(m Message, family uint16, flags netlink.HeaderFlags) ([]RuleMessage, error) { msgs, err := r.c.Execute(m, family, flags) rules := make([]RuleMessage, len(msgs)) for i := range msgs { rules[i] = *msgs[i].(*RuleMessage) } return rules, err } // Add new rule func (r *RuleService) Add(req *RuleMessage) error { flags := netlink.Request | netlink.Create | netlink.Acknowledge | netlink.Excl _, err := r.c.Execute(req, unix.RTM_NEWRULE, flags) return err } // Replace or add new rule func (r *RuleService) Replace(req *RuleMessage) error { flags := netlink.Request | netlink.Create | netlink.Replace | netlink.Acknowledge _, err := r.c.Execute(req, unix.RTM_NEWRULE, flags) return err } // Delete existing rule func (r *RuleService) Delete(req *RuleMessage) error { flags := netlink.Request | netlink.Acknowledge _, err := r.c.Execute(req, unix.RTM_DELRULE, flags) return err } // Get Rule(s) func (r *RuleService) Get(req *RuleMessage) ([]RuleMessage, error) { flags := netlink.Request | netlink.DumpFiltered return r.execute(req, unix.RTM_GETRULE, flags) } // List all rules func (r *RuleService) List() ([]RuleMessage, error) { flags := netlink.Request | netlink.Dump return r.execute(&RuleMessage{}, unix.RTM_GETRULE, flags) } // RuleAttributes contains all attributes for a rule. type RuleAttributes struct { Src, Dst *net.IP IIFName, OIFName *string Goto *uint32 Priority *uint32 FwMark, FwMask *uint32 SrcRealm *uint16 DstRealm *uint16 TunID *uint64 Table *uint32 L3MDev *uint8 Protocol *uint8 IPProto *uint8 SuppressPrefixLen *uint32 SuppressIFGroup *uint32 UIDRange *RuleUIDRange SPortRange *RulePortRange DPortRange *RulePortRange } // unmarshalBinary unmarshals the contents of a byte slice into a RuleMessage. func (r *RuleAttributes) decode(ad *netlink.AttributeDecoder) error { for ad.Next() { switch ad.Type() { case unix.FRA_UNSPEC: // unused continue case unix.FRA_DST: r.Dst = &net.IP{} ad.Do(decodeIP(r.Dst)) case unix.FRA_SRC: r.Src = &net.IP{} ad.Do(decodeIP(r.Src)) case unix.FRA_IIFNAME: v := ad.String() r.IIFName = &v case unix.FRA_GOTO: v := ad.Uint32() r.Goto = &v case unix.FRA_UNUSED2: // unused continue case unix.FRA_PRIORITY: v := ad.Uint32() r.Priority = &v case unix.FRA_UNUSED3: // unused continue case unix.FRA_UNUSED4: // unused continue case unix.FRA_UNUSED5: // unused continue case unix.FRA_FWMARK: v := ad.Uint32() r.FwMark = &v case unix.FRA_FLOW: dst32 := ad.Uint32() src32 := uint32(dst32 >> 16) src32 &= 0xFFFF dst32 &= 0xFFFF src16 := uint16(src32) dst16 := uint16(dst32) r.SrcRealm = &src16 r.DstRealm = &dst16 case unix.FRA_TUN_ID: v := ad.Uint64() r.TunID = &v case unix.FRA_SUPPRESS_IFGROUP: v := ad.Uint32() r.SuppressIFGroup = &v case unix.FRA_SUPPRESS_PREFIXLEN: v := ad.Uint32() r.SuppressPrefixLen = &v case unix.FRA_TABLE: v := ad.Uint32() r.Table = &v case unix.FRA_FWMASK: v := ad.Uint32() r.FwMask = &v case unix.FRA_OIFNAME: v := ad.String() r.OIFName = &v case unix.FRA_PAD: // unused continue case unix.FRA_L3MDEV: v := ad.Uint8() r.L3MDev = &v case unix.FRA_UID_RANGE: r.UIDRange = &RuleUIDRange{} err := r.UIDRange.unmarshalBinary(ad.Bytes()) if err != nil { return err } case unix.FRA_PROTOCOL: v := ad.Uint8() r.Protocol = &v case unix.FRA_IP_PROTO: v := ad.Uint8() r.IPProto = &v case unix.FRA_SPORT_RANGE: r.SPortRange = &RulePortRange{} err := r.SPortRange.unmarshalBinary(ad.Bytes()) if err != nil { return err } case unix.FRA_DPORT_RANGE: r.DPortRange = &RulePortRange{} err := r.DPortRange.unmarshalBinary(ad.Bytes()) if err != nil { return err } default: return errInvalidRuleAttribute } } return ad.Err() } // MarshalBinary marshals a RuleAttributes into a byte slice. func (r *RuleAttributes) encode(ae *netlink.AttributeEncoder) error { if r.Table != nil { ae.Uint32(unix.FRA_TABLE, *r.Table) } if r.Protocol != nil { ae.Uint8(unix.FRA_PROTOCOL, *r.Protocol) } if r.Src != nil { ae.Do(unix.FRA_SRC, encodeIP(*r.Src)) } if r.Dst != nil { ae.Do(unix.FRA_DST, encodeIP(*r.Dst)) } if r.IIFName != nil { ae.String(unix.FRA_IIFNAME, *r.IIFName) } if r.OIFName != nil { ae.String(unix.FRA_OIFNAME, *r.OIFName) } if r.Goto != nil { ae.Uint32(unix.FRA_GOTO, *r.Goto) } if r.Priority != nil { ae.Uint32(unix.FRA_PRIORITY, *r.Priority) } if r.FwMark != nil { ae.Uint32(unix.FRA_FWMARK, *r.FwMark) } if r.FwMask != nil { ae.Uint32(unix.FRA_FWMASK, *r.FwMask) } if r.DstRealm != nil { value := uint32(*r.DstRealm) if r.SrcRealm != nil { value |= (uint32(*r.SrcRealm&0xFFFF) << 16) } ae.Uint32(unix.FRA_FLOW, value) } if r.TunID != nil { ae.Uint64(unix.FRA_TUN_ID, *r.TunID) } if r.L3MDev != nil { ae.Uint8(unix.FRA_L3MDEV, *r.L3MDev) } if r.IPProto != nil { ae.Uint8(unix.FRA_IP_PROTO, *r.IPProto) } if r.SuppressIFGroup != nil { ae.Uint32(unix.FRA_SUPPRESS_IFGROUP, *r.SuppressIFGroup) } if r.SuppressPrefixLen != nil { ae.Uint32(unix.FRA_SUPPRESS_PREFIXLEN, *r.SuppressPrefixLen) } if r.UIDRange != nil { data, err := marshalRuleUIDRange(*r.UIDRange) if err != nil { return err } ae.Bytes(unix.FRA_UID_RANGE, data) } if r.SPortRange != nil { data, err := marshalRulePortRange(*r.SPortRange) if err != nil { return err } ae.Bytes(unix.FRA_SPORT_RANGE, data) } if r.DPortRange != nil { data, err := marshalRulePortRange(*r.DPortRange) if err != nil { return err } ae.Bytes(unix.FRA_DPORT_RANGE, data) } return nil } // RulePortRange defines start and end ports for a rule type RulePortRange struct { Start, End uint16 } func (r *RulePortRange) unmarshalBinary(data []byte) error { b := bytes.NewReader(data) return binary.Read(b, nativeEndian, r) } func marshalRulePortRange(s RulePortRange) ([]byte, error) { var buf bytes.Buffer err := binary.Write(&buf, nativeEndian, s) return buf.Bytes(), err } // RuleUIDRange defines the start and end for UID matches type RuleUIDRange struct { Start, End uint16 } func (r *RuleUIDRange) unmarshalBinary(data []byte) error { b := bytes.NewReader(data) return binary.Read(b, nativeEndian, r) } func marshalRuleUIDRange(s RuleUIDRange) ([]byte, error) { var buf bytes.Buffer err := binary.Write(&buf, nativeEndian, s) return buf.Bytes(), err } golang-github-jsimonetti-rtnetlink-1.4.1/rule_test.go000066400000000000000000000131061455442221600230020ustar00rootroot00000000000000package rtnetlink import ( "bytes" "errors" "net" "reflect" "testing" ) func TestRuleMessage(t *testing.T) { skipBigEndian(t) tests := map[string]struct { m Message b []byte marshalErr error unmarshalErr error }{ "empty": { m: &RuleMessage{}, b: []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, }, "no attributes": { m: &RuleMessage{ Family: 1, DstLength: 2, SrcLength: 3, TOS: 4, Table: 5, Action: 6, Flags: 7, }, b: []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x00, 0x00, 0x06, 0x07, 0x00, 0x00, 0x00}, }, "with attributes": { m: &RuleMessage{ Family: 7, DstLength: 6, SrcLength: 5, TOS: 4, Table: 3, Action: 2, Flags: 1, Attributes: &RuleAttributes{ Src: netIPPtr(net.ParseIP("8.8.8.8")), Dst: netIPPtr(net.ParseIP("1.1.1.1")), IIFName: strPtr("eth0"), OIFName: strPtr("br0"), Goto: uint32Ptr(1), Priority: uint32Ptr(2), FwMark: uint32Ptr(3), FwMask: uint32Ptr(5), L3MDev: uint8Ptr(7), DstRealm: uint16Ptr(11), SrcRealm: uint16Ptr(13), TunID: uint64Ptr(17), Protocol: uint8Ptr(19), IPProto: uint8Ptr(23), Table: uint32Ptr(29), SuppressPrefixLen: uint32Ptr(31), SuppressIFGroup: uint32Ptr(37), UIDRange: &RuleUIDRange{ Start: 22, End: 25, }, SPortRange: &RulePortRange{ Start: 23, End: 26, }, DPortRange: &RulePortRange{ Start: 24, End: 27, }, }, }, b: []byte{ 0x07, 0x06, 0x05, 0x04, 0x03, 0x00, 0x00, 0x02, 0x01, 0x00, 0x00, 0x00, 0x08, 0x00, 0x0f, 0x00, 0x1d, 0x00, 0x00, 0x00, 0x05, 0x00, 0x15, 0x00, 0x13, 0x00, 0x00, 0x00, 0x08, 0x00, 0x02, 0x00, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x01, 0x00, 0x01, 0x01, 0x01, 0x01, 0x09, 0x00, 0x03, 0x00, 0x65, 0x74, 0x68, 0x30, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x11, 0x00, 0x62, 0x72, 0x30, 0x00, 0x08, 0x00, 0x04, 0x00, 0x01, 0x00, 0x00, 0x00, 0x08, 0x00, 0x06, 0x00, 0x02, 0x00, 0x00, 0x00, 0x08, 0x00, 0x0a, 0x00, 0x03, 0x00, 0x00, 0x00, 0x08, 0x00, 0x10, 0x00, 0x05, 0x00, 0x00, 0x00, 0x08, 0x00, 0x0b, 0x00, 0x0b, 0x00, 0x0d, 0x00, 0x0c, 0x00, 0x0c, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x13, 0x00, 0x07, 0x00, 0x00, 0x00, 0x05, 0x00, 0x16, 0x00, 0x17, 0x00, 0x00, 0x00, 0x08, 0x00, 0x0d, 0x00, 0x25, 0x00, 0x00, 0x00, 0x08, 0x00, 0x0e, 0x00, 0x1f, 0x00, 0x00, 0x00, 0x08, 0x00, 0x14, 0x00, 0x16, 0x00, 0x19, 0x00, 0x08, 0x00, 0x17, 0x00, 0x17, 0x00, 0x1a, 0x00, 0x08, 0x00, 0x18, 0x00, 0x18, 0x00, 0x1b, 0x00, }, }, } for name, tt := range tests { t.Run(name, func(t *testing.T) { var b []byte t.Run("marshal", func(t *testing.T) { var marshalErr error b, marshalErr = tt.m.MarshalBinary() if !errors.Is(marshalErr, tt.marshalErr) { t.Fatalf("Expected error '%v' but got '%v'", tt.marshalErr, marshalErr) } }) t.Run("compare bytes", func(t *testing.T) { if want, got := tt.b, b; !bytes.Equal(want, got) { t.Fatalf("unexpected Message bytes:\n- want: [%# x]\n- got: [%# x]", want, got) } }) m := &RuleMessage{} t.Run("unmarshal", func(t *testing.T) { unmarshalErr := (m).UnmarshalBinary(b) if !errors.Is(unmarshalErr, tt.unmarshalErr) { t.Fatalf("Expected error '%v' but got '%v'", tt.unmarshalErr, unmarshalErr) } }) t.Run("compare messages", func(t *testing.T) { if !reflect.DeepEqual(tt.m, m) { t.Fatalf("unexpected Message:\n- want: %#v\n- got: %#v", tt.m, m) } }) }) } t.Run("invalid length", func(t *testing.T) { m := &RuleMessage{} unmarshalErr := (m).UnmarshalBinary([]byte{0x00, 0x01, 0x2, 0x03}) if !errors.Is(unmarshalErr, errInvalidRuleMessage) { t.Fatalf("Expected 'errInvalidRuleMessage' but got '%v'", unmarshalErr) } }) t.Run("skipped attributes", func(t *testing.T) { m := &RuleMessage{} unmarshalErr := (m).UnmarshalBinary([]byte{ 0x01, 0x00, 0x00, 0x02, 0x03, 0x00, 0x00, 0x04, 0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x05, 0x00, 0x04, 0x00, 0x07, 0x00, 0x04, 0x00, 0x08, 0x00, 0x04, 0x00, 0x09, 0x00, 0x04, 0x00, 0x12, 0x00, }) if !errors.Is(unmarshalErr, nil) { t.Fatalf("Expected no error but got '%v'", unmarshalErr) } expected := &RuleMessage{ Family: 1, TOS: 2, Table: 3, Action: 4, Flags: 5, Attributes: &RuleAttributes{}, } if !reflect.DeepEqual(expected, m) { t.Fatalf("unexpected Message:\n- want: %#v\n- got: %#v", expected, m) } }) t.Run("invalid attribute", func(t *testing.T) { m := &RuleMessage{} unmarshalErr := (m).UnmarshalBinary([]byte{ 0x01, 0x00, 0x00, 0x02, 0x03, 0x00, 0x00, 0x04, 0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x2a, 0x00, }) if !errors.Is(unmarshalErr, errInvalidRuleAttribute) { t.Fatalf("Expected 'errInvalidRuleAttribute' error but got '%v'", unmarshalErr) } }) } func uint64Ptr(v uint64) *uint64 { return &v } func uint32Ptr(v uint32) *uint32 { return &v } func uint16Ptr(v uint16) *uint16 { return &v } func uint8Ptr(v uint8) *uint8 { return &v } func netIPPtr(v net.IP) *net.IP { if ip4 := v.To4(); ip4 != nil { // By default net.IP returns the 16 byte representation. // But netlink requires us to provide only four bytes // for legacy IPs. return &ip4 } return &v } func strPtr(v string) *string { return &v } golang-github-jsimonetti-rtnetlink-1.4.1/testdata/000077500000000000000000000000001455442221600222555ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/000077500000000000000000000000001455442221600232535ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessage/000077500000000000000000000000001455442221600270245ustar00rootroot0000000000000003197537f1d80d5ea34e9b96031694042cf03ea0-16000066400000000000000000000005011455442221600342410ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing\x04\x00\x04\x00\x04i\x00\x00\x00\u007f\x04\x00\x00\u007f\x04\x00\x04\u007f\x04\x00\x04i\x00\x00\x00\u007f\x04\x00\x00\u007f\x04\x00\x00d\x00\x00\x00\x1e\x00\x00d\x00\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x80\x00\x00\x00\x80i\x00\x00\x00d\x00\x00\x00\x1e\x00\x00\x10\x00\x00\x00bad ve")040d4c058f957c7c46392714ba3c37f8df605910-5000066400000000000000000000003701455442221600342010ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("s\x00\x00ing\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\x02\x00\x01\x00\x04\x00\x00\x00\x00\x00\x02\x00\x01\x00\x03\x00\x01\x00\x02\xef\x01\x00\x02\x00\x01\x00\x03\xbf\xfb\x93}B")07917bf9ce973c087e09e0c65cee6a9b3488dbb9-6000066400000000000000000000005311455442221600346070ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\x00\x00\x03\x80\x00\x00\x00\x00\x00\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\x02\x00\x01\x00\x04\x00\x00\x00\x00\x00\x02\x00\x01\x00\x03\x00\x01\x00\x02\xef\x01\x00\x02\x00\x01\x00\x03\xbf\x03\x00\x01\x00\x02\x00\x01\x00\x04\x00\x00\x00\x00\x00\x02\x00\x01\x00\x03\x00\x01\x00\x02\xef\x01\x00\xfb\x93}")0ca52f9d57f8a1c240bfbb5687d7cb73fecd2017-10000066400000000000000000000003051455442221600347620ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("s\x00\x00ing\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x04\x00\x00\x00\x00\x00d\x00\x00\x00\x00\x80\xc8h\x00@")0ebf70dc98b04ebe1ac65db1a110fcf453da46ed-2000066400000000000000000000001061455442221600350760ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("\x14\x01\x00\x01p\x13a\x14\x02\x00\bc\xa1K߫")106930161272d1a659e4bfed0ba011dc1880d96d-15000066400000000000000000000003411455442221600343660ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\b\x00ng3\x95\b\x00\b\x00ng6\x95\b\x00\b\x00ng3\x95\b\x00\b\x00ng3\x95\b\x00\b\x00ng6\x95\b\x00\b\x00ng@\x95\b\x00\b\x00\x00\x00\x00\x95\b\x00\b\x00ng@\x95\b\x00\b\x00\x04\x00\b\u007f\x04\x00\b\x00")114b01dea00a7d222eb38a532f486b5ecfe1d1d9-6000066400000000000000000000002001455442221600345710ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing\x04\x00\x04\x00@\x95\x00\x00\x04i\x00\x00\x00\u007f\x04\x00\x00\u007f\x04\x00\x04\x04_\x9c/)")1696a08860d1da58b24d0be098fa9b2ed791e137-15000066400000000000000000000002601455442221600344760ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("\b\x00\b\x00ng6\x95\x14\x00\x06@\x95\x95\b\x00\b\x00ng\b\x00\b\x00ng6\x95\x14\x00\x06\x00\b\x00\b\x00ng@\x95\b\x00\b\x00\x04\x00\b\u007f\x04\x00\b\x00")170d92bab090512441dee91cd18303090a500610-10000066400000000000000000000002021455442221600341110ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\x00\x00\x03\x80\x00\x00\x04i\x00\x00\x80\x80\x00\x00\x80i\x00\x00\x80\x80\x00\x00\x02\x00")1851ba010e3ad79290aeb291ff65e3c54c6825e8-11000066400000000000000000000001251455442221600344630ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\x00\x00\x03\x80\x00\x00\x03\x80\x00\x04i\x00")18898d583b9037246600e4a5199febbc97ca9140-5000066400000000000000000000001251455442221600342120ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ingX\x95\x00\x00\x04i\x00\x00\x10\x00\x00\x00\x04\x00")199c834a15965ba27bbe7b0aa0f57f185ab6d532-17000066400000000000000000000001771455442221600345560ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("\b\x00\a\x00ng@\x95\x14\x00\x01\x00\x00\x00\x00\x00\x00\u007f\x04\x00\x00\x00\x00\x00\u007f\x04\x00\b")19fbb82983f94e9ff7e60da279232a70e2d895de-5000066400000000000000000000001501455442221600345260ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing\x00\x00\x04\x00\x80i\x00\x00\x00\x80\x00\x00\x02\x00\x04\xff\xf4\x00")1d65e6ca16802ed2dc662a57362bc95698dc9045-10000066400000000000000000000003551455442221600344230ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing\x04\x00\x04\x00\x00\u007f\x04\x00\x00\u007f\x04\x00@\x95\x06\x00\x04i\x00\x00\x00\u007f\x04\x00\x00\u007f\x04\x00\x04\u007f\x04\x00@\x95\x06\x00\x04i\x00\x00\x00\u007f\x04\x00\x00\u007f\x04\x00\x06\x00")1dc4ebbec0dc087985cce2cd9d0a680e4c1933ec-16000066400000000000000000000002121455442221600351230ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing\x00 \b\x00\x02\x00ng@\x95\b\x00\x01\x00ng@\x95\b\x00\a\x00\x00\x95\b\x00\b\x00\x04\x00\b\x00\x00\u007f")1e5098185c53a6be709e41e72024493864456ef0-7000066400000000000000000000001251455442221600340460ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\b\x00\x04\x00\x00\x00\u007f\x04\x00\x04\x00d")210a5ce32eb32f1d719f51a6f78ce15f8976e575-4000066400000000000000000000001661455442221600344310ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte(",\xbd\a\x00\x01\x00\x02\x00\a\x00\x03\x00\x01\x00\x02\x00\a\x00\x03\x00\x01\t\x02�\x19\x10")22197bbb11092c6a416058ce6fd1d99fd8c4633a-4000066400000000000000000000001161455442221600344050ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("q\xf9rs\x95\x00\x80i\x00\x00\x00\x80\x00\x00\x02\x00")293caf4336ebf745aef235fc01a965a1cfcf80c1-4000066400000000000000000000000731455442221600347020ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing\x00\x00\x04\x00\x05\x00")296b5ba71cf743803e5563189812b89f7f2f7452-14000066400000000000000000000002261455442221600342230ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte(",\xbd\x84ing@\x95\b\x00\x05\x00ng\x00 \b\x00\x05\x00ng@\x95\b\x00\x05\x00\x00\x00@\x95\b\x00\x05\x00n\x01\x00\x00\x00@\x95\b")2c7bee9012687618688c8f46f34b0aca1e2f2a68-6000066400000000000000000000001331455442221600344230ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing\x00\x00\x04\x00\x00\x00\x00\x00\x00\x80\x00\x00\x02\x00")2d9da857031d9bb79ba5732d53ed8bbc983d6d03-16000066400000000000000000000003621455442221600346460ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\b\x00\a\x00ng@\x95\b\x00\a\x00ng@\x95\b\x00\a\x00ng@\x95\b\x00\a\x00ng@\x95\b\x00\a\x00ng@\x95\b\x00\a\x00ng@\x95\b\x00\a\x00ng@\x95\b\x00\a\x00@\x95\b\x95\b\x00\a\x00\x00\x00\x00\x00\x00\u007f\x04\x00")338c208de76ff3e364afec353ee773104532aecd-5000066400000000000000000000001651455442221600345560ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte(",\xbd\a\x00\x01\x00\x02\x00\a\x00\x03\x00 \x00\x00\x00\a\x00\x03\x80\x00\x00\x00�\x19\x10")3621359eddc4258bcd52a2fd9a8fb75d44434b93-3000066400000000000000000000000661455442221600345010ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st�\b@\x95\x00\x00\x06\x00")369c2bb765753d7ecc40da8382acbe04f624f6d9-12000066400000000000000000000005241455442221600346420ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x80\x00\x00\x80i\x00\x00\x00d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x04\x00\x00")380ea3c8c815edb0d24278ba6a049d14d6b6c0ce-13000066400000000000000000000002101455442221600346640ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\x00\x00\x03\x80\x00\x00\x03\x80\x00\x00\x03\x80\x00\x00\x03\x80\x00\x00\x03\x80\x00\x00\x04\x80")398f9b7eb4f3f4ad6369eddb771c4433adc4e7ca-6000066400000000000000000000001311455442221600350070ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\b\x00\x04i\x00\x00\x00\u007f\x04\x00\x04\x00d�")39da7860aa52bb0886e507bb9017380673ac55c2-3000066400000000000000000000001131455442221600342370ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing\x00\x00\x04\x00\x03\x00\x01\x00\x02\xef")3a9e964d1a74ae15985b1eb93450e9caebd4fa4f-8000066400000000000000000000003141455442221600347230ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte(",\xbd\a\x00\x01\x00\x02\x00\a\x00\x03\x00 \x00\x02\x00\a\x00\x03\x00 \x00\x00\x00\a\x00\x03\x00\x01\a\x00\x00\a\x00\x03\x00 \x00\x00\x00\a\x00\x03\x00\x01\a\x00\x03\x00\t\x01\x00")3b677b007f3e2009b0c9b242dc2f74d666614c77-13000066400000000000000000000003001455442221600343200ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("\xff\xff\x04\x90}g\x00\x00\x04\x00\x80i\x00\x00\x80\x80\x00\x00\x80\x00\x00\x00\x80\x80\x00\x00\x80i\x00\x00\x00d\x00\x00\x00\x1e\x00\x00d\x80\x00\x00\x00(\"\xe5\xb8-")3bde4493d6083edc9c29ff0b78111fa1219160f0-6000066400000000000000000000001051455442221600344010ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("\x00\x00\x04i\x00\x00\x10\x00\x00\x00\a\x00")3f2da580433bae37e15f9f38c6235fed72fd83b2-11000066400000000000000000000001301455442221600346300ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\x00\x00\x03\x80\x00\x00\x03\x80\x00\x00\x04\x80")3f5962d8f537c531b6c84d9a82b13f517757e1b1-1000066400000000000000000000000561455442221600342660ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte(",\x10�\x1f\xef\xbd")408a00980e100b54f789fe692ed9a6bc3f0bb313-6000066400000000000000000000001721455442221600344050ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte(",\xbd\a\x00\x01\x00\x02\x00\a\x00\x03\x00 \x00\x00\x00\a\x00\x03\x00\x01\a\x00\x03\x00\t\x02\xef")414283dc8341e896fc0b9fa0dbe054720de3affd-11000066400000000000000000000001721455442221600347040ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing6\x95\b\x00\b\x00ng6\x95\b\x00\b\x00ng@\x95\b\x00\b\x00\x00\x00\x00\u007f\x04\x00\b\x00")41a19022337a6b3b7fc3a78db4ba18e2f74d3f93-8000066400000000000000000000001621455442221600344640ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\x00\x00\x04i\x00\x00\x80\x80\x00\x00\x80i\x00\x00\x80\x80\x00\x00\x02\x00")43ff49d88057eaf164f08d374471387d01acbb32-7000066400000000000000000000001641455442221600343430ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\b\x00\x04i\x00\x00\x00\u007f\x04\x00\x00\u007f\x04\x00\x04\x00\x00\x80i\x00")44e3dddcee541f0c70c971d034098c00e09c2cfb-8000066400000000000000000000002031455442221600346130ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("s*\x84Ung@\x95\b\x00\x01\x00\x00d@\x95\b\x00\x01\x00ng@\x95\b\x00\x01\x00\x00\x00\x03\x00\x00\x00\x01\x00")45ebe55bebe737b40a7623b415d014c01dbfc48e-12000066400000000000000000000002021455442221600346610ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\x14\x00\x02\x80\x00\x00\x04i\x00\x00\x80\x80\x00\x00\x80i\x00\x00\x80\x80\x00\x00\x02\x00")46b76c7654b654663df1bfc89f4f57b0c7914575-8000066400000000000000000000002741455442221600343170ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing\x04\x00\x04\x00@\x95\x06\x00\x04i\x00\x00\x00\u007f\x04\x00\x00\u007f\x04\x00\x04\u007f\x04\x00\x00\u007f\x04\x00\x00\u007f\x04\x00\x04\x04_\x95\x06\x00")46f1beb4ce96847d318124ae66aa89308b6bb82c-18000066400000000000000000000001751455442221600345700ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("\b\x00\a\x00n`@\x95\x14\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\u007f\x04\x00\b")46f39a97120eea8e01bba6c139518fe4f523617b-17000066400000000000000000000002621455442221600344750ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("\b\x00\b\x00ng6\x95\x14\x00\x06@\x95\x95\b\x00\b\x00ng\b\x00\b\x00ng6\x95\x14\x00\x06\x00\b\x00\b@\x95g@\x95\b\x00\b\x00\x04\x00\b\u007f\x04\x00\x06\x00")4795a256eea4ee6c0e825b55be08592109e88a8a-13000066400000000000000000000002351455442221600345110ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ifg@\x95\x14\x00\x06\x80\x00\x00\x80\x80\x00\x00\x80i\x00\x00\b\x00\x00\x00\x00\x95\b\x00\b\x00\x04\x00\b\u007f\x04\x00\b\x00")47ecd03a9f7e50b0a7e4467fdccbeb75da7a67e8-16000066400000000000000000000001601455442221600351430ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("\b\x00\a\x00ng@\x95\x14\x00\x01\x00ng@\x95\b\x00\a\x00\x00\x00\x00\x00\u007f\x04\x00\b")49f5844888536d5e92b09a09992d14c7017f12c5-6000066400000000000000000000001541455442221600340660ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("s\x10\a\x90}g\x00\x00\x04\x00\x80i\x00\x00\x80\x80\x00\x00\x02\x17\x04\xff\xf4\xff")4a3ebb6c4c8c73af75b41a088fd26978b2361308-9000066400000000000000000000002311455442221600344150ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("s\x00\x00ing\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x80\xc8h\n\x0f")4c79920163233fb69e0e72fab06f1bde46960f83-4000066400000000000000000000001061455442221600343360ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("s\x04\x84i&�\x01\x00ng\x00\x00\x04\x00\x04")4fc9ce6d1d0f22976ec833d59f6cfe62c16e1752-13000066400000000000000000000002121455442221600346500ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte(",\xbd\x84ing@\x95\b\x00\x05\x00ng\x00 \b\x00\x05\x00ng@\x95\b\x00\x01\x00\x00\x00@\x95\b\x00\x05\x00ng\x00\u007f")52255a62365808354655b1f7661d391798e30323-7000066400000000000000000000002061455442221600335450ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing\x04\x00\x04\x00@\x95\x06\x00\x04i\x00\x00\x00\u007f\x04\x00\x00\u007f\x04\x00\x04\x04_\x95\x06\x00")53a7392c8f2ac718701a1a1be07f50629fe56097-9000066400000000000000000000001511455442221600342530ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\b\x00\b\x00ng@\x95\b\x00\b\x00\x00\x00\x00\u007f\x04\x00\x04\x00")541bdf90fd69a923e12c2ee8b52c56cb1e0450e9-3000066400000000000000000000000711455442221600345440ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("stz\x00tln\x00\x00\x00\xe9trinJ")54749e1cacebfce8b22ff4e83b2ba0a8ed33f544-11000066400000000000000000000002021455442221600351170ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\x14\x00\x06\x80\x00\x00\x04i\x00\x00\x80\x80\x00\x00\x80i\x00\x00\x80\x80\x00\x00\x02\x00")554a2add8bc75404ed7f55ab7bad5f3a880b1fef-12000066400000000000000000000002021455442221600351200ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\x14\x00\x06\x80\x00\x00\x04i\x00\x00\x80\x80\x00\x00\x80i\x00\x00\x80\x80\x00\x00\x06\x00")56f6ec79db815a7bb18cbccfc7255384e634857d-6000066400000000000000000000001261455442221600346010ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\b\x00\x01\x00\x00\x00\x03\x00\x00\x00\x01\x00")58253ecb6927e96cc3a26cff858bc88485ae2760-20000066400000000000000000000001751455442221600345270ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("\b\x00\a\x00ng@\x95\x14\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\u007f\x04\x00\b")58493b835c47302c2806ec3eb7e30fa7584d0292-1000066400000000000000000000001021455442221600341640ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("\x14\x01\x00\x01p\x13a\x14\x01\x00\x01\a")58d90b43ebec2dc1bcb5cff722703d8941c9be88-15000066400000000000000000000002651455442221600350060ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\b\x00\a\x00ng@\x95\b\x00\a\x00ng@\x95\b\x00\a\x00ng@\x95\b\x00\a\x00ng@\x95\b\x00\x01\x00ng@\x95\b\x00\a\x00\x00\x00\x00\x00\u007f\x04\x00\b")5a2d8d473a6c3e1b7620d2550cd35fbdf8f20c1a-13000066400000000000000000000002471455442221600346730ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing3\x95\b\x00\b\x00ng6\x95\b\x00\b\x00ng@\x95\b\x00\b\x00\x00\x00\x00\x95\b\x00\b\x00ng@\x95\b\x00\b\x00\x04\x00\b\u007f\x04\x00\b\x00")5d3fc41de9259046c25345d0d17c1de6f0723256-7000066400000000000000000000001301455442221600342430ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\b\x00\x04\x00\x00\x00\x00\u007f\x04\x00\x04\x00")6064a9c9c050c456f4b743d67c2876d4fafc4706-12000066400000000000000000000001501455442221600344210ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\x00\x00\x03\x80\x00\x00\x03\x80\x00\x00\x03\x80\x00\x00\x04\x80")61a790bd551d1db982a8362dcd328b972d5d83b5-7000066400000000000000000000002611455442221600344200ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte(",\xbd\a\x00\x01\x00\x02\x00\a\x00\x03\x00 \x00\x00\x00\a\x00\x03\x00\x01\a\x00\x00\a\x00\x03\x00 \x00\x00\x00\a\x00\x03\x00\x01\a\x00\x03\x00\t\x01\x00")659b4628d5acfdc0184ed31433725e280b4c387b-6000066400000000000000000000001641455442221600343350ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\b\x00\x04i\x00\x00\x00\u007f\x04\x00\x04i\x00\x00\x00\u007f\x04\x00\x04\x00")66905bc1f59737fdab24dd7110b101a4b4fc77a0-6000066400000000000000000000002351455442221600344520ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte(",\xbd\a\x00\x05\x00\x02\x00\a\x00\x03\x00\x01\x00\x02\x00\a\x00\x03\x00\x00\x00\x00\x00\a\x00\x03\x00\x01\t\x02\xef\xbf\x00\xbd\x19")66a9c7121a61e782c68fa2d7bf70135dc43f1cbc-3000066400000000000000000000000651455442221600345440ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("str&�\x01\x00\x00\x01\x00")66eb63b0d261b8272cda52764e92513763be5897-4000066400000000000000000000001351455442221600342040ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte(",\x10\a\x00\x01\x00\x02\x00\a\x00\x03\x00\x01\x00\x00\x02i\xcfn\xea")674385897f247dfb32a67d2bdb04d7bffe0b4e69-15000066400000000000000000000003371455442221600346620ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\b\x00\a\x00ng@\x95\b\x00\a\x00ng@\x95\b\x00\a\x00ng@\x95\b\x00\a\x00ng@\x95\b\x00\a\x00ng@\x95\b\x00\a\x00ng@\x95\b\x00\a\x00@\x95\b\x95\b\x00\a\x00\x00\x00\x00\x00\x00\u007f\x04\x00")67453e7b828d6944a7d5649472f6042811e3900c-11000066400000000000000000000003561455442221600340570ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("\x00\x00\x04i\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x04\x00\x00\x00\x00\x00\x80\x80\x00\x00\x80i\x00\x00\x00d\x00\x00\x00\x00\x80\xc8h\x00")68e675e533322aea8928e315339ad529635f0346-7000066400000000000000000000002161455442221600340530ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("\xff\xff\x04\x90}g\x00\x00\x04\x00\x80i\x00\x00\x80\x80\x00\x00\x80i\x00\x00\x80\x80\x00\x00\x02\x17\x04\xff\xf4\x00")691f5d75bde11171af07e9325753253c625cc21a-10000066400000000000000000000002321455442221600343140ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84igg\x00 \b\x00\x04\x00ng@\x95\b\x00\x04\x00\x00g@\x95\b\x00\x04\x00ng@\x95\b\x00\x04\x00\x00\x00\x00\u007f\x04\x00\x04\x00")69ab743c127ffdb6c1f5b7a6bd9be7dbb21a9653-2000066400000000000000000000000461455442221600347720ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("strings\x95J")69cf73c46886c75b52c8260b1fa1d2eeaa2e082e-1000066400000000000000000000000511455442221600345440ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("strings\x95Join")6e635917981e43ca2b91eb094200e13b7afeadfb-9000066400000000000000000000002661455442221600345540ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte(",\xbd\a\x00\x01\x00\x02\x00\a\x00\x03\x80\x00\x00\x00\x00\a\x00\x03\x00 \x00\x00\x00\a\x00\x03\x00\x01\a\x00\x00\a\x00\x03\x00\x00\x00\x00\x00\x01\a\x01\x00")6f2a41a959831880dea139a67efe6cf73657d36e-9000066400000000000000000000002301455442221600344420ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("s\x00\x00ing\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x04\x00\x00\x00\x00\x00d\x00\x00\x00\x00\x80\xc8h\x00\x00")7239ad4bc508d704040d2bae0f46fb894ce8ec01-14000066400000000000000000000003151455442221600346170ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing3\x95\b\x00\b\x00ng6\x95\x14\x00\x06\x80\x00\b\x00\b\x00ng@\x95\x95\b\x00\b\x00ng\b\x00\b\x00\x00\x00\x00\x95\b\x00\b\x00ng@\x95\b\x00\b\x00\x04\x00\b\u007f\x04\x00\b\x00")7285a50d7de3b6208758496f436f3d195a14e7c4-13000066400000000000000000000001701455442221600342720ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\b\x00\a\x00ng@\x95\b\x00\a\x00ng@\x95\b\x00\a\x00\b\x00\x00\u007f\x04\x00\b\x00")75174d33450a5cd9fcd4315e1d672fbb6c853269-5000066400000000000000000000001631455442221600343410ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte(",\xbd\a\x00\x01\x00\x02\x00\a\x00\x03\x00 \x00\x00\x00\a\x00\x03\x00\x01\t\x02�\x19\x10")75543968632bf02abbf1f3a3df89054ebd87097b-10000066400000000000000000000001351455442221600345010ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing\x00 \b\x00\x02\x00ng@\x95\b\x00\x01\x00\x00\x00\x00\u007f")7599dd7e66269c08b8abce2977751628e97f956d-8000066400000000000000000000001711455442221600343430ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("s\x00\x00ing\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\xc8h\n\x0f")75b30d575b0db195e12f1284d6c83446df5fc440-3000066400000000000000000000001471455442221600343310ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte(",\x10\a\x81\f\xab@\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\x02�\x19\xbd")76954e0c5c040f01bb64ab74ca8e562559456527-14000066400000000000000000000007571455442221600342660ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84in\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x04\x00\x00\x00\x00\x00\x80\x00\x00\x00\x80i\x00\x00\x00d\x00\x00\x00\x1e\x00\x00\x00\x00\x00\x00\x00\x80\x04\x00\x00\x00\x00\x00d\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x04\x00\x00\x00\x00\x00\x80\x00\x00\x00\x80i\x00\x00\x00d\x00\x00\x00\x1e\x00\x80\x04\x00")76983cd222c221cfbef8b858042d4e3a6229e256-8000066400000000000000000000001261455442221600343420ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\b\x00\b\x00\x00\x00\x00\u007f\x04\x00\x04\x00")79fa28ed23e1e1bd6dcf10fc9e44a2a458be655b-9000066400000000000000000000003261455442221600350000ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing\x04\x00\x04\x00@\x95\x06\x00\x04i\x00\x00\x00\u007f\x04\x00\x00\u007f\x04\x00\x04\u007f\x04\x00@\x95\x06\x00\x04i\x00\x00\x00\u007f\x04\x00\x00\u007f\x04\x00\x04\x04_\x95\x06\x00")7b7e41301ba2d2a223f51410fd7fd4b87206c6ad-4000066400000000000000000000001571455442221600344430ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84\x81\f\xab@\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\x02\x80\x00\x00\x00\xbd")8851d9c9e41e7008543bb4912900851eafeb241f-12000066400000000000000000000001651455442221600343350ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte(",\xbd\x84ing@\x95\b\x00\x05\x00ng\x00 \b\x00\x05\x00ng@\x95\b\x00\x01\x00\x00\x00\x00\u007f")8cede749725df244aafe5a8d376808c298b816d7-6000066400000000000000000000001411455442221600345260ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte(",\xbd\a\x00\x01\x00\x02\x00\a\x00\x03\x00\x00\x00\x00\a\x00\x03\x00\x01")8dda798c343b3bc83158f77eeff80e645f124365-4000066400000000000000000000001131455442221600344350ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing\x00\x00\x04\x00\x04\x00\x04\xff\xf4\x04")8ded6a0cd324784a117fac305c72fca1b716c531-11000066400000000000000000000001511455442221600346010ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\b\x00\a\x00ng@\x95\b\x00\a\x00\x04\x00\x00\u007f\x04\x00\x06\x00")917b34aab4968f8fda0754fabc0f07b7ce411017-4000066400000000000000000000001471455442221600345440ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte(",\x01\a\x81\f\xab@\x00\x10\x00\x02\x00\x01\xed\x02\x00\x01\x00\x02�\x19\xbd")926b50528df0f5f9a9dea665ad946b7055cbc888-4000066400000000000000000000001271455442221600345230ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\x00\x00\x04i\x00\x00\x00\u007f\x04\x00\x04\x00")9414975d2cec04e3e670248c84961a2fe107f271-16000066400000000000000000000003041455442221600342610ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("\x04\x00@\x00\x00\x00\x03\x80\u007f\x00\x04\x80der using a custom Comparer; if you control the implementation of type, you can also consider using an Exporter, AllowUnexp")98b48b65f9cd15fc821550bd352a74905eac753f-15000066400000000000000000000011151455442221600345060ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84in\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x04\x00\x00\x00\x00\x00\x80\x00\x00\x00\x80i\x00\x00\x00d\x00\x00\x00\x1e\x00\x00\x00\x00\x00\x00\x00\x80\x04\x00\x00\x00\x00\x00d\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x04\x00\x00\x00\x00\x00\x80\x00\x00\x00\x80i\x00\x00\x00d\x00\x00\x00\x1e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00bad ve")9b7b7c89451647713aff7995df71ce98fd82bf5d-15000066400000000000000000000002531455442221600346320ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte(",\xbd\x84ing@\x95\b\x00\x05\x00ng\x00 \b\x00\x05\x00ng@\x95\b\x00\x05\x00ng\x00 \b\x00\x05\x00\x00\x00@\x95\b\x00\x05\x00n\x01\x00\x00\x00@\x95\b")a3ba8e1302f5fdc9b741c7e779f7ba3120d2fccb-20000066400000000000000000000001751455442221600350420ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("\b\x00\a\x00ng@\x95\x14\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\u007f\x04\x00\b")a4ebde97ceba106723b7b4fec2489a7f45fefcae-7000066400000000000000000000001561455442221600352250ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84Ung@\x95\b\x00\x01\x00\x00d@\x95\b\x00\x01\x00\x00\x00\x03\x00\x00\x00\x01\x00")a731f3a8548ebd9850d6741d79ac784eac115385-13000066400000000000000000000006051455442221600344320ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84in\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x04\x00\x00\x00\x00\x00\x80\x00\x00\x00\x80i\x00\x00\x00d\x00\x00\x00\x1e\x00\x00\x00\x00\x00\x00\x00\x80\x04\x00\x00\x00\x00\x00d\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x04\x00\x00")a843cf75c7781efa3de7790d6f2c00915b470921-9000066400000000000000000000003471455442221600343540ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte(",\xbd\a\x00\x01\x00\x02\x00\a\x00\x03\x00 \x00\x02\x00\a\x00\x03\x00 \x00\x00\x00\a\x00\x03\x00\x01\a\x00\x00\a\x00\x03\x00 \x00\x00\x00\a\x00\x03\x00 \x00\x02\x00\a\x00\x03\x00\x01\a\x00\x03\x00\t\x01\x00")a8ae6f215f2d51d297bd83d44f58fb9fde068aec-3000066400000000000000000000000731455442221600350110ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing\x00\x00\x04\x00\x04\x00")ac1ba525cc316db3b13951bdef31efab1106de05-10000066400000000000000000000003031455442221600347740ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("s*\x84Ung@\xa3\b\x00\x01\x00\x00d@\x95\b\x00\x01\x00ng@\x95\b\x00\x01\x00\x00g@\x95\b\x00\x01\x00ng@\x95\b\x00\x01\x00\x00g@\x95\b\x00\x01\x00\x00\x00\x03\x00\x00@\x95\b")aea62b4bff7bd147631cd503c98ad9213f77d6be-3000066400000000000000000000000701455442221600347060ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("i\xf9ring@\x95\x00\x00\x02\x00")afd5a9ac7ec4df101699242a93ccc74ce1c74e22-14000066400000000000000000000002721455442221600347700ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing3\x95\b\x00\b\x00ng3\x95\b\x00\b\x00ng6\x95\b\x00\b\x00ng@\x95\b\x00\b\x00\x00\x00\x00\x95\b\x00\b\x00ng@\x95\b\x00\b\x00\x04\x00\b\u007f\x04\x00\b\x00")b357a3f2e1c813058a73942e3d5e9854abeb4d48-10000066400000000000000000000005071455442221600344760ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\b\x00\x03\x00 \x00\x02\x00\a\x00\x03\x00 \x00\x00\x00\b\x00\x03\x00 \x00\x02\x00\a\x00\x03\x00 \x00\x00\x00\a\x00\x03\x00\x01\a\x00\x00\a\x00\x03\x00 \x00\x00\x00\a\x00\x03\x00\x01\a\x00\x00\a\x00\x03\x00 \x00\x00\x00\a\x00\x03\x00 \x00\x02\x00\a\x00\x03\x00\x01\a\x00\x03\x00\t\x01\x00")b3650f1abca51343339f1cd22a1bfeebbbe8b2ef-8000066400000000000000000000001631455442221600351010ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("s\x8d\x84ing@\x95\b\x00\x04\x00\x00g@\x95\b\x00\x04\x00\x00\x00\x00\u007f\x04\x00\x04\x00")b6114c305ebd4b9ba74b3e156315dbf85de4fa79-5000066400000000000000000000001471455442221600346300ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing\x04\x00\x04\x00@\x95\x00\x00\x04i\x00\x00\x00\u007f\x04\x00\x04\x00")bc7af769bbc6f3c36eb16625c212c2c8ea54f97b-7000066400000000000000000000001741455442221600347220ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte(",\x10\xefing@\x95\b\x00\x04i\x00\x00\x00\u007f\x04\x00\x00\u007f\x04\x00\x04\u007f\x04\x00\x04\x00")bf13ca386bb4613410e957c31b000189cf07f03d-4000066400000000000000000000002121455442221600342750ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte(",\x10\a\x81\f\xab@\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\x02\xef\x01\x00\x02\x00\x01\x00\x03\xbf\xfb\x93}B")bf70b79ab7e9ee863253a7ac8aee81fcbf855e8f-14000066400000000000000000000002401455442221600351610ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\b\x00\a\x00ng@\x95\b\x00\a\x00ng@\x95\b\x00\a\x00ng@\x95\b\x00\a\x00ng@\x95\b\x00\a\x00\x00\x00\x00\x00\u007f\x04\x00\b")bfe24f4303af816ab86da59e18dfbcabb8444d28-8000066400000000000000000000002361455442221600347760ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("\xff\xff\x04\x90}g\x00\x00\x04\x00\x80i\x00\x00\x80\x80\x00\x00\x80i\x00\x00\x9a\xff\x00\x00\x00\x01\x00\x00\x02\x17\x04\xff\xf4\x00")c01bb1c7dbe87db58b0e527c2dd72caac9b3cfb7-3000066400000000000000000000001051455442221600351660ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("\x14\x01\x00\x01p\x80\x00\x00\x00\x00\b\x00")c0e4d6ec235635a92ceeaa82e7e0820ea6c63ce0-9000066400000000000000000000001331455442221600347000ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing\x00 \b\x00\a\x00ng@\x95\b\x00\x01\x00\x00\x00\x00\u007f")c38fccf97e8155d328da7216d41d699473c2818c-2000066400000000000000000000000651455442221600343610ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("string@\x95\x00\x00\x04\x00")c5471b56b05e8cf8306af45e61c2c309786bcdc7-12000066400000000000000000000002241455442221600345540ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing3\x95\b\x00\b\x00ng6\x95\b\x00\b\x00ng@\x95\b\x00\b\x00\x00\x00\x00\x95\b\x00\b\x00\x04\x00\b\u007f\x04\x00\b\x00")ca1bee79e992bbecb0dcc7786e8eac98844a8b22-2000066400000000000000000000001341455442221600350700ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte(",\x10\a\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\x02�\x19\xbd")cc1d7e42dd85a7da33ae2c9cda8bada68688ecfc-14000066400000000000000000000002301455442221600353520ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\x00\x00\x03\x80\x00\x00\x03\x80\x00\x00\x03\x80\x00\x00\x03\x80\x00\x00\x03\x00\x00\x00\x03\x80\x00\x00\x04\x80")cc8326919c41daa089d455e3cda637105edd86e3-14000066400000000000000000000001641455442221600345600ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\b\x00\x01\x00 \x00\x00\x00\a\x00\x03\x00ng@\x95\b\x00\a\x00\b\x00\x00\u007f")cd698b2fb99fcfbd04fa7628270e2e37befbe395-8000066400000000000000000000001101455442221600350130ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\b\x00\x01\x00\x00\x00\x00\u007f")cf4dbe6a7810e20d76eccb50a3538a5c12734537-12000066400000000000000000000001441455442221600345340ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\b\x00\a\x00ng@\x95\b\x00\a\x00 \x00\x00\u007f\x04\x00\b\x00")cfa8f136c1e13736851892dbab1552a514e317a3-15000066400000000000000000000002201455442221600343710ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\b\x00\x01\x00 \x00\x00\x00\a\x00\x03\x00ng@\x95\b\x00\a\x00\x00\x95\b\x00\b\x00\x04\x00\b\x00\x00\u007f")d8fa2f67c30bb94b6f0f4148ccc984b3b9c2ef26-12000066400000000000000000000005061455442221600350020ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("\x00\x00\x04i\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x04\x00\x00\x00\x00\x00\x80\x80\x00\x00\x80i\x00\x00\x00d\x00\x00\x00\x1e\x00\x00\x00\x00\x00\x00\x00\x80\x04\x00\x00\x00\x00\x00d\x00\x00\x00\x00\x80\x00\x00\x00(\"\xe5\xb8-")da39a3ee5e6b4b0d3255bfef95601890afd80709000066400000000000000000000000321455442221600344100ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("")de6ae9714625105f8323efd037a92833b4c92efe-10000066400000000000000000000001351455442221600344760ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing\x00 \b\x00\x05\x00ng@\x95\b\x00\x01\x00\x00\x00\x00\u007f")de865354115e718b92af38ad958e111d2ee0c87f-5000066400000000000000000000001251455442221600344250ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\b\x00\x04i\x00\x00\x00\u007f\x04\x00\x04\x00")e356e0ea3b5d0d5288b27738723f7b41bfa1ec49-11000066400000000000000000000004701455442221600345520ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("\x00\x00\x04i\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x04\x00\x00\x00\x00\x00\x80\x80\x00\x00\x80i\x00\x00\x00d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x04\x00\x00\x00\x00\x00d\x00\x00\x00\x00\x80\xc8h\x00@")e5d8827f2dc69340ad956d487b5795e3cfff3aba-9000066400000000000000000000001371455442221600346720ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\b\x00\x01\x00 \x00\x00\x00\a\x00\x03\x00\x00\x00\u007f")e7e47fbfbdfb604cdc542a4ff4cfd4a62880fcf9-10000066400000000000000000000001471455442221600353050ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\b\x00\b\x00ng@\x95\b\x00\b\x00\x00\x00\x00\u007f\x04\x00\b\x00")ea19a0e4f20f412685f8b00d8930958e3c1965e6-3000066400000000000000000000001321455442221600342560ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte(",\x10\a\x00\x01\x00\x02\x00\a\x00\x03\x00\x01\x00\x02�\x19\xbd")ea220edfb68c47a225afc173c1bb4c19b7c3ddea-7000066400000000000000000000001511455442221600351040ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("s\x00\x00ing\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x80\xc8h\n\x0f")ec07786954c326b3824b239e9393f38045dee1fa-15000066400000000000000000000003101455442221600343500ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\x00\x00\x03\x80\x00\x00\x03\x80\x00\x00\x03\x80\x00\x00\x03\x80\x00\x00\x03\x80\x00\x00\x03\x80\x00\x00\x03\x00\x00\x00\x03\x00\x00\x00\x03\x80\x00\x00\x04\x80")eceebe92c6b361d97f82b57144ef9b852918cb80-11000066400000000000000000000001631455442221600346560ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte(",\xbd\x84ing@\x95\b\x00\a\x00ng\x00 \b\x00\x05\x00ng@\x95\b\x00\x01\x00\x00\x00\x00\u007f")ee249e051fbec2f602346a768e4fd4a32ed7a917-16000066400000000000000000000003001455442221600346320ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte(",\xbd\x84idg@\x95\b\x00\x05\x00ng\x00 \b\x00\x05\x00ng@\x95\b\x00\x05\x00ng\x00 \b\x00\x05\x00ng\x00 \b\x00\x05\x00\x00\x00@\x95\b\x00\x05\x00n\x01\x00\x00\x00@\x95\b")f09265e8f0522226c7805967cdbc8d482aa783d1-11000066400000000000000000000002021455442221600343360ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\x14\x00\x04\x80\x00\x00\x04i\x00\x00\x80\x80\x00\x00\x80i\x00\x00\x80\x80\x00\x00\x02\x00")f53b257eb26b5d2fd0b63d65f38334e266366ced-9000066400000000000000000000002051455442221600345010ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84igg\x00 \b\x00\x04\x00ng@\x95\b\x00\x04\x00\x00g@\x95\b\x00\x04\x00\x00\x00\x00\u007f\x04\x00\x04\x00")f5ad532c95cfa98d4dfd737addba001efc7dddf0-10000066400000000000000000000001351455442221600353450ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing\x00 \b\x00\x04\x00ng@\x95\b\x00\x01\x00\x00\x00\x00\u007f")f8a7aa66b4ce5729bde72f3b9230527253512edb-9000066400000000000000000000002331455442221600344740ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("s*\x84Ung@\xa3\b\x00\x01\x00\x00d@\x95\b\x00\x01\x00ng@\x95\b\x00\x01\x00\x00g@\x95\b\x00\x01\x00\x00\x00\x03\x00\x00\x00\x01\x00")fb30ca9850d6762ed66bd5073a8e3a3f14d21b4e-6000066400000000000000000000001431455442221600345420ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte(",\x10\a\x00\x01\x00\x02\x00\a\x00\x03\x00\x01\x00\x10\x00\x00\x00\x04\x00")fd82caf0faae36a8f3f105bf41bf1919cc009f2f-9000066400000000000000000000002021455442221600350370ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzAddressMessagego test fuzz v1 []byte("st\x84ing@\x95\x00\x00\x03\x00\x01\x00\x04i\x00\x00\x80\x80\x00\x00\x80i\x00\x00\x80\x80\x00\x00\x02\x00")golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessage/000077500000000000000000000000001455442221600263345ustar00rootroot000000000000000219bdb2b09a3f9faa91596ebc864d8dd38ca961-8000066400000000000000000000002141455442221600341520ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x06\x00\x01\x00l\x13\x01\x00\x06A\x17\x00\x12\x00\x00\x00\x02\x00\x01\x01\x02\x00\x01\x00e\x8c\x04\x00roviP")028fbcc3f84f2b7b794c0e98e8e109a7a41c32f8-15000066400000000000000000000004121455442221600341540ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x86\x00\x01\x00\x02sid\x06A\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\xbfv\x00\x00\xefv\x00\x00\xef\x12\x00\x00\xbfv\x00\x00\xefv\x00\x00\xef\x12\x00\x00\x00\x10\x00\x00\x00\xbf\x00\x00\x00\x10\x00\x00\x00\xbf\x00\x00on\x00\x00\xbf\xc6")03d6afbd6f33d4e9eb92017bf24a68b09b3605f8-3000066400000000000000000000001451455442221600340610ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i\xef�\xbf\xbd�\xef\xbf\xc6\xef\xbf\x00\x00\x00\xef\xbf\x00\x00\xbd\x01")057986b251cd78abfdfa431695f37b1d7e015b8e-10000066400000000000000000000002211455442221600340630ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x06\x00\x01\x00\x02\x03\xe8d\x06A\x04\x00\x12\x00\x00\x00rv\x04\x00+\x00\x04\x00ro\x04\x00dr\x04\x00rv\x04\x00Ne")068e8db551236f6494b56bdc196b65f07c54826d-2000066400000000000000000000001131455442221600335750ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consider proviPn\x01\x00a\x1c\x01\x00din\x01\x00a")0759c6b3164af44b76405abfae4091fc3a07fae4-3000066400000000000000000000001231455442221600340410ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consider proviPn\x01\x00a\x1c\x01\x00d\x00\x00\x00\u007fa")07ce7c2b77ac83fc8a6f8837c8b46039d39ec911-6000066400000000000000000000001751455442221600340350ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i\xef�\xbf\xbd�\xef\xbf\xc6\xef\xbf \t\x00\x02\x00\x00\x00\x00\xbf\x00\x00\xbdA\x00\x00\x02\x00")091049356afd1f153ba4ff597b9f3cf1b3890462-20000066400000000000000000000005441455442221600337310ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("\x00\x00\x00\xbf\x00\x00\x12v\x00\x00\xef\x00\x00\x00\xbfv\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00")0937b3cd15503a61bfa2057bd6a196eff0278d32-17000066400000000000000000000004701455442221600337710ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("ider\x04\x00roviP\x1c\x01\x00dr\x04\x00av\x00\x00\xefr\x04\x00\xbfv\x00\x00\xefv\x00\x00\xef\x12\x00\x00\x00\x10\x00\x00\x00\xbf\x00\x00\x12v\x00\x00\xefv\x00\x00\xef\x00\x00\x00\x12\x00\x00\x00\xbfv\x00\x00\xefv\x00\x00\xef\x12\x00\x00\x00\x10\x00\x00\x00\xbf\x00\x00on\x00\x00\xbf\xc6")0970052ba0f01bcaa041b5d34abaa5ac6205d648-7000066400000000000000000000002061455442221600340010ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x06\x00\x01\x00\x02sid\x06A\x17\x00\x12\x00\x00\x00\x03\x00\x01\x01\x02\x00\x01\x00e\x8c\x04\x00roviP")0bce4e245b2146313a9b87db0402b6dc03c604c8-6000066400000000000000000000002171455442221600336670ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("psetsock\u007fotuLOCA\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00")0cdf9c1ecd3b8da43e87160990f8852a0b752496-8000066400000000000000000000002141455442221600337360ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x86\x00\x01\x00\x02sid\x06A\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00")0d3c04968182a809a7c651f73886fe66d53adbae-11000066400000000000000000000002611455442221600340140ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("ider\x04\x00roviP\x1c\x01\x00dr\x04\x00rv\x00\x00\xefr\x04\x00\xbfv\x00\x00\xefv\x00\x00\xef\xbf\x00\x00on\x00\x00\xbf\xc6\x04\x00*\xef\x00\x00\x00\x00")0d8d6378b9b325df6e1fe97551745e64bb2746a4-20000066400000000000000000000004021455442221600337400ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("\x04\x00\x1e\x00\b\x00\x04\x00\x04\x00\xab\x00\b\x00\x1e\x00\b\x00\x04\x00\x04\x00\xab\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\n\x00\xab\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\n\x00\xab\x00\b\x00\x04\x00\x00\x04\x00\x04")0dbf84d5cdeb5b3ac083769068e4d50d7d1657ed-4000066400000000000000000000001251455442221600341470ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i\xef�\xbf\xbd�\xef\xbf\xc6\xef\xbf\x00\x00\x00\x03\x00")0e4a40bfdaae116f201053d089af46b94e71bdb2-21000066400000000000000000000003711455442221600341660ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i\xef�\xbf\xbd�\xef\xbf\xc6\xef\xbf \t\x00\x02\x00Questio \t\x00\x02\x00\xbf\xbd\xef\xbf\xc6F\xaa\x1c\t\x00\x02\x00Questio \t\x00\x02\x00\x00\xe8\xffJ\x0e\xef\xbf \t\x00\x02\x00Questio \t\x00\x02\x00\x00\xe8\xff\x01\x00")0e6756c6dbffd6770516a36d83b4f375cb55771e-23000066400000000000000000000004121455442221600340210ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("considX� �\x00\x00@\x00+\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\n\x00\xab\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\n\x00\xab\x00\b\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\n\x01\xab\x00\b\x00")0eec49e671b83c83f81cc6aff7514aed81a85f35-13000066400000000000000000000002141455442221600342350ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x06\x00\x01\x00\x02\x03\xe8d\x06A\x17\x00\x12\x00\x00\x00\x01\x00\x0f\x00\x01\x00\x01\x00e\x8c\x01\x00roviP")10e72bcd98910ae208da19436068b7564624d614-13000066400000000000000000000001611455442221600334760ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consider prr\x04\x00rv\x14\x00+\x00\x04\x00\x01\x00\x00\x00\x03\x00\x0f\x00ro\x04\x00dr")111d78fb62158413b0eb86525697197495e42ffd-7000066400000000000000000000002031455442221600334410ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x86\x00\x01\x00\x02sid\x06A\x00\x00\xbfv\x00\x00\xef\xbf\x00\x00on\x00\x00\xbf\xfa\x00\x00\xfa\x00")1232adaaab56d7b80ae7e5cf63cd0823fb02a4bf-16000066400000000000000000000004531455442221600344130ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x86\x00\x01\x00\x02si\x00\x00\x00@\x00\x12\x00\x00\x00\x12\x00\x00\x00\xbfv\x00\x00\xefv\x00\x00\xef\x12\x00\x00\x00\x10\x00\x00\x00\xbf\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\xbfv\x00\x00\xefv\x00\x00\xef\x12\x00\x00\x00\x10\x00\x00\x00\xbf\x00\x00on\x00\x00��")16e318e33f883df563f0ed6bd6467a31c13bb3b1-4000066400000000000000000000001371455442221600337750ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("psetsock\u007fotuLOCA\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00")17201668622c629bf04df7e190c1566c9c3ce915-6000066400000000000000000000002301455442221600335040ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("ider\x04\x00\x00\x10\x00iP\x1c\x01\x00dr\x04\x00\xbfv\x00\x00\xef\xbf\x00\x00on\x00\x00\xbf\xc6\x04\x00*\xef\x00\x00\u007f\xff")18a3061a8f8b395296daec88ae0c36f2758bc404-11000066400000000000000000000001751455442221600340100ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("*\x00roviP\x1c\x04\x00dr\x04\x00rv\x14\x00+\x00\x04\x00\x12\x00\x00\x00\x03\x00\x0f\x00ro\x04\x00dr")1a123141593914984298309f84a1df34f1d84f99-16000066400000000000000000000001611455442221600333660ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consider prr\x04\x00rv\x14\x00+\x00\b\x00\x03\x00\x01\x00\b\x00\b\x00\x03\x00\x0f\x00ro")1bab3bc7a002472ccf086997ec723150e63c61e7-23000066400000000000000000000010551455442221600337700ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("\b\x00\x04\x00\x04\x00\xab\x00\b\x00\x1e\x00\b\x00\x04\x00\x04\x00\xab\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\n\x00\xab\x00\b\x00\x04\x00\x1e\x00\t\x00\b\x00\x04\x00\n\x00\xab\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\n\x00\xab\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\n\x1a\xab\x00\b\x00\x1e\x00\b\x00\x04\x00\x04\x00\xab\x00\b\x00\x1e\x00\b\x00\x04\x00\x04\x00\xab\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\n\x00\xab\x00\b\x00\b\x00\n\x00\x04\x00+\x00\b\x00\n\x00\x04\x00+\x00\b\x00\n\x00\x04\x00+\x00\b\x00\n\x00ARes")1df03daa5547b8c5aaf45060cc1c34d19825cc59-16000066400000000000000000000001651455442221600341310ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consider prr\x04\x00rv\x14\x00+\x00\b\x00\x01\x00\x00\x00\x03\x00\x00\x00\x01\x00\x04\x00dr")1e144bea9765cbd9f41a52f07610b8e9dd0786b8-12000066400000000000000000000002061455442221600340670ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("\x04\x00dr\x04\x00rv\x04\x00d\x00\x04\x00rv\x04\x00+\x00\x04\x00+\x00\x04\x00+\x00\x04\x00+\x00\x04\x00+\x00")2220f834b6fc438f49adb6f0d3d4ca1e0cfa8f06-16000066400000000000000000000003461455442221600342760ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte(" prr\x04\x00rv\x14\x00\b\x00\x04\x00\x1e\x00\b\x00\x04\x00\x04\x00\xab\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\n\x00\xab\x00\b\x00\x04\x00\x00\x04\x05\u007f\x0f\x00\x05\x00\x01\x00e\x8c\x01\x00roviP")22eecb9cfd661c5e5a471667ae2e1e08d1d34e5f-3000066400000000000000000000001631455442221600342220ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x06\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\x02\x00\x01\x00er\x04\x00roviP\x1c")23eb7c53ceabc4b4d938039f81829d9e439260fd-19000066400000000000000000000002721455442221600341070ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte(" prr\x04\x00rv\x14\x00\b\x00\x04\x00\x1e\x00\b\x00\x04\x00\x04\x00\xab\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\n\x00\xab\x00\b\x00\x04\x00\x00\x04\x00\x04")25aaf5f092486a6ce081cfae87c9935f7532a44e-23000066400000000000000000000004111455442221600340740ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consis\x86\x00\x01\x00\x02si\x00\x00\x00@\x00\x12\x00\x00\x00\xbfv\x00\x00\xefv\x00\x00\xef\x12\x00\x00\x00\xbf\t\x00\x02\x00Questio \t\x00\x02\x00\x00\xe8\xffJ\x0e\xef\x10 \t\x00\x02\x00Q\x02si\x00\x00\x00@\x00\x00\x02\x00\x00\xe8\xff\x01")27cb682114f346a93ddf8eb2c1efacf5769d3428-22000066400000000000000000000003461455442221600341570ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("id\x06\x00\x01\x00\x02\x03\xe8d\x06A\x04\x00\x12\x00,\x00+\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\n\x00\xab\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\n\x00\xab\x00\b\x00\x04\x00\x00\x04\x00\x04")2a45d39bca96133cd3a01a0f1ff3084753b1c4a0-15000066400000000000000000000002021455442221600340150ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i\x00\x01\x00d\x00\x00\xef\xbfder pr\x00\b\x00\n\x00\x04\x00+\x00\b\x00\n\x00\x04\x00+\x00\x04\x00\n\x00")2a78a980b8c69da586219829703c8d0d2400e492-18000066400000000000000000000003611455442221600335230ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("\x01\x00\x02\x02\xe8d\x06Q\x04\x00\x80Q\x04\x00\x80\x00\x00\x00\x03\x00\x00\x00\x03\x00\x04\x00\x03\x00\x00\x00\x03\x00\x00\x00\x03\x00\x00\x00\x03\x00\x00\x00\x03\x00\x04\x00\x03\x00\x00\x00\x03\x00\x00\x00\x03\x00")2b7b8e961c2674c732a9d802d7fc6fca0c2cf458-1000066400000000000000000000000761455442221600340720ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("psetsockoptuLOCA\x00\x00\x10\x00AINe")316ab7d81c3813171dbb479563402863e4c75423-24000066400000000000000000000007631455442221600334260ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("ider \x00\x12\x00 prr\x04\x00rm\x14\x00\x12\x00\b\x00\x04\x00r\xff\x04v\x04\x00\x04\x00\x00\x00r\x00\b\x00\x04\x00\x1e\x00\t\x00\b\x00\x04\x00\n\x00\xab\x00\b\x00\x04\x00*\x00\b\x00\b\x00\x04\x00\n\x00\xab\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\"\x00\n\x1a\xab\x87\b\x00\x1e\x00\b\x00\x04\x00\x04\x00\xab\x00\b\x00\x1e\x00\b\x00\x04\x00\x04\x00\xab\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\n\x00@\x00\b\x00\x00\x00\x03\xe8\x04\x00+\x00\x04\x00+\x00\x04\x00+\x00\b\x00\n\x00ARes")333330650a4eafaa1b3f520e4d2df239309086ae-13000066400000000000000000000001611455442221600337450ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consider prr\x04\x00rv\x14\x00+\x00\x04\x00\x02\x00\x00\x00\x03\x00\x0f\x00ro\x04\x00dr")33cb29a46d3f6c58e0b1fee915b51c4ebb178f6d-16000066400000000000000000000002331455442221600343040ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i\x00\x01\x00d\x00\x00\xef\xbfder\x04\x00+\x00\b\x00\n\x00 pr\x00\b\x00\n\x00\x04\x00+\x00\b\x00\n\x00\x04\x00+\x00\x04\x00\n\x00")33dc0e6ca256438edf3147f2234e399720abf8f5-1000066400000000000000000000000731455442221600337230ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consider proviP\x1c\x01\x00ding a")3437072a583d2a28e1f9634f9b04bdac9fcab11e-19000066400000000000000000000003141455442221600341350ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte(" prr\x04\x00rv\x14\x00\b\x00\x04\x00\x1e\x00\b\x00\x05\x00\x04\x00\x1e\x00\b\x00\x05\x00\x04\x00\x1e\x00\b\x00\x05\x00\x00\x04\x05\u007f\x0f\x00\x05\x00\x01\x00e\x8c\x01\x00roviP")34b40911ed681608332dfe6abbbd225c2f7180a3-13000066400000000000000000000002501455442221600337530ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("id\x06\x00\x01\x00\x02\x02\xe8d\x06A\x04\x00\x12\x00\x00\x00\x03\x00\x0f\x00\x03\x00\x01\x00\x02\x02\xe8d\x06A\x04\x00\x12\x00\x00\x00\x03\x00")354d737578481e624423933980cadd516eceb876-11000066400000000000000000000002141455442221600335230ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x06\x00\x01\x00\x02\x03\xe8d\x06A\x17\x00\x12\x00\x00\x00\x03\x00\x0f\x00\x05\x00\x01\x00e\x8c\x01\x00roviP")385b42b7dae0e591ad66b8060b9aa8b2df457cfd-7000066400000000000000000000001741455442221600342250ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("ider\x04\x00\x10\x10\x00iP\x1c\x01\x00dr\x10\x00\x03\x00\x00rv\x00\x00\xef\xbf\x00\x00\x00\x00\x00")3d4b4f61b35a6abe7188b7197adb01a46bf8b682-3000066400000000000000000000001031455442221600340470ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("ider\x04\x00roviP\x1c\x01\x00dr\x04\x00rv")425c0a087cf2b3ddf56ecdb4b0990783a5a6552d-4000066400000000000000000000002001455442221600340440ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x06\x00\x01\x00\x02A\x00\x00\x12\x00\x01\x00\x03\x00\x01\x00\x02\x00\x01\x00er\x04\x00roviP\x1c")4363ce424fbfe2df4911182d01dfeb3722ee497b-3000066400000000000000000000001061455442221600340530ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("psets\x00\x00\x03\xe8ptuLOCA\x00\x00\x02\x00")452b49a350544c3fbdbce68364aa78a5684f9ba2-8000066400000000000000000000001601455442221600340050ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("�sid\x86\x00\x01\x00\x02sid\x06A\x05\x00\x03\x00\x00\x00\x12\x00\x05\x00\x03\x00\x01")45f69d56074f75a6ba7c302a068b908ad39bdac5-13000066400000000000000000000001641455442221600340660ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("coRCodeNameError\x17\x00\x12\x00\x00\x00\x05\x00\x0f\x00\x05\x00\x01\x00e\x8c\x01\x00roviP")46ebdd8c18c28ee8b40ee38d82b15433f0a790b8-8000066400000000000000000000002151455442221600340720ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i��\uf83d�\xef\xbf\x00\x00\x00\x06\x00\x00\x00\x06\x00\x00\x00\x06\x00\x00\x00\x06@\x00\x00\x06@\x00\x00\x06@")48c1bc19853b58bfbe20606dee27510b66ca2fc0-24000066400000000000000000000007501455442221600341310ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("\b\x00\x04\x00\x04\x00\xab\x00\b\x00\x1e\x00\b\x00\x04\x00\x04\x00\xab\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\n\x00\xab\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\n\x00\xab\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\n\x00\xab\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\xf9\x1a\xab\x00\b\x00\x1e\x00\b\x00\x04\x00\x04\x00\xab\x00\b\x00\x1e\x00\b\x00\x04\x00\x04\x00\xab\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\n\x00\xab\x00\b\x00\x04\x00OA\x04\x00so")49705bfae8bae6c18066a3fb935c4c26d268577a-5000066400000000000000000000001621455442221600340140ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i\xef�\xbf\xbd�\xef\xbf\xc6\xef\xbf\x00\x00\x00\xef\xbf\x00\x00\xbdA\x00\x00\x00\x01")4ac1ea9fc64f16cd8ecc41626c527b9d4490ddd1-7000066400000000000000000000002421455442221600342240ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i\xefetsockoptuLOCA\x05\x00\x10\x00LOCA\x05\x00\x10\x00LOCA\x05\x00\x10\x00LOCA\x05\x00\x10\x00LOCA\x05\x00\x10\x00LOCA\x05\x00\x10\x00A")4bf22c3d01d26c8f30026052895327d1f851250e-6000066400000000000000000000002061455442221600334010ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x06\x00\x01\x00\x02sid\x06A\x17\x00\x12\x00\x01\x00\x03\x00\x01\x00\x02\x00\x01\x00e\x8c\x04\x00roviP")4dad8bcbb0dd854ed90f82792443c0bd889af7ab-17000066400000000000000000000005031455442221600343730ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("id\x86\x00\x01\x00\x02si\x00\x00\x00@\x00\x12\x00\x00\x00\x12\x00\x00\x00\xbfv\x00\x00\xefv\x00\x00\xef\x12\x00\x00\x00\x10\x00\x00\x00\xbf\x00\x00\x12v\x00\x00\xefv\x00\x00\xef\x00\x00\x00\x12\x00\x00\x00\xbfv\x00\x00\xefv\x00\x00\xef\x12\x00\x00\x00\x10\x00\x00\x00\xbf\x00\x00on\x00\x00\xbf\xc6")4e1e4cc12139e801cc42e5aad595cd8fde2f8793-15000066400000000000000000000001631455442221600342310ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consider prr\x04\x00rv\x14\x00+\x00\b\x00\x03\x00\x01\x00\b\x00\x00\x00\x03\x00\x0f\x00ro")4e5e5e605a89c2cc2eb9998fd3ee73331cd2f415-17000066400000000000000000000002611455442221600341650ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("\x01\x00\x02\x02\xe8d\x06Q\x04\x00\x80Q\x04\x00\x80\x00\x00\x00\x03\x00\x00\x00\x03\x00\x04\x00\x03\x00\x00\x00\x03\x00\x00\x00\x03\x00\x04\x00\x03\x00")4f46d3e49f455438c8dace98168286c9c2288e03-15000066400000000000000000000003211455442221600337010ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("*\x00roviP\x1c\x04\x17dQ\x04\x00or\x17\x00\x12\x00\x00\x00\x05\x00\x0f\x00\x05\x00\x01\x00e\x8c\x01\x00rovior\x17\x00\x12\x00\x00\x00\x05\x00\x0f\x00\x05\x00\x01\x00e\x8c\x01\x00roviP")4f69f4314200a610c9db7fe95068907cfc42dd4a-4000066400000000000000000000001411455442221600337200ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("ider\x04\x00roviP\x1c\x01\x00dr\x04\x00rv\x00\x00\xef\xbf\x00\x00onsinn")4ff2a45908db4e2d97b7d4441417a6bb684e2af1-11000066400000000000000000000003261455442221600340630ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("cviIdder*\x00roviP\x1c\x04\x00dr\x04\x00rv\x04\x00\x17\x00\x12\x00\a\x00\x01\x00\x02\x00\x01\x00\x03\x00\xf9\xff\x01\x00\x01\x00+\x00\x04\x00ro\x04\x00dr\x04\x00rv\x04\x00N\xa9\x9fM\u007fK")5047faa198b646f001433c04c346589be7504141-10000066400000000000000000000001261455442221600334030ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("*\x00roviP\x1c\x04\x00dr\x04\x00rv\x04\x00+\x00\x04\x00+\x00")5306ee75438633ee7ca20168fdd42070dfd0b141-22000066400000000000000000000003731455442221600337110ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x86\x00\x01\x00\x02si\x00\x00\x00@\x00\x12\x00\x00\x00\xbfv\x00\x00\xefv\x00\x00\xef\x12\x00\x00\x00\x10\t\x00\x02\x00Questio \t\x00\x02\x00\x00\xe8\xffJ\x0e\xef\xbf \t\x00\x02\x00Questio \t\x00\x02\x00\x00\xe8\xff\x01")531c8288845c4c09d5e712e3acc117a820af53ff-10000066400000000000000000000002361455442221600337760ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("*\x00roviP\x1c\x04\x00dr\x04\x00rv\"\x00+\x00\x04\x00ro\x04\x00d~\xbd\xbfソ\xef\x13\xbd\xbf\xefN\x1e\xbd\xbf\xefr\x04\x00rv\x04\x00")5660729606d39330d928fe2bebf1b5800d487cd0-10000066400000000000000000000002451455442221600336440ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("ider\x04\x00roviP\x1c\x01\x00dr\x04\x00rv\x00\x00\xefr\x04\x00\xbfv\x00\x00\xefv\x00\x00\xef\xbf\x00\x00on\x00\x00\xbf\xc6\x04\x00*�q\xef")583aab550a0f428ade1524c5b864473c6ee09fb2-6000066400000000000000000000001661455442221600337760ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("ider\x04\x00\x10\x10\x00iP\x1c\x01\x00dr\x10\x00\x03\x00\x00rv\x00\x00\xef\xbf\x00\x00on\x00")58a5021686cc17dfff01e8c2cc67887c88beca55-15000066400000000000000000000002511455442221600341630ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("id\x06\x00\x01\x00\x02\x02\xe8d\x06Q\x04\x00\x80\x00\x00\x00\x03\x00\x0f\x00\x02\x00matUh\x00\x02\x03\xd5d\x06A\x04\x00\x03\x00\x00\x00\x03\x00")59a9750ea2027f003f1386013558ff7eeb99cb32-5000066400000000000000000000001771455442221600335750ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i\xef�\xbf\xbd�\xef\xbf\xc6\xef\xbf \x00\x00\x02\x00\x00\x00\x00\xbf\x00\x00\xbdA\x00\x00\x02\x00")5a1c0bbd8ac5c0c9ba568d9d46606670bb537904-10000066400000000000000000000002471455442221600340540ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("�sid\x86\x00\x01 \x02sid\x06C\x05\x00\x03\x00\x00\x00\x12\x00\x05\x00\x03\x00\x00d\x06C\x05\x00\x03\x00\x00\x00\x12\x00\x05\x00\x03\x00\x01")5a682088e8b5ca58353298feebed3ff1ec96c89b-9000066400000000000000000000002121455442221600342010ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("�sid\x86\x00\x01\x00\x02sid\x06C\x05\x00\x03\x00\x00d\x06C\x05\x00\x03\x00\x00\x00\x12\x00\x05\x00\x03\x00\x01")5b107511835848cf3ba08936da36c92faf87289f-15000066400000000000000000000001741455442221600336700ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("ider \x00\x12\x00 prr\x04\x00rv\x14\x00\x12\x00\b\x00\x04\x00r\xff\x04v\x04\x00\x04\x00+\x00\n\x00")5f250f1e6bd2fe2fce6a07ba13859fb4823f8204-22000066400000000000000000000007401455442221600341400ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("\b\x00\x04\x00\x04\x00\xab\x00\b\x00\x1e\x00\b\x00\x04\x00\x04\x00\xab\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\n\x00\xab\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\n\x00\xab\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\n\x00\xab\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\n\x1a\xab\x00\b\x00\x1e\x00\b\x00\x04\x00\x04\x00\xab\x00\b\x00\x1e\x00\b\x00\x04\x00\x04\x00\xab\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\n\x00\xab\x00\b\x00\x04\x00OAReso")5f3bae574bb193cb573ad399d6747c274774e16d-9000066400000000000000000000002061455442221600337460ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x06\x00\x01\x00\x02sid\x06A\x17\x00\x12\x00\x00\x00\x01\x00\x01\x01\x02\x00\x01\x00e\x8c\x01\x00roviP")6065e07e2adf0dc9cc85fabf6deeb256ef07fedf-19000066400000000000000000000006621455442221600347050ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("\x00\x00\x00\xbf\x00\x00\x12v\x00\x00\xef\x00\x00\x00\xbfv\x00\x00\xefv\x00\x00\xef\x12\x00\x00\x00\x10\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x00\xbf\x00\x00\x12v\x00\x00\x00\x02\x00\x00\xef\x00\x00\x00\x12\x00\x00\x00\xbfv\x00\x00\xefv\x00\x00\xef\x12\x00\x00\x00\x10\x00\x00\x00\xbf\x00\x00on\x00\x00\xbf\xc6")60d8132e7ef9a37fe06743e92fde8560ecfcd28b-3000066400000000000000000000001431455442221600341620ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i\xef�\xbf\xbd�\xef\xbf\xc6\xef\xbf\x00\x00\x00\xef\xbf\x00\x00onside")63d1acf1505de8f0e3553575c7e11c24f6c62c76-11000066400000000000000000000002141455442221600337740ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x06\x00\x01\x00\x02\x03\xe8d\x06A\x17\x00\x12\x00\x00\x00\x03\x00\x0f\x00\x02\x17\x01\x00e\x8c\x01\x00roviP")63d58ee0da34f8cd669ac446a1d9f82728792244-14000066400000000000000000000002511455442221600337470ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("id\x06\x00\x01\x00\x02\x02\xe8d\x06A\x04\x00\x12\x00\x00\x00\x03\x00\x0f\x00\x03\x00matUh\x00\x02\x02\xd5d\x06A\x04\x00\x03\x00\x00\x00\x03\x00")66560512e75ef3b590b35b37588063896b997e90-3000066400000000000000000000000721455442221600333200ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("psetsocjoptuLO0A\x00\x00\x12\x00")6776f5d9cdc53e6296e2744780d5e847fedd5197-19000066400000000000000000000005071455442221600340070ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x86\x00\x01\x00\x02si\x00\x00\x00H\x00+\x00\x00\x00\x12\x12\x00\x00\x00\x10\x00\x00\x00\xbf\x00\x00\x12v\x00\x00\xef\x00\x00\x00\xbfv\x00\x00\xefv\x00\x00\xef\x12\x00\x00\x00\x10\x00\x00\x00\xbf\x00\x00\x12v\x00\x00\xefv\x00\x00\xef\x00\x00\x00\x12\x00\x00\x00\xbfv\x00\x00\xefv\x00\x00\xbf\xbd")686568adf1a539ad292dce918aa03234276234f2-14000066400000000000000000000001401455442221600336370ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("ider prr\x04\x00rv\x14\x00+\x00\b\x00\n\x00\x04\x00+\x00\x04\x00\n\x00")691371e5d8f30ed5e51d07e76019caeef8fd9863-2000066400000000000000000000001031455442221600340220ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i����\xef\xbf\x00\x00\x00\x04\x00")6991c6033fb228a00f86b7a1e3c3a0b360f53b42-5000066400000000000000000000001661455442221600336200ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("ider\x04\x00\x00\x10\x00iP\x1c\x01\x00dr\x04\x00rv\x00\x00\xef\xbf\x00\x00on\x00\x00\x00\x01")6a96401d76b0ada76efde9eb7c6cb9e86dd3481c-17000066400000000000000000000005071455442221600344070ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x86\x00\x01\x00\x02si\x00\x00\x00H\x00\x12\x00\x00\x00\x12\x00\x00\x00\xbfv\x00\x00\xefv\x00\x00\xef\x12\x00\x00\x00\x10\x00\x00\x00\xbf\x00\x00\x12v\x00\x00\xefv\x00\x00\xef\x00\x00\x00\x12\x00\x00\x00\xbfv\x00\x00\xefv\x00\x00\xef\x12\x00\x00\x00\x10\x00\x00\x00\xbf\x00\x00on\x00\x00\xbf\xc6")6d531c8337285a4b515f4997a2ad2a80d0aa5998-12000066400000000000000000000002131455442221600336420ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("id\x06\x00\x01\x00\x02\x02\xe8d\x06A\x04\x00\x12\x00\x00\x00\x03\x00\x0f\x00\x03\x00\x01\x00\xe5\x8c\x01\x00roviP")6e901bdaf70c240af2ede33d0b10c502e2c6a095-16000066400000000000000000000005071455442221600341640ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x86\x00\x01\x00\x02si\x00\x00\x00@\x00\x12\x00\x00\x00\x12\x00\x00\x00\xbfv\x00\x00\xefv\x00\x00\xef\x12\x00\x00\x00\x10\x00\x00\x00\xbf\x00\x00\x12v\x00\x00\xefv\x00\x00\xef\x00\x00\x00\x12\x00\x00\x00\xbfv\x00\x00\xefv\x00\x00\xef\x12\x00\x00\x00\x10\x00\x00\x00\xbf\x00\x00on\x00\x00\xbf\xc6")6ed560bf331a98fda459ed9612320637299a89aa-5000066400000000000000000000001721455442221600336610ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i\xefetsockoptuLOCA\x05\x00\x10\x00LOCA\x05\x00\x10\x00LOCA\x05\x00\x10\x00LOCA\x05\x00\x10\x00A")6f840bf7b1a63d5227a1a4e1dcad63d363ff9f4f-22000066400000000000000000000005241455442221600343000ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte(" prr\x04\x00rv\x14\x00\b\x00\x04\x00\x1e\x00\b\x00\x05\x00\x04\x00\x1e\x00\b\x00\x05\x00\x04\x00\x1e\x00\b\x00\x05\x00\x00\x00\x1e\x00\b\x00\x05\x00\x04\x00\x1e\x00\b\x00\x05\x00\x04\x00\x1e\x00\b\x00\x05\x00\x00\x00\x1e\x00\b\x00\x05\x00\x04\x00\x1e\x00\b\x00\x05\x00\x04\x00\x1e\x00\b\x00\x05\x00\x00\x04\x04\x05")722479aaeb7fe4b5a5270bed87f8d7dbab4ce17a-3000066400000000000000000000001001455442221600343530ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i����\xef\xbf\x00\x00\x00\x05@")7247b935debe7850c2d2622eb00e73641aa1fd5f-15000066400000000000000000000001631455442221600340530ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consider prr\x04\x00rv\x14\x00+\x00\b\x00\b\x00\x00\x00\x03\x00\x00\x00\x01\x00\x04\x00dr")7347c4271ad5f355fbcf37d40b402d348ff6a668-13000066400000000000000000000003161455442221600340100ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("ider\x04\x00roviP\x1c\x01\x00dr\x04\x00av\x00\x00\xefr\x04\x00\xbfv\x00\x00\xefv\x00\x00\xef\x12\x00\x00\x00\x03\x00\x00\x00\xbf\x00\x00on\x00\x00\xbf\xc6\x04\x00*\xef\x04\x00q\xef")7380beaed3969348eeec32ecabbc2e8ca202b596-21000066400000000000000000000006011455442221600343550ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("nsid\x06\x00\x01\x00\x02sid\x06A\x00\x00\x12\x00\x01\x00\x03\x009sid\x06\x00P�\x01\x00\x06A\x16\x00\x01\x00\x01\x00e\x8c\x01\x00rovd\x06A\x17\x00\x12\x00\x00\x00\x01\x00\x0f\x00\x01\x00\x01\x00e\x8c\x01\x00rovsid\x0e\x00\x01\x00\x01\x00e\x8c\x01\x00rovsid\x0e\x00\x01\x00id\x06\x00\x01\x00\x02\x03\xe8d\x06A\x16\x00\x01\x00\x01\x00e\x8c\x01\x00Rovd\r��~")748548a146b118a20a9a602b08a6bd377b373196-20000066400000000000000000000002731455442221600334710ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i\xef�\xbf\xbd�\xef\xbf\xc6\xef\xbf \t\x00\x02\x00Questio \t\x00\x02\x00\xbf\xbd\xef\xbf\xc6\xef\xbf \t\x00\x02\x00Questio \t\x00\x02\x00\x00\xe8\xff\x01\x00")7558f9e6328f303e58974a5127079dbb5672cb65-7000066400000000000000000000001501455442221600334550ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("cviINder*\x00roviP\x1c\x04\x00ro\x04\x00dr\x04\x00rv\x04\x00Ne\x00\x02\x00\x01")77ebc6dfe60a8afbf375bd51b6704345c1554ae8-7000066400000000000000000000001531455442221600341470ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i\xef�\xbf\xbd�\xef\xbf\xc6\xef\xbf \t\x00\x02\x00Questio \t\x00\x02\x00sage.")7ab269e20df98d22efd264119c250da0104b90a8-18000066400000000000000000000002201455442221600337620ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte(" prr\x04\x00rv\x14\x00\b\x00\x04\x00\x1e\x00\b\x00\x04\x00\x04\x00\xab\x00\b\x00\x04\x00\x1e\x00\b\x00\x04\x00\x04\x00")7b70078b4ca712a2336db76f91538c00a011e34c-6000066400000000000000000000002161455442221600335330ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i\xefetsockoptuLOCA\x05\x00\x10\x00LOCA\x05\x00\x10\x00LOCA\x05\x00\x10\x00LOCA\x05\x00\x10\x00LOCA\x05\x00\x10\x00A")7b957c44f5e78cf66a62e61b88ab4988a7c95d80-8000066400000000000000000000002201455442221600337670ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x86\x00\x01\x00\x02sid\x06A\x00\x00\xbfv\x00\x00\xef\xbf\x00\x00on\x00\x00\xbfv\x00\x00\xef\xbf\x00\x00\xfa\x00")7befec705523fe2a981cd2ea764cf41e63cec53f-14000066400000000000000000000001711455442221600343670ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("ider \x00\x12\x00 prr\x04\x00rv\x14\x00+\x00\b\x00\x04\x00r\xff\x04v\x04\x00\x04\x00+\x00\n\x00")7c21f2642a84e1b257be7d4ddb7e289fd479dcbe-14000066400000000000000000000001751455442221600343230ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("ider prr\x04\x00rv\x14\x00+\x00\b\x00\x04\x00\x14\x00+\x00\b\x00\x04\x00\x04\x00+\x00\x04\x00\n\x00")7daa2251f6a657ae575cf84cc9af93222aae4017-14000066400000000000000000000003321455442221600341340ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x06\x00\x01\x00\x02\x03\xe8d\x06A\x17\x00\x12\x00\x00\x00\x01\x00\x0f\x00\x01\x00\x01\x00e\x8c\x01\x00rovd\x06A\x17\x00\x12\x00\x00\x00\x01\x00\x0f\x00\x01\x00\x01\x00e\x8c\x01\x00roviP")7ff434f5ab21600df4ba7251b595f89634ee42fb-15000066400000000000000000000002011455442221600340610ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("ider \x00\x12\x00 prr\x04\x00rv\x14\x00\x12\x00\b\x00\x04\x00r\xff\x04v\x04\x00\x04\x00\x00\x00\x04\x00")809fed811d3a8268154f6204d6e40b3b62485843-19000066400000000000000000000004161455442221600335170ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i\xef�\xbf\xbd�\xef\xbf\xc6\xef\xbf \t\x00\x02\x00Questio \t\x00\x02\x00sag\x00\xe8\xff\x01\x00\x0f\x00\x01\x00\x01\x00e\x8c\x01\x00rovsid\x0e\x00\x01\x00id\x06\x00\x01\x00\x02\x03\xe8d\x06A\x16\x00\x01\x00\x01\x00e\x8c\x01\x00Rovd\r��~")816258f6a7046cc770d79c913a04775a5927c8bf-21000066400000000000000000000005621455442221600336110ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("\x04\x00\x1e\x00\b\x00\x04\x00\x04\x00\xab\x00\b\x00\x1e\x00\b\x00\x04\x00\x04\x00\xab\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\n\x00\xab\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\n\x00\xab\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\n\x00\xab\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\n\x00\xab\x00\b\x00\x04\x00\x00\x04\x00\x04")82981b0b7d4cd9721e929a4c0c40ccba945d2529-5000066400000000000000000000001251455442221600337210ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("cviINder\x04\x00roviP\x1c\x04\x00ro\x04\x00dr\x04\x00rviINe")8305b64af2834c1b7c4051ec45ac7c2d1217f5d5-8000066400000000000000000000002121455442221600337010ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("ider\x04\x00\x00\x10\x00iP\x1c\x01\x00dr\x04\x00\xbfv\x00\x00\xef\xbf\x00\x00on\x00\x00\xbf\xc6\x04\x00*�q\xef")83df8b42cd294b1956954a71d8091e402a45c832-6000066400000000000000000000002061455442221600335100ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x06\x00\x01\x00\x02sid\x06A\x00\x00\x12\x00\x01\x00\x03\x00\x01\x00\x02\x00\x01\x00\x02\x00\x01\x00ro")85c9106dc8fc8b96c8545e781c61602abcfd0c71-15000066400000000000000000000003261455442221600340770ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("id\x06\x00\x01\x00\x02\x02\xe8d\x06A\x04\x00\x12\x00\x00\x00\x03\x00\x0f\x00\x03\x00matUh\x00\x02\x02\xd5d\x06A\x04\x00\x03\x00\x00\x00\x03\x00\x0f\x00\x03\x00\x00\x02\x02\xd5d\x00maUh\x00")86249c5b31b03457684a493db3a43ed60bf768cd-5000066400000000000000000000001001455442221600336370ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i����\xef\xbf\x00\x00\x00\x06@")86cc29afd692641aa72f396c58f4b9aec024dda8-16000066400000000000000000000003151455442221600342400ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x06\x00\x01\x00\x02\x03\xe8d\x06A\x16\x00\x01\x00\x01\x00e\x8c\x01\x00rovd\x06A\x17\x00\x12\x00\x00\x00\x01\x00\x0f\x00\x01\x00\x01\x00e\x8c\x01\x00rovsid\x06\x00\x01\x00iP")876f2fd027e136dccf546cca6ce0e8d617ddf222-16000066400000000000000000000004521455442221600343120ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x86\x00\x01\x00\x02si\x00\x00\x00@\x00+\x00\x00\x00\x12\x00\x00\x00\xbfv\x00\x00\xefv\x00\x00\xef\x12\x00\x00\x00\x10\x00\x00\x00\xbf\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\xbfu\xff\xe3\xefv\x00\x00\xef\x12\x00\x1e\x00\x10\x00\x00\x00\xbf\x00\x00on\x00\x00\xbf\xc6")87a6acff90efccb9612af1b9aaaaaa656adf8ead-12000066400000000000000000000002561455442221600350150ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("ider\x04\x00roviP\x1c\x01\x00dr\x04\x00av\x00\x00\xefr\x04\x00\xbfv\x00\x00\xefv\x00\x00\xef\xbf\x00\x00on\x00\x00\xbf\xc6\x04\x00*\xef\x04\x00q\xef")89e64572943e253310a1e7e373aa407403e89f6f-16000066400000000000000000000003111455442221600335130ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("ider \x00\x12\x00 prr\x04\x00rm\x14\x00\x12\x00\b\x00\x04\x00r\xff\x04v\x04\x00\x04\x00\x00\x00\x04\x00\x14\x00\x12\x00\b\x00\x04\x00r\xff\x04v\x04\x00\x04\x00\x00\x00\x04\x00")8d64e4044bc354ef510bdb158926cb70d2c9a095-14000066400000000000000000000002721455442221600337770ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("\x04\x00dr\x04\x00rv\x00rv\x04\x04\x01+\x00\x04\x00+\x00\x04\x00+\x00\x04\x00+\x00\x04\x00+\x00\x04\x00+\x00\x04\x00+\x00\x04\x00+\x00\x04\x00+\x00\x04\x00+\x00")8df9425a456879363ed2d05dd4a65065169c1f77-22000066400000000000000000000004331455442221600336110ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("\x01\x00rov\x01\x00e\x8c\x01\x00rod\x06AN\x00\x12\x00\x00\x00\x01\x00\x0f\x00\x01\x00\x01\x00e\x8c\x01\x00rovsi \x0e\x00\x01\x00\x01\x00e\x8c\x01\x00rovsid\x0e\x00\x01\x00id\x06\x00\x01\x00\x02\x03\xe8d\x06A\x16\x00\x01\x00\x01\x00e\x8c\x01\x00Rovd\r��~")8ec86fbb938af878edc4375fb85598510d088a48-7000066400000000000000000000001771455442221600340030ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i\uffff\xbd\x00\xbd�\xef\xbf\xc6\xef\xbf \x00\x00#\x00\x00\x00\x00\xbf\x00\x00\xbdA\x00\x00\x04\x00")8fa0a7c7fda046b630d3fd38adf0e5cdccf1746a-5000066400000000000000000000002121455442221600344240ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x06\x00\x01\x00\x02sid\x06A\x00\x00\x12\x00\x01\x00\x03\x00\x01\x00\x02\x00\x01\x00e\x8c\x04\x00roviP\x1c")90044f245a88c4b3f0a28af7b6944a8c6279a987-9000066400000000000000000000002611455442221600336100ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("ider\x04\x00\x00\x10\x00iP\x1c\x01\x00dr\x04\x00\xbf\x1c\x01\x00dr\x04\x00\xbfv\x00\x00\xefv\x00\x00\xef\xbf\x00\x00on\x00\x00\xbf\xc6\x04\x00*�q\xef")90348d829d35b5c5fef148e833fce00ccf986627-11000066400000000000000000000001711455442221600340300ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("co\x04\x00)d\x06\x00\x01\x00\x02\x03\xe8d\x06A\x10\x00\x12\x00\x00\x00gv\x04\x00+\x00\x04\x00ro")919ad3d9f3b794f1c113472d94a87b3c57ea0070-9000066400000000000000000000002061455442221600336500ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x06\x00\x01\x00\x02sid\x06A\x17\x00\x12\x00\x00\x00\x03\x00\x0f\x00\x02\x00\x01\x00e\x8c\x01\x00roviP")94f421b6740cf7e7dfe9422eec7244d30042993e-8000066400000000000000000000002041455442221600336560ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("nsid\x06\x00\x01\x00\x02sid\x06A\x00\x00\x12\x00\x10\x00\x03\x00\x01\x00\x02\x00\x01\x00\x02\x00\x01\x00ro")9628620a8a00aec4be1ba23486bce5ba9fb2236f-14000066400000000000000000000003001455442221600341720ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x86\x00\x01\x00\x02sid\x06A\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\xbfv\x00\x00\xefv\x00\x00\xef\x12\x00\x00\x00\x10\x00\x00\x00\xbf\x00\x00on\x00\x00\xbf\xc6")966867dad79fb5bcfb50519e774acd626f3d5f29-15000066400000000000000000000002721455442221600342040ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x06\x00\x01\x00\x02\x03\xe8d\x06A\x17\x00\x01\x00\x01\x00e\x8c\x01\x00rovd\x06A\x17\x00\x12\x00\x00\x00\x01\x00\x0f\x00\x01\x00\x01\x00e\x8c\x01\x00roviP")96a5a65fb544374a8e28a2dea711cbcbbbfb1b51-21000066400000000000000000000002551455442221600343420ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x06\x00\x01\x00\x02\x03\xe8d\x06A\x04\x00\x12\x00\x04\x00+\x00\x0f\x00\x01\x00\x01\x00e\x8c\x01\x00rov\xef\xbf \t\x00\x02\x00 \t\x00\x02\x00")97b093155cdea36bed9a7d1c52c32a722bfb72c9-18000066400000000000000000000002561455442221600342250ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte(" prr\x04\x00rv\x14\x00\b\x00\x04\x00\x1e\x00\b\x00\x05\x00\x04\x00\x1e\x00\b\x00\x05\x00\x00\x04\x05\u007f\x0f\x00\x05\x00\x01\x00e\x8c\x01\x00roviP")97b3a7828b1a7799eee880f57dfabbcf5bcbd2d5-4000066400000000000000000000000761455442221600344120ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i����\xef\xbf\x00\x00\x00\a@")98dad742ea4c50812abf718229f7872c72bfaab7-14000066400000000000000000000002771455442221600341560ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("coRCodeNameError\x17\x00\x12\x00\x00\x00\x05\x00\x0f\x00\x05\x00\x01\x00e\x8c\x01\x00rovior\x17\x00\x12\x00\x00\x00\x05\x00\x0f\x17\x05\x00\x01\x00e\x8c\x01\x00roviP")98fad2cb7a702989eebebc054396fb6ea3e5b087-6000066400000000000000000000001771455442221600342500ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i\uffff\xbd\xbf\xbd�\xef\xbf\xc6\xef\xbf \x00\x00#\x00\x00\x00\x00\xbf\x00\x00\xbdA\x00\x00\x02\x00")9c8b28de743d65325e4de9ba3dffbda76ad3b209-2000066400000000000000000000000551455442221600343100ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("�����\xef")a033affdb373b9ab3d82f1096d3f20af2bbe6b5a-10000066400000000000000000000002671455442221600344150ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("cviIdder*\x00roviP\x1c\x04\x00dr\x04\x00rv\x04\x00\a\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\x02\x00\x01\x00+\x00\x04\x00ro\x04\x00dr\x04\x00rv\x04\x00Ne")a0b7ae0caf17e2da19ad707c596b894cfffa63d9-25000066400000000000000000000004141455442221600344470ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consis\x86\x00\x01\x00\x02si\x00\x00\x00@\x00\x12\x00\x00\x00\xefv\x00\x00\x02\x00\x00\x00\x00\xbf\t\x00\x02\x00Questio \t\x00\x02\x00\x00\xe8\xffJ\x0e\xef\x10 \t\x00\x02\x00Q\x02si\x00\x00\x00@\x00\x00\x02\x00\x00\x00\x02\x00\x00\xe8\xff\xe8")a0e37a1b2c4ba3945fec9d2006c1b755c0a20bc1-17000066400000000000000000000002641455442221600341610ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i\x00\x01\x00d\x00\x00\xef\xbfder\x04\x00+\x00\b\x00\n\x00\x04\x00+\x00\b\x00\n\x00 pr\x00\b\x00\n\x00\x04\x00+\x00\b\x00\n\x00\x04\x00+\x00\x04\x00\n\x00")a13cc8662a3a8b60cb8798ad12b3a492c4129fb2-5000066400000000000000000000001771455442221600337730ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("psetsock\u007fotuLOCA\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00")a16400cb5d0387c8319b5af2e532578901685fa0-3000066400000000000000000000000761455442221600334750ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i\xefetsockoptuLOCA\x05\x00\x10\x00A")a33e1e6e6c09ac729b1e3b28f7ca0482f973d7dc-11000066400000000000000000000002141455442221600342210ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x06\x00\x01\x00\x02\x03\xe8d\x06A\x04\x00\x12\x00\x00\x00\x03\x00\x0f\x00\x02\x00\x01\x00e\x8c\x01\x00roviP")a4c8048537333f19550f0a8a956ad71c510c43f4-9000066400000000000000000000002071455442221600335000ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("psetsockopOdA\x00\x00\x00\x15\x00\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00")a5dd37b5ee6a6f6efbf8c2229bd10738b34ee044-9000066400000000000000000000001711455442221600342270ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("cviIdder*\x00roviP\x1c\x04\x00dr\x04\x00rv\x04\x00+\x00\x04\x00ro\x04\x00dr\x04\x00rv\x04\x00Ne")a69141e955cc92a24ff9e9e606d79163b412735a-15000066400000000000000000000002711455442221600336630ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("id\x86\x00\x01\x00\x02sid\x06A\x00\x00\x12\x00 \x00\x12\x00\x00\x00\xbfv\x00\x00\xefv\x00\x00\xef\x12\x00\x00\x00\x10\x00\x00\x00\xbf\x00\x00on\x00\x00\xbf\xc6")a7feccd6499b1dc0c350385e702c864f008c9279-22000066400000000000000000000004161455442221600340160ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("considX� �\x00\x00@\x00+\x00\x04\x00\xab\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\n\x00\xab\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\n\x00\xab\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\n\x01\xab\x00\b\x00\x04\x00\x1e\x00\b\x00")a8a68077b1151ae82a56f4ccc8d1c22f78dfd81e-6000066400000000000000000000001231455442221600341420ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i��\uf83d�\xef\xbf\x00\x00\x00\x06\x00\x00\x00\x06@")ab34d1d80a9aa624eea04c6195cd74014dded7b2-13000066400000000000000000000001571455442221600342600ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consider prr\x04\x00rv\x14\x00+\x00\x04\x00\b\x00\x00\x00\x03\x00\x0f\x00ro\x04\x00dr")acbb1f45d32e8f41ace634f7601e78bbe23f2234-2000066400000000000000000000001131455442221600341170ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consider\x04\x00roviP\x1c\x01\x00dr\x04\x00rvinng")ae0e5309602c0edee9bb0e634c56cb3fb79de8a9-12000066400000000000000000000002521455442221600343600ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("*\x00roviP\x1c\x04\x00dr\x04\x00rv\"\x00+\x00\x04\x00ro\x04\x00\xbfv\x00\x00\xefv\x00\x00\xef\xbf\x00\x00on\x00\x00\xbf\xc6\x00*\xef\x00\x00\x00")aef665286233b4e2d762403b6a16d67ddb3d7ce5-5000066400000000000000000000001621455442221600340020ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("psets\xea@koputdown\x1b\x00\x02\x00!\x00\x02\x00\x01\x00er\x04\x00\u007ffec0::/10\xffviP")b1ae9fecf9e6dee6ab8254bdc1acd20ea0bc24c5-3000066400000000000000000000000751455442221600346420ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("psets\xea@koptuLOCA\x00\x00\x17\x00")b21c12a59c0bb040d6a2ab6ef844cf0516ec948b-12000066400000000000000000000001751455442221600341740ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("*\x00roviP\x1c\x04\x00dr\x12\x00rv\x14\x00+\x00\x04\x00\x04\x00\x00\x00\x03\x00\x0f\x00ro\x04\x00dr")b364b6ad35c93c9c1f99e91bb39779a0e39dc14b-2000066400000000000000000000001511455442221600340740ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i\xef�\xbf\xbd�\xef\xbf\xc6\xef\xbf\x00\x00\x00\xef\xbf\x00\x00\xbd\x01\x03")b406e18dcc37f239d4cb9cc267d850fc443ff452-7000066400000000000000000000001401455442221600340670ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x86\x00\x01\x00\x02sid\x06A\x00\x00\x12\x00\x05\x00\x03\x00\x01")b610ef56bd1e506c017cd3c819a75b37c2592379-12000066400000000000000000000001321455442221600337140ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("*\x00rovi\x9c\x1c\x04\x00dr\x04\x00rv\x04\x00+\x00\x04\x00\n\x00")ba55bdd23c5adb52a8239b8700023c232f15f543-2000066400000000000000000000000721455442221600336640ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("psetsockoptuLOCA\x00\x00\x12\x00")baeb8a6d92561f4ef53c0061d2f537f8ee15248f-3000066400000000000000000000001451455442221600340670ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consider\x04\x00roviP\x1c\x01\x00dr\x04\x00rv\x00\x00\xef\xbf\x00\x00onsinn")bb1fe7f04a744798a57d6a3875a6ae58b3243aa2-10000066400000000000000000000001611455442221600340570ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("*\x00roviP\x1c\x04\x00dr\x04\x00rv\x14\x00+\x00\x04\x00ro\x04\x00dr\x04\x00rv\x04\x00Ne")bb7c56a06ab593af8558cb43b11a6a3645ca9f51-16000066400000000000000000000003031455442221600341270ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("ider \x00\x12\x00 prr\x04\x00rm\x14\x00\x12\x00\b\x00\x04\x00r\xff\x04v\x04\x00\x04\x00\x00\x00rm\x14\x00\x12\x00\b\x00\x04\x00r\xff\x04v\x04\x00\x04\x00\x00\x00\x04\x00")bce91efc74bdd35403f8b381a62f1550af3f1a98-17000066400000000000000000000001561455442221600342250ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i\xef\xbfr prr\x04\x00rv\x14\x00\xab\x00\b\x00\x04\x00\x04\x00\b\x00\x04\x00\x04\x00")bdd1d03fa13baadc2c1f3a86b280dfe8126ef412-9000066400000000000000000000003071455442221600343310ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i��\uf5bd�\xef\xbf\x00\x00\x00\x06\x00\x00\x00\x06\x00\x00\x00\x06\x00\x00\x00\x06@\x00\x00\x06\x00\x00\x00\x06\x00\x00\x00\x06@\x00\x00\x06@\x00\x00\x06@\x00\x00\x06@")bdf426caaa2ad5b17787a84c1197650f3de45f58-26000066400000000000000000000004101455442221600341440ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("considX� �\x00\x00@\x00+\x00\b\x00\b\x00\x1e\x00\x04\x00\b\x00\x01\x00\n\x00\xab\x00\b\x00\b\x00\x1e\x00\b\x00\b\x00\x04\x00\n\x00\xab\x00\b\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\n\x01\xab\x00\b\x00")be028b6b7b7b529309bb099939b229fcc2fa78d1-2000066400000000000000000000001001455442221600340010ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i����\xef\xbf\x00\x00\x00\x01@")be152934e82d85f71034c7c352f9942aa2bb1de3-1000066400000000000000000000000531455442221600337110ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("stackCalAlrgsSize")be39e0bfbd0fb27740f4fbf3e865b0605c76f938-6000066400000000000000000000002061455442221600341540ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("ider\x04\x00\x00\x10\x00iP\x1c\x01\x00dr\x04\x00\xbfv\x00\x00\xef\xbf\x00\x00on\x00\x00\xbf\xc6\xefr\x00\x00")be5783f933f4b2aa1033c27b235816edb7ff98f5-2000066400000000000000000000001041455442221600340040ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("����\xbd\xef\xbf\x00\x00\x00��")c0636f5f20d990c0e8402bd2b8592083d0b90f6e-9000066400000000000000000000002341455442221600336420ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x86\x00\x01\x00\x18sid\x06A\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00")c0dd41379ddeee29e40794be676e475ff4b4d868-20000066400000000000000000000005031455442221600341750ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x06\x00P�\x01\x00\x06A\x16\x00\x01\x00\x01\x00e\x8c\x01\x00rovd\x06A\x17\x00\x12\x00\x00\x00\x01\x00\x0f\x00\x01\x00\x01\x00e\x8c\x01\x00rovsid\x0e\x00\x01\x00\x01\x00e\x8c\x01\x00rovsid\x0e\x00\x01\x00id\x06\x00\x01\x00\x02\x03\xe8d\x06A\x16\x00\x01\x00\x01\x00e\x8c\x01\x00Rovd\r��~")c2308fe53885ff64144b2f392c2f0685bf1a8a9d-4000066400000000000000000000001731455442221600337360ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x06\x00shutdown\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\x02\x00\x01\x00er\x04\x00roviP\x1c")c23f2c59c156c1bf8ccc9335d4de81cd62c5d4c9-13000066400000000000000000000002231455442221600343030ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("\x04\x00dr\x04\x00rv\x00rv\x04\x04\x01+\x00\x04\x00+\x00\x04\x00+\x00\x04\x00+\x00\x04\x00+\x00\x04\x00+\x00\x04\x00+\x00")c443e6c4bf6bd07fc7af6919ed846eec2dcb9d0c-27000066400000000000000000000004211455442221600345400ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("considX\x00\xbf\xbd �\x00\x00@\x00+\x00\b\x00\b\x00\x1e\x00\b\x00\b\x00\b\x00\n\x00\xab\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\n\x00\x10\x00\b\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\n\u007f\x00\x00\b\x00")c45e88b7e7fb03718beb3a0d4f777499ac712755-10000066400000000000000000000002021455442221600340150ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("id\x06\x00\x01\x00\x02sid\x06A\x17\x00\x12\x00\x00\x00\x03\x00\x0f\x00\x02\x00\x01\x00e\x8c\x01\x00roviP")c4ed06339b7e9b172006cad6ec921e0482261510-17000066400000000000000000000004371455442221600336320ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("*\x00roviP\x1c\x04\x17dQ\x06\x00or\x17\x00\x12\x00\x00\x00\x05\x00\x0f\x00\x05\x00\x01\x00e\x8c\x01\x00rovior\x17\x00\x12\x00\x00\x00\x05\x00\x0f\x00\x05\x00\x01\x00e\x8c\x01\x00rovior\x17\x00\x12\x00\x00\x00\x05\x00\x0f\x00\x05\x00\x00\x01\x00e\x8c\x01\x00rovi")c64bc5c71270fef0b23361980abe6c40f3fd991c-16000066400000000000000000000001621455442221600341360ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consider prr\x04\x00rv\x14\x00+\x00\b\x00\b\x00\x00\x00\x03\x00\b\x00\b\x00\x00\x04\x00d")c734fc07d0971392cb5d6151dae5023299baa79f-19000066400000000000000000000002471455442221600340120ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i\xef�\xbf\xbd�\xef\xbf\xc6\xef\xbf \t\x00\x02\x00Questio \t\x00\x02\x00sag\x00\xe8\xff\x01\x00\x0f\x00\x02\x00\x00rovsid\x0e\x00\x01\x00")c7975a35c0594b2cce5db9f33db9eb4445898d4d-25000066400000000000000000000004101455442221600341660ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("considX� �\x00\x00@\x00+\x00\b\x00\b\x00\x1e\x00\b\x00\b\x00\x01\x00\n\x00\xab\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\n\x00\xab\x00\b\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\n\x01\xab\x00\b\x00")c969d5815b63869e6eb96b56c9f5938cc977af3d-18000066400000000000000000000006041455442221600340750ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x86\x00\x01\x00\x02si\x00\x00\x00H\x00\x12\x00\x00\x00\x12\x12\x00\x00\x00\x10\x00\x00\x00\xbf\x00\x00\x12v\x00\x00\xef\x00\x00\x00\xbfv\x00\x00\xefv\x00\x00\xef\x12\x00\x00\x00\x10\x00\x00\x00\xbf\x00\x00\x12v\x00\x00\xefv\x00\x00\xef\x00\x00\x00\x12\x00\x00\x00\xbfv\x00\x00\xefv\x00\x00\xef\x12\x00\x00\x00\x10\x00\x00\x00\xbf\x00\x00on\x00\x00\xbf\xc6")caf56122fa0446fdd7f7c666640298985251ea78-11000066400000000000000000000001641455442221600336650ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("*\x00roviP\x1c\x04\x00dr\x04\x00rv\x14\x00\x12\x00\x04\x00ro\x04\x00dr\x04\x00rv\x04\x00Ne")cb2407ccf049c8b4a6a9d73307a8254de3a21b95-8000066400000000000000000000001741455442221600337770ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("ider\x04\x00\x10\x10\x00iP\x1c\x01\x00dr\x10\x00\x03\x00\x00rv\x00\x00\xeb\x00\x00\x00\x00\x00\x00")cd84fe50bdc1342a642715cd77b6ec1a0e538fb2-21000066400000000000000000000003721455442221600342070ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte(" prr\x04\x00rv\x14\x00\b\x00\x04\x00\x1e\x00\b\x00\x05\x00\x04\x00\x1e\x00\b\x00\x05\x00\x04\x00\x1e\x00\b\x00\x05\x00\x00\x00\x1e\x00\b\x00\x05\x00\x04\x00\x1e\x00\b\x00\x05\x00\x04\x00\x1e\x00\b\x00\x05\x00\x00\x04\x04\x05")cda5a181292acede4a577ac474861993d58595dc-18000066400000000000000000000004411455442221600341050ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x06\x00\x01\x00\x02\x03\xe8d\x06A\x16\x00\x01\x00\x01\x00e\x8c\x01\x00rovd\x06A\x17\x00\x12\x00\xe8\xff\x01\x00\x0f\x00\x01\x00\x01\x00e\x8c\x01\x00rovsid\x0e\x00\x01\x00id\x06\x00\x01\x00\x02\x03\xe8d\x06A\x16\x00\x01\x00\x01\x00e\x8c\x01\x00rovd\r��~")ce95b4ae5bbb670fa1647807e014ff961778c292-16000066400000000000000000000002211455442221600340140ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("\x01\x00\x02\x02\xe8d\x06Q\x04\x00\x80Q\x04\x00\x80\x00\x00\x00\x03\x00\x00\x00\x03\x00\x04\x00\x03\x00\x00\x00\x03\x00")d1069aea1f2b629e6f25bec76d5d30ced7765b80-7000066400000000000000000000003031455442221600341440ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("psetsockopOCA\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00")d1e936d971700d058e1e5968ac489cb61ce3ab02-12000066400000000000000000000003661455442221600340110ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("\x01\x05\x00\x03\x00d\x06C\x05\x00\x02\xf7\x00\x00\x12\x00\x05\x00\x03\x00\x00d\x06C\x05\x00\x03\x00\x00\x00\x12\x00\x05\x00\x03\x00\x00d\x06C\x05\x00\x03\x00\x00\x00\x12\x00\x05\x00\x03\x00\x00d\x06C\x05\x00\x03\x00\x01")d206361650e22ee3b3184b4522707acbee497013-16000066400000000000000000000004371455442221600335450ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("*\x00roviP\x1c\x04\x17dQ\x06\x00or\x17\x00\x12\x00\x00\x00\x05\x00\x0f\x00\x05\x00\x01\x00e\x8c\x01\x00rovior\x17\x00\x12\x00\x00\x00\x05\x00\x0f\x00\x05\x00\x01\x00e\x8c\x01\x00rovior\x17\x00\x12\x00\x00\x00\x05\x00\x0f\x00\x00\x05\x00\x01\x00e\x8c\x01\x00rovi")d2c63cccd858cb7cecd42b58cfe28ddbdae6f358-11000066400000000000000000000003341455442221600346720ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x86\x00\x01\x00\x18sid\x06A\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00")d3cefdccb6192d023c01b61a391a2c66c0babe72-24000066400000000000000000000004101455442221600343140ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("considX� �\x00\x00@\x00+\x00\b\x00\b\x00\x1e\x00\b\x00\b\x00\x04\x00\n\x00\xab\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\n\x00\xab\x00\b\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\n\x01\xab\x00\b\x00")d44c7334cb6421f5a6cdd3365c5148afe8ae3cbe-3000066400000000000000000000001121455442221600342050ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("psetsockoptuLOCA\x00\x00\x00\x00\x00\x00\x00\x00")da3215ffdb175978f8fdb4c847d8bf3bf1aaff40-7000066400000000000000000000001601455442221600343750ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i��\uf83d�\xef\xbf\x00\x00\x00\x06\x00\x00\x00\x06\x00\x00\x00\x06@\x00\x00\x06@")da39a3ee5e6b4b0d3255bfef95601890afd80709000066400000000000000000000000321455442221600337200ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("")da98eb8ea0786a1fe2a3bf2bcb452050ba30d3c4-9000066400000000000000000000001741455442221600342570ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("ider\x04\x00\x10\x10\x00iP\x1c\x01\x00dr\x10\x00\x03\x00\x00rv\x00\x00\x00\x00\x00\x00\x00\x00\x00")db6f459ac2134031b8f1205b426208b69a2f77ea-14000066400000000000000000000001551455442221600337060ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consider prr\x04\x00rv\x14\x00+\x00\b\x00\b\x00\x00\x00\x03\x00\x0f\x00ro\x04\x00dr")de82341ac577ed9d32198bc06ad534af400840ad-1000066400000000000000000000000641455442221600337640ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("������\xef\xbf")dea9aa47d14c15d4170619a67a2dc29b31477fb5-16000066400000000000000000000002111455442221600340470ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x06\x00\x01\x00\x02\x03\xe8d\x06A\x04\x00\x12\x00\x04\x00+\x00\x0f\x00\x01\x00\x01\x00e\x8c\x01\x00roviP")e07e3327265d9ee2d303da5b30fd59bfc433c122-6000066400000000000000000000001301455442221600337600ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("cviINder*\x00roviP\x1c\x04\x00ro\x04\x00dr\x04\x00rv\x04\x00Ne")e0bb6419c95c74972e3f9ff71092b2f4e0861c11-4000066400000000000000000000001221455442221600336460ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i\xefetsockoptuLOCA\x05\x00\x10\x00LOCA\x05\x00\x10\x00A")e1df9169d06a4d3c627bc973d40c4d8561a31734-24000066400000000000000000000004111455442221600337210ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consis\x86\x00\x01\x00\x02si\x00\x00\x00@\x00\x12\x00\x00\x00\xbfv\x00\x00\xefv\x00\x00\x02\x00\x00\x00\x00\xbf\t\x00\x02\x00Questio \t\x00\x02\x00\x00\xe8\xffJ\x0e\xef\x10 \t\x00\x02\x00Q\x02si\x00\x00\x00@\x00\x00\x02\x00\x00\xe8\xff\x01")e2a81da8d6aa3076b0c4d028b0c4e69f986b684f-7000066400000000000000000000001611455442221600340660ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("\xbd\xbf\xbd�\xef\xdd\xc6\xef\xbf\x00\x00\x00\xef\xbf\x00\x00\x12\x00\x00\x00\x12\x00")e4bf5b62dcb0e49ed0accc07bcb039a585ddac12-9000066400000000000000000000002061455442221600344750ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x06\x00\x01\x00\x02sid\x06A\x17\x00\x12\x00\x00\x00\x04\x00\x01\x01\x02\x00\x01\x00e\x8c\x01\x00roviP")e5122de586eb70748849bcfa38bac42edd3fec01-5000066400000000000000000000002411455442221600342210ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i\xef�\xbf\xbd�\xef\xbf\xc6\xef\xbf\x00\x00\x00\xef\xbf\x00\x00\x12\x00\x01\x00\x03\x00\x01\x00\x02\x00\x01\x00ro\x00\x00\u007f\xff")e534a02a8cb1a420e85c08f745cde585cee50772-13000066400000000000000000000001541455442221600340550ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("ider prr\x04\x00rv\x14\x00+\x00\b\x00\x04\x00r\xff\x04v\x04\x00+\x00\x04\x00\n\x00")e61213dfe95b6b6a1c731bd74cd59a5a4b65a0ea-8000066400000000000000000000002521455442221600342070ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("nsid\x06\x00\x01\x00\x02sid\x06A\x00\x00\x12\x00\x01\x00\x03\x02\x03\x03\x04\x03\x04\x04\x05\x03\x04\x04\x05\x04\x05\x05\x06\x00\x01\x00\x02\x00")ea10c9405e121436e45512ba8272f343631f7f01-10000066400000000000000000000002201455442221600334430ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("c\x94iIdder*\x00roviP\x1c\x04\x00dr\x04\x00ov\x04\x00+\x00\x04\x00dr\x04\x00rv\x04\x00ro\x04\x00dr\x04\x00rv\x04\x00Ne")eb044d53d405d4f1e181d611694a83255b58cf58-8000066400000000000000000000001741455442221600335700ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("cviINder*\x00roviP\x1c\x04\x00dr\x04\x00rv\x04\x00ro\x04\x00dr\x04\x00rv\x04\x00Ne\x00\x02\x00\x01")eba30036602404d42618a8cf831b90f7f5bb8fef-4000066400000000000000000000001131455442221600337660ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consider\x04\x00roviP\x1c\x04\x00dr\x04\x00rviINe")ec7661f3c4f791e5001f147deca8ebd5075e2e1c-25000066400000000000000000000004231455442221600342230ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("considX\x00\xbf\xbd �\x00\x00@\x00+\x00\b\x00\b\x00\x1e\x00\b\x00\b\x00\x04\x00\n\x00\xab\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\n\xef\xab\x00\b\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\n\u007f\x00\x00\b\x00")ee15ea6b4cad91f0ec3779e0e4c9b58f88d200b8-11000066400000000000000000000001511455442221600343060ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("\x04\x00dr\x04\x00rv\x04\x00+r\x04\x00rv\x04\x00+\x00\x04\x00+\x00\x04\x00+\x00")ee5c9cf78a28d694415b61efdc0b7caf0a1bc9bc-7000066400000000000000000000002041455442221600344410ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("nsid\x06\x00\x01\x00\x02sid\x06A\x00\x00\x12\x00\x01\x00\x03\x00\x01\x00\x02\x00\x01\x00\x02\x00\x01\x00ro")ee6b31168f5497859a0a1a81ef5779ff8e15b5fd-5000066400000000000000000000001031455442221600340310ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("ider\x04\x00roviP\x1cU\x00dr\x04\x00+\x00")f041df0fecb3960fb66df204131b4a4b61bff653-1000066400000000000000000000001031455442221600341070ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i����\xef\xbf\x00\x00\x00\x01\x03")f117c5cd27dcd9566d86d274e3e04357a0a37442-12000066400000000000000000000001661455442221600337270ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("\x04\x00dr\x04\x00rv\x04\x00+r\x04\x00rv\x04\x00+\x00\x04\x00+\x00\x04\x00+\x00\x04\x00+\x00")f180ddb75a3469ea439a7e6311d70eab65a443b6-8000066400000000000000000000001341455442221600337760ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("id\x86\x00\x01\x00\x02si \x06A\x00\x00\x12\x00\x05\x00\x03\x00\x00")f1e6d5ecbcd0ddf1f9b089882a8fff811b92de80-18000066400000000000000000000003461455442221600344720ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i\x00\x01\x00d\x00\x00\xef\xbfder\x04\x00+\x00\b\x00\n\x00\x04\x00+\x00\b\x00\n\x00\x04\x00+\x00\b\x00\n\x00\x04\x00+\x00\b\x00\n\x00 pr\x00\b\x00\n\x00\x04\x00+\x00\b\x00\n\x00\x04\x00+\x00\x04\x00\n\x00")f25e58b7ce5f6cc7619f017769a0bd19b444bc03-2000066400000000000000000000000701455442221600340040ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("psetsockoptuLOCA\x00\x00\n\x00")f2735f718d81afa836a0209e8e898debcd27fbdd-20000066400000000000000000000003541455442221600343250ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte(" prr\x04\x00rv\x14\x00\b\x00\x04\x00\x1e\x00\b\x00\x05\x00\x04\x00\x1e\x00\b\x00\x05\x00\x04\x00\x1e\x00\b\x00\x05\x00\x00\x04\x05\u007f\b\x00\x05\x00\x00\x04\x05\u007f\x0f\x00\x05\x00\x01\x00e\x8c\x01\x00roviP")f2aa540cd3907aca5b6842dfb83bf5bd2ae7b3cc-16000066400000000000000000000001241455442221600345010ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("ider prr\x04\x00rv\x14\x00+\x00\b\x00\x04\x00\x04\x00\xc6r")f43afd8e9ab998563347365720c0326585f8b733-15000066400000000000000000000004551455442221600335410ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x86\x00\x01\x00\x02si\x00\x00\x00@\x00\x12\x00\x00\x00\x12\x00\x00\x00\xbfv\x00\x00\xefv\x00\x00\xef\x12\x00\x00\x00\x10\x00\x00\x00\xbf\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\xbfv\x00\x00\xefv\x00\x00\xef\x12\x00\x00\x00\x10\x00\x00\x00\xbf\x00\x00on\x00\x00\xbf\xc6")f496b3b55ac628c207a9e3ee5ae470ad8e5c79ab-19000066400000000000000000000004301455442221600343140ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i\x00\x01\x00d\x00\x00\xef\xbfder\x04\x00+\x00\b\x00\n\x00\x04\x00+\x00\b\x00\n\x00\x04\x00+\x00\b\x00\n\x00\x04\x00+\x00\b\x00\n\x00 pr\x00\b\x00\n\x00\x04\x00+\x00\b\x00\n\x00\x04\x00+\x00\b\x00\n\x00\x04\x00+\x00\b\x00\n\x00\x04\x00+\x00\x04\x00\n\x00")f4a69f17d31682d0a2c48c58df67f24615fdfb74-11000066400000000000000000000002141455442221600340750ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x06\x00\x01\x00\x02\x03\xe8d\x06A\x17\x00\x12\x00\x00\x00\x02\x00\x0f\x00\x02\x00\x01\x00e\x8c\x01\x00roviP")f5e40c76436723a3a11b5887632d8c63cd2b3811-13000066400000000000000000000001531455442221600335540ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("id\x06\x00\x01\x00p\x02\xe8d\x06A\x04\x00\x12\x00\x00\x00\x03\x00\x00\x00\x03\x00")f8d4cdc60e4fd0c437e3c299b9d8487cca808c59-7000066400000000000000000000001541455442221600341760ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x86\x00\x01\x00\x02sid\x06A\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00")f9057ab7ab481fb2e127a7c7fd34a781c90cbd73-24000066400000000000000000000007171455442221600342300ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04ro\x04\x00dr\x00\n\x00\x1e\x00\t\x00\b\x00\x04\x00\n\x00\xab\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\n\x00\xab\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\x04\x00\n\x1a\xab\x00\b\x00\x1e\x00\b\x00\x04\x00\x04\x00\xab\x00\b\x00\x1e\x00\b\x00\x04\x00\x04\x00\xab\x00\b\x00\x04\x00\x1e\x00\b\x00\b\x00\n\x00\xab\x00\b\x00\b\x00\n\x00\x04\x00+\x00\b\x00\n\x00\x04\x00+\x00\b\x00\n\x00\x04\x00+\x00\b\x00")fb21a374ea4ea877259b9909dfaed6ddffbd0e6e-17000066400000000000000000000002201455442221600345370ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte(" prr\x04\x00rv\x14\x00\b\x00\x04\x00\x1e\x00\b\x00\x05\x00\x00\x04\x05\u007f\x0f\x00\x05\x00\x01\x00e\x8c\x01\x00roviP")fbcaf9e8481b3087e436abea0a1a689593d127a0-17000066400000000000000000000003261455442221600341430ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x06\x00\x01\x00\x02\x03\xe8d\x06A\x16\x00\x01\x00\x01\x00e\x8c\x01\x00rovd\x06A\x17\x00\x12\x00\x00\x00\x01\x00\x0f\x00\x01\x00\x01\x00e\x8c\x01\x00rovsid\x0e\x00\x01\x00\r��~iP")fc2ca55344da18c13ae026c9f438d0726ebd4bfa-2000066400000000000000000000000761455442221600342040ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consider proviZ\x1c\x00\x00\x00@ng a")fd1e3cf101ab3cb4b776d21fd197a50a6aba823c-10000066400000000000000000000002741455442221600343260ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("consid\x86\x00\x01\x00\x18sid\x06A\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00")ff19b3c440695f80ff2b9164083a39c570b199ac-6000066400000000000000000000001651455442221600336600ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i\xef�\xbf\xbd�\xef\xbf\xc6\xef\xbf\x00\x00\x00\xef\xbf\x00\x00\x12\x00\x00\x00\x12\x00")ff28b3e67d9c887abae06eb3b810dc2beb3b41f8-4000066400000000000000000000001661455442221600343650ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("i\xef�\xbf\xbd�\xef\xbf\xc6\xef\xbf\x00\x00\x00\xef\xbf\x00\x00\xbdA\x00\x00\x02\x00\x01")ff4e8e2a7a52611983d6a56d70173d7582c692cf-11000066400000000000000000000003151455442221600337400ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzLinkMessagego test fuzz v1 []byte("�si\x00\x00\x00\x01\x05\x00\x03\x00d\x06C\x05\x00\x03\x00\x00\x00\x12\x00\x05\x00\x03\x00\x00d\x06C\x05\x00\x03\x00\x00\x00\x12\x00\x05\x00\x03\x00\x00d\x06C\x05\x00\x03\x00\x01")golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessage/000077500000000000000000000000001455442221600264715ustar00rootroot0000000000000001a78ee57b268fa9b97b6dc1a5fdfaca2557a16d-5000066400000000000000000000002321455442221600344400ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x05\x80\x01\x00\x00\x00\x01\x00\x03\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00")0e72cbff958c30ceb0e37671e15823581a1d259c-2000066400000000000000000000001521455442221600340520ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x05\x00\x01\x00\x02\x00\x00\x00\x03\x00\x01\x00\x02\x00\x02\x00\x00\x00\x01\x00")116588d53b4140808dd368bef0c913bb9ecf368b-3000066400000000000000000000001401455442221600340570ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\xff\xff\xff\u007f\xbf\xbd\u2ffdH\x00\x02\x00\x00\xef\x00\x00\x00d\xbf")1a812995716a31b14ab967c690456c87fbdc68b2-4000066400000000000000000000002211455442221600337230ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x05\x00[\xff\u007fascii:]\x01\x00\x02\x00\x00\x00\x03\x00\x01\x00\x02\x00\x02\x00@\x00\x00\x00\x00\x03\x00\x01\x00\x01")238e3c0be278f6b203c76143e941ff8ef4e721be-6000066400000000000000000000002241455442221600341440ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x05\x00ҟ\xc6\x01\x00\x02\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x02\x01\x00\x00\x00\x02\x00\x00\x1b\x00\x00\x00\x00\x01")24819fc21a3f6b8a22a759b7b4db16bf3a2d8ba3-1000066400000000000000000000000751455442221600342610ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\xff\xff\xff\u007f\xefjgt\xef3\x03|")24e0485bfa0f89fc0142e2ba2c17becc3c75a515-6000066400000000000000000000002271455442221600342560ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x03\x00\x01\x00\x05\x00d\xbf\x00\x01\x00\x02\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x00")2db20efdef59e82d1d265faaab3392e709edddf2-5000066400000000000000000000001141455442221600345730ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("answerscii:]\n\x00\x02\x00\x00\x00\x03\x00\x01\x00")2f7b9224da4bcdd2a26ce5207ff5e480bcbfab40-2000066400000000000000000000001561455442221600344740ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x05\x00\x02\x00\x00\x00\x00\x02\x00\x01\x00\x02\x00\x00\x00\x00\x02\x00\x00\x02\x00")3d91b97d109c222efc674be1f2f63a8770197394-3000066400000000000000000000001371455442221600337350ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\xd96H@\xa9i\xae\xef\x00\x00\xef\xbf\x00\x00\xff\xec\x00\x00\x00expec")42e474056ab4b03af2d5200be9dc3dc4513008f3-7000066400000000000000000000003101455442221600340160ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x00\x80\x01\x00\x00\x00\x01\x00\x03\x00\x01\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00end ms")48bb9fa084e1f665d4ad3e8042b1ba8a418d4cd3-4000066400000000000000000000001641455442221600342700ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("answerscii:]\x01\x00\x02\x00\x00\x00\x03\x00\x01\x00\x02\x00\x02\x00\x00\x00\a\x02\x00\x00")4b32677ab91fb2bc0420f8e9ab6f7c3de2d770d5-6000066400000000000000000000001731455442221600342770ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\xff\xff\xff\x04\x00\xbf\xbdJ�y\x13\x00��6��\x82\x1b�\x04\x00\xbf\xbd\x04\x00\xbd\xbd")4b68e9dcafe6c8fc6cf4960e9d46c1de8f34dda3-3000066400000000000000000000002121455442221600346220ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x05\x00\x01\x00\x02\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x00\x01\x00\xbe")4c7385125257d4a35c342b9b5bad819625a6e007-5000066400000000000000000000001501455442221600336260ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\b\x00\x01\x00\x02\x00\x01\x00")4e276b5d9a6c84d08f2a936c06d6574e0c33f7c2-2000066400000000000000000000001141455442221600340630ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\xd9\x1eH��H\xef\x00\x01\x00\x00\xbf?\x97\x94`")52347ae850afae853d5b4d72e5da7040b7f50181-5000066400000000000000000000001701455442221600340450ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\b\x00\x01\x00\x02\x00\x02\x00\x00\x00\x01\x00")5b3d0577b262bb027e879c7c6d4506ab23c1575d-4000066400000000000000000000001721455442221600337730ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x05\x80\x01\x00\x00\x00\x01\x00\x03\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00")5b67baeb93297422630def14a2ac3e09e45a77df-5000066400000000000000000000002441455442221600342160ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x05\x00ҟ\xc6\x01\x00\x02\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x02\x01\x00\x00\x00\x02\x00\x00\x1b\x00\x00\x00\x01\x00\x00\x00\x00\x01")5e21ddf1e68bcd868ca36c90d16f853c37be0663-5000066400000000000000000000002651455442221600342340ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x05\x00[\xff\u007fascii:]\x01\x00\x02\x00\x00\x00\x03\x00\x01\x00\x02\x00\x02\x00@\x00\x00\x00\x01\x00\x02\x00\x00\x00\x03\x00\x01\x00\x03\x00\x01\x00\x01")62b8f03ecbcc6b6773d8671b4e640c26d22775fa-3000066400000000000000000000001371455442221600341430ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\xff\xff\xff\u007f�J�y\x13\x00��\xbf\xbd�H\xef\x00\x00\x00d")64da8c7da7aec5d4a4b03547898f79baa5edf893-1000066400000000000000000000000661455442221600344040ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\xd9\x1eH��H�/\xef\xbf")66687e03c6ec2b531ad64624844b04d61de7412a-8000066400000000000000000000003561455442221600337200ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x00\x80\x01\x00\x00\x00\x01\x00\x03\x00\x01\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00�'\xef\xbf")6a4cf91b2ea936d3f25625869822baff674d32b8-1000066400000000000000000000000471455442221600340740ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("SOAResource.N")6bb2583db7f524df91f331bd63b62740109b272d-3000066400000000000000000000001521455442221600337640ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x00\x02\x00\x00\x00\x00\x02\x00\x01\x00\x02\x00\x00\x00\x00\x02\x00\x00\x02\x00")6fbbea3e72b2fbe8e6b44d60670526effbf20976-7000066400000000000000000000001621455442221600343710ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\xff\xff\xff\u007f�J�y\x13\x00��6��\x82\x1b�\x04\x00\xbf\xbd\x04\x00name o")72b14b1baa539d47b17db2bcc19cdf897eaff3dc-3000066400000000000000000000001621455442221600345670ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\xbf\xbd�H\xef\x00\x00\x00\x05\xdd\x01\x00\x00\x00\x01\x00\x03\x00\x01\x00\x00\x00\x00")75602924c84ce99ae3d043a08704d9843702cc03-4000066400000000000000000000002071455442221600335560ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x00d\xbf\x00\x01\x00\x02\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x00\x01")7f12bab997c389aef8a091a7cdfc35e1f04164f4-2000066400000000000000000000001321455442221600343000ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x05\x00\x01\x00\x00\x00\x01\x00\x03\x00\x01\x00\x00\x00\x00\x00")88a063c42663cf9c45a934d2ea1ecf5390dfd84f-6000066400000000000000000000001441455442221600342330ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("answerscii:]\n\x00\x02\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x02\x00")8a6b7b525086b78692c93647330d3f87d43817d7-5000066400000000000000000000002121455442221600335270ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x05\x00\x01\x00\x00\x00\x01\x00\x03\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00")8ec650489564c08030db8c15f27b856bdb3fa443-3000066400000000000000000000001521455442221600337770ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x05\x00\x01\x00\xbe\xbd\xef\x02\xbdHd\x00\x0e\x00\x03\x00\x00\xdd\x02\x04each c")8fa4655c5061fbfc2a6cb7dc3302961210244e94-8000066400000000000000000000003321455442221600337650ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x00\x80\x01\x00\x00\x00\x01\x00\x03\x00\x01\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00")91327662f15e20f5e084c0ec5c791628a5d6f475-4000066400000000000000000000001721455442221600336520ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x05\x00\x01\x00\x00\x00\x01\x00\x03\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00")a2f53468d78087d4776363e0b87d5e3586aa4e5e-12000066400000000000000000000002251455442221600340270ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\xff\xff\xff\u007f�J�y\x13\x00ᅳ�6��\x82\x1b�\x04\x00\xbf\xbd\x04\x00na\x04\x00n\xbd\x04\x00U\xbf\xbd6\xef\xbf")a417d0477189b59441288aa71a977758a6f5e801-7000066400000000000000000000003061455442221600335250ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x05\x00[\xff\u007fascii:]\x01\x00\x03\x00\x01\x00\x03\x00\x01\x00\x02\x00\x02\x00\x01\x00\x02\x00\x00\x00\x03\x00\x01\x00\x02\x00\x00\x00\x03\x00\x01\u007f\xff\x00\x01\x00")a5fd213ad610082a8c252cf015f9982e9918e0f1-3000066400000000000000000000001271455442221600337720ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\xd9\x1eH��H\xef\x00\x01\x009\t\x01\x00\x01\x00?\x97\x94`")a717c3df94896d0a034cb1f3b20f41d9720e162e-7000066400000000000000000000002471455442221600340520ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x05\x00\xd20\xbd\xbf\xef\x9f\xc6\x01\x00\x02\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x02\x01\x00\x00\x00\x02\x00\x00\x1b\x00\x00\x00\x00\x01")aa0520dcf548b4827272abe8be10bae6303c82bb-5000066400000000000000000000001301455442221600342360ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x05\x00\x01\x00\x00\x00\x01\x00\x03\x00\x01\x00\x00\x00\b\x00")aaeb533b0644c19230ffa9b731755b5dc2ce971c-4000066400000000000000000000002141455442221600342000ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\xbf\xbd�H\xef\x00\x00\x00\x05\xdd\x01\x00\x00\x00\x01\x00\x03\x00\x03\x00\x01\x00\x02\x00\x02\x00\x01\x00newlin")b1ae79a8c86f1a20238e842562f2cf08490f31ac-6000066400000000000000000000003231455442221600340530ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x05\x00[\xff\u007fascii:]\x01\x00\x02\x00\x00\x00\x03\x00\x01\x00\x02\x00\x00\x00\x03\x00\x01\x00\x02\x00\x02\x00@\x00\x00\x00\x01\x00\x02\x00\x00\x00\x03\x00\x01\u007f\xff\x00\x01\x00")b2814ca8bf4fb0ed8315734e7a6c2452e7643d30-9000066400000000000000000000002101455442221600340470ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\xff\xff\xff\u007f�J�y\x13\x00��6��\x82\x1b�\x04\x00\xbf\xbd\x04\x00na\x04\x00n\xbd\xbf\xefU\x0f")c31b6907598097b9e2fb6da6b9b379f9f98fc44a-2000066400000000000000000000001441455442221600342020ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x05\x00\x01\x00\xbe\xbd\xef\x02\xbdHd\x00\x00\x00\x03\x00\x00\xdd\x02\x04")c6f996ae51c88e8a89aba0f9d4ada2d5e30c7040-7000066400000000000000000000003361455442221600343710ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x00\x80\x01\x00\x00\x00\x01\x00\x03\x00\x01\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00")c78e559e580e24a44fd25d2578f795c409da973f-8000066400000000000000000000001701455442221600340430ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\xff\xff\xff\u007f�J�y\x13\x00��6��\x82\x1b�\x04\x00\xbf\xbd\x04\x00na\x04\x00na")cf3fea1bd189fd27c4b18effa9aaa3417af24437-7000066400000000000000000000001641455442221600345170ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\b\x00\b\x00\x00\x00\x00\x00\x00\x00\b\x00")d3297da5f2ed35f32ce0994229df07201730006b-5000066400000000000000000000002071455442221600337050ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x05\x00d\xbf\x00\x01\x00\x02\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x00")da39a3ee5e6b4b0d3255bfef95601890afd80709000066400000000000000000000000321455442221600340550ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("")db7f12473f720e27f02ceeda83a2fda358c48707-3000066400000000000000000000001321455442221600342110ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x02\x00\x00\x00\x03\x00\x01\x00\x02\x00\x02\x00\x00\x00\x01\x00")dcf4f2a666e8a75e4325cc3b88367ec37b97df57-6000066400000000000000000000001441455442221600342540ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\b\x00\b\x00\x01\"\x00\x00")dd464b9ba4ce3e03aff4a2d417393b4ec25f3154-4000066400000000000000000000001511455442221600342600ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\xd96H@,\x87x\xa0\xa9i\xae\xef\x00\x00\xef\xbf\x00\x00\xff\xec\x00\x00\x00expec")dd6967827761cebd54631c845929252175ad992b-3000066400000000000000000000001601455442221600336060ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x05\x00[:^ascii:]\x01\x00\x02\x00\x00\x00\x03\x00\x01\x00\x02\x00\x02\x00\x00\x00\x01")de9c6875b2349b3dd6f452a5cc8b045690595cb2-3000066400000000000000000000001521455442221600340710ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x05\x00\x01\x00\x00\x00\x01\x00\x03\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00")e10830c09d7695ff5dca2ff5260a28c8daa13df3-11000066400000000000000000000002101455442221600343410ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\xff\xff\xff\u007f�J�y\x13\x00ᅳ�6��\x82\x1b�\x04\x00\xbf\xbd\x04\x00na\x04\x00n\xbd\x04\x00U\x0f")ec70deabe9b85c7ba0336b9c4420fd898f62cf23-6000066400000000000000000000003161455442221600343670ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x00\x80\x01\x00\x00\x00\x01\x00\x03\x00\x01\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x01\x00\x00\x00\x00\x05\x00\x00\x00\xef")ef2f727c8c113205c64718281071f26df4edac31-4000066400000000000000000000002501455442221600337640ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x05\x00ҟ\xc6\x01\x00\x02\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x02\x01\x00\x00\x00\x02\x00\x00\x1b\x00\x00\x00\x01\x00\x00\x00\x00\x01")f032b7a6a53d3a73744166ded93830c8ba89e3ad-7000066400000000000000000000003611455442221600341420ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x03\x00\x01\x00\x05\x00d\xbf\x00\x01\x00\x02\x00\x00\x00\x02\x00\x00\x00\x01\x05\x00d\xbf\x00\x01\x00\x02\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\xedj")f3ec0ae9b3225c9e3c7dd5e5a74a9c2472d89e72-3000066400000000000000000000001721455442221600343120ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x00\x02\x00\x01\x00\x02\x00\x00\x00\x00\x02\x00\x05\x00\x02\x00\x00\x00\x00\x02\x00\x01\x00\x02")f68990d1d6d67d2f40d37a696971f8f01fd56013-9000066400000000000000000000003321455442221600337510ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x00\x80\x01\x00\x00\x00\x01\x00\x03\x00\x01\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00")f817d027b3c2d941e8908d23273bcb6f53c19c92-8000066400000000000000000000005101455442221600340050ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x00\x80\x01\x00\x00\x00\x01\x00\x03\x00\x01\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x01\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00endend")f8dce948016bb06ace9c55a4bb772e3b55937345-5000066400000000000000000000001501455442221600341450ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\xff\xff\xff\u007f�J�y\x13\x00��6��w\x1b�\x04\x00\xbd�\xbf\xbd")fdd884cbbcebe95c699c81fa8ddb609cf810a6be-2000066400000000000000000000001151455442221600346750ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\xff\xff\xff\u007f\xbf\xbd�H\xef\x00\x00\x00d\xbf")fe97cac1cacfc563b58423f0e06ee4ee46ed1338-1000066400000000000000000000001321455442221600344320ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzNeighMessagego test fuzz v1 []byte("\x05\x00\x01\x00\x02\x00\x00\x00\x03\x00\x01\x00\x02\x00\x01\x00")golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessage/000077500000000000000000000000001455442221600265355ustar00rootroot0000000000000003d7df28102a6fe318669d3f6d04bad62eb97b83-7000066400000000000000000000003441455442221600342130ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x13\xff\u007f\xff\x01\x00\x00\xe66\x00\f\x00\xe62\x92\x9b\x00d\xbe\x00\x00\b\x04\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00SR\x00P\xc6")03d8a259e830a7a36be1b0fa92deeaa87f7d4d76-12000066400000000000000000000003231455442221600345010ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\x00\x01(\x00\b\x00\x00\x00\b\b\x00\x00\x00\xff\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\x01\x00\x00\b\n\x00\x00\x01\b\x00\x00\x01\x00")048b531242649c05a91f36d5e2d172cd205ca821-11000066400000000000000000000003171455442221600337370ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\b\x00\x05\x00\x03\x00\x01\x00\b\x00\x05\x00\x03\x00\x05\x00\b\x00\x05\x00\x03\x00\x01\x00\b\x00\x05\x00\x03\x00\x05\xff\x00\x00\x05\x00")04dd44da76a5494a8815fcccedad2cbce1fcde81-13000066400000000000000000000001611455442221600347730ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\x00#\f\x00\b\x00\x00\x00\x0e\x00\x00\x00\x01\x00")08bde76522a736daffde5481cd7e222ef34324cd-13000066400000000000000000000002721455442221600344230ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x01\x01\x00\x19\x80\b\x00\x00\x00\x01\b\x00\x17\x00\x00\x00\b\x00\b\x00\x17\x00\x00\x00\b\x01\b\x00\x17\x00\x00\x00\x00\x01\b\x00\x17\x00\x00\x00\b\x00")08df73915c72ecaa38851022a4ee2dd353d07d2b-11000066400000000000000000000002161455442221600342430ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00")0929a91de4d9260144a64b23a244b89bbe5ac160-6000066400000000000000000000001701455442221600340240ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\b\x00\x04\x00\x03\x00\x00\x04\x00\x00\x04\x00")09b98a2835a75a833b8243d8b7031982f086fba6-22000066400000000000000000000003131455442221600337730ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\x00[\x01\x00\x03\b\x04\x17\x80\xff\x00\b\x00\x01\x00\x03\x00\x01\x00\b\x00\a\x00\x01\xf5\x01#\f\x00\t\x00\b\x00\x00\a\xe0\x00\x00\x01\b\x00\x05\x00\x00\x06\n\x01\x00\x00\b\x00")0a29ab41efac4ac8f0e2d194f51499978dfee03d-11000066400000000000000000000002341455442221600345050ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x02\x00\x01\x00\xff\x00\x00\b\x00\x00\x00\x01\x05\x00\x14\x00\x00\x00\x00\x01\x05\x00\x14\x00\x00\x00\x00\x01\x05\x00\x14\x00\x00")0a2b2ef82bdc86e216519b446c3a5f7e84343f24-7000066400000000000000000000001241455442221600341210ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\x00\x01N\x00\x00\x01\x00\x02\xe2\x01\x01\x00\x00\x0f\x00")0a734b09bdba7d2bd50ece42bbeb72c51bc4a7d6-16000066400000000000000000000003201455442221600346650ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x01\x00\u007f\x00\x00\b\x00\x00\x00\x01\b\x00\x0f\x00\x00\x00\x00\x01\b\x00\x0f\x00\x00\x02\x00\x01\b\x00\x0f\x00\x00\x00\x00\x01\b\x00\x0f\x00\x0f\x00\x00\x00\x00\x01\b\x00")0b3c47c3f9e4542cd4cec7317024347517f0f50c-5000066400000000000000000000002321455442221600340300ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x80\x00\x00\x00\x00\x01\x00\x03\x00\x01\xfa\xff\x14\x00\x01\x00\x01\x00\x02\x00\x01\x00\x03\x00\x03\x00\x01\xdf\x03\x00\x01\x00")0c19ce60bca179aba79b494d1673b38e6c960f1c-13000066400000000000000000000010641455442221600343440ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x01\x01\x00\x00\x00\x01\x00\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\x19\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\x00\x00\b\x00\x00\x01")0cd2d96deaf5968d4da5716d5c71ef97ebc0e32a-15000066400000000000000000000003251455442221600345770ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00d\b\x00\a\x00\x03\x00\x00\x00d\b\x00\a\x00\x03\x00\x00\x00\b\x00\a\x00\x03\x00\x01\x00\b\x00\a\x00\x00\x00\x00d\b\x00\a\x00\x03\x00\x01\x00\b\x00\a\x00\x00\x00\b\x00\x00\b\x00\x00")0ee7c738bafd0eb60fbd14d671827afc35a31ac5-16000066400000000000000000000003361455442221600345520ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\\\xffd\b\x00\a\x00\x03\x00\x00\x00d\b\x00\a\x00\x03\x00\x00\x00\b\x00\a\x00\x03\x00\x01\x00\b\x00\a\x00\x00\x00\x00d\b\x00\a\x00\x03\x00\x01\x00\b\x00\a\x00\x00\x00\x00d\b\x00\a\x00\x00\b\x00\x00")0f133444ab840e054b884d88704de17a24439180-14000066400000000000000000000005361455442221600336220ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\xff\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x01\x05\x00\x14\x00\x00\x00\x00\x01\x05\x00\x14\x00\x00\x00\x00\x01\x05\x00\x14\x00\x00\x00\x00\x01\x05\x00\x14\x00\x00\x00\x00\x01\x05\x00\x14\x00\x00\x00\x00\x01\x05\x00\x14\x00\x00\x00\x00\x01\x05\x00\x14\x00\x00\x00\x00\x01\x05\x00\x14\x00\x00\x00\x01\x01\x05\x00\x14\x00\x00")0f3806b89153fa6458e4f0383795db36f61c5c1f-16000066400000000000000000000003561455442221600340710ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00#\f\x00\b\x00\b\x00\v\x00\x00\x00\x00#\f\x00\b\x00\b\x00\v\x00\x00\x00\x00#\f\x00\b\x00\b\x00\v\x00\x00\x00\x00#\f\x00\b\x00\b\x00\v\x00\x00\x00\x00\x00\x00\x01\xbd\xbf")10af79ec941d0383d9ca28f0b4cdc421bdcc635f-14000066400000000000000000000001571455442221600344750ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00#\f\x00\b\x00\b\x00\v\x00\x00\x00\x01\x00")11b009f50bb7ad0f7c669de540374853ca2677f7-20000066400000000000000000000004461455442221600341270ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x00@\x00\x00\x00\x00\x00#\f\x00\b\x00\b\x00\f\x00\x00\x00\x00#\f\x00\b\x00\b\x00\f\x00\x00\x00\x00#\f\x00\b\x00\b\x00\f\x00#\f\x00\b\f\x00\b\x00\b\x00\f\x00\x00\x00\x00#\f\x00\b\x00\b\x00\f\x00\x00\x00\x00#\f\x00\b\x00\b\x00\f\x00#\f\x00\b\f\x00\b\x00")12b5cef05c76f45eacc26e14843d7530c9ab96b4-1000066400000000000000000000000551455442221600342560ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("Q��Ӯ��\xef")1406e50fddac3f912bf88bf66527e9d93dcd2813-15000066400000000000000000000002761455442221600343650ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\x00\x01\b\x00\x0f\x00\x00\x00\x00\x01\b\x00\x17\x00\x00\x00\x00\x01\b\x00\x10\x00\x00\x00\x00\x01\b\x00\x06\x00\x00\x00\b\x00")1535d65b2996588ad5fa5d2399612d436b9b178b-9000066400000000000000000000001641455442221600337370ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\xa4\x01\x00\x02\x00\x01\x00\x03\x00#\x00\r\x00\t\x00\x00\x04\x03\x00\x01\x01\x03\xbf\xff")16ed44a258bfdc95d7105f25a94687f52cdc0673-1000066400000000000000000000001011455442221600341230ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x16\x02\xf7\x91Iw\xd5B\x9c\x97\xad\xec")16fe11a68ae650350409ddf6a6f7ba3d0175f646-3000066400000000000000000000001671455442221600341220ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\x00\x00\x01\x00\x03\x00\x01\x00\x00\x00\x01\x00")178632fc18a458cf2aad6e39ab536802b8b9c6a2-13000066400000000000000000000004521455442221600342650ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x01\x01\x00\x00\x00\x01\x00\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00")19ded5cdb48e1a07d5e4723198e06fdbcc02cbe1-13000066400000000000000000000002051455442221600345470ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\x00[\x01\x00\x03\b\x04\x00\x00\x00d\b\x00\a\x00\x03\x00\x01\x00\b\x00\a\x00\x00\x00\b\x00\x00\x00\x01\x00")1a9f2207eaa2c051903509690721b5b35507fb84-7000066400000000000000000000002061455442221600336040ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x01@\x02\x00\x01\x00\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\x01\b\x00SRV")1ab3bde60aeee99dfa2d3e67aeb94699686c0399-16000066400000000000000000000010501455442221600345310ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x01\x01\x00\x00\x00\x01\x00\x00\x00\x00\x01\x00\x00\x88\x01\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\b\x00\x00")1b2acee3247fc46ba395a9d23326ec8ebe66b113-14000066400000000000000000000002561455442221600344140ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\x00\x01\b\x00\x0f\x00\x00\x00\x00\x01\b\x00\x10\x00\x00\x00\x00\x01\b\x00\x0f\x00\x00\x00\x00\x01\b\x00\x00\b")1d19326c3c9d31eb30426b7a680732b5a93b4eeb-18000066400000000000000000000002731455442221600341740ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x01\xf1\x1d\x00\x00\x00\x00#\f\x00\t\x00\b\x00\x00\x00\x00\x00\x00#\f\x00\t\x00\b\x00\v\x00\x00\xf5\x01#\f\x00\t\x00\b\x00\x00\x00\x00\x00\b\x00")1e0cc70ec08b5bc788434d3711048ac63ccc83ed-10000066400000000000000000000003551455442221600343300ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\x00\x00\x00\xe7\x00\x00\x00\x00\x00\x00\x01\b\x00\x04\x00\x03\x00\x00\x01\b\x00\x04\x00\x00\x00\x00\x01\b\x00\x04\x00\x03\x00\x00\x04\b\x00\x04\x00\x03\x00\x00\x01\b\x00\x04\x00\x03\x00\x00\x04\x00\x00\x04\x00")1e1baa74e93f9f4fc404eeadd5584996f6621663-12000066400000000000000000000003221455442221600343030ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03 \x01\x01\x00\x00\x00\x00\x00\x00\x00\x01(\x00\b\x00\b\x00\b\x00\b\x00\x00\xff\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\x01\b\x00\x00\x01\x00")1e608ee0455c35ea247392d523548023732d4418-6000066400000000000000000000002541455442221600334610ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x13\xff\u007f\xff\x01\xe9\xff\xe56\x00\f\x00\x00\x00\x00\x9b\xbd\x89\xbe\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00SR\x00P")1f3d10553768eca649fa60dc4c4d34fdf85f0094-11000066400000000000000000000002021455442221600342600ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x01\x01\x00\x19\x80\b\x00\x00\x00\x01\b\x00\x17\x00\x00\x00\x00\x01\b\x00\x17\x00\x00\x00\b\x00")1f406efa874f3bd14528dcbf4a8b0fdc22aa73e1-3000066400000000000000000000002311455442221600344600ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x13\xff\u007f\xff\x01\x00\x00\xe66\x00\f\x00\xe62\x92\x9b\xbd\x89\xbe\x00\x02\x00\x00\x00\x00\x00\x04\x00\x00SR\x00P\xc6")214848111cc8bffb5195e46807d333cb5a03ef04-10000066400000000000000000000002611455442221600341050ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\b\x00\x05\x00\x03\x00\x01\x00\b\x00\x05\x00\x03\x00\x01\x00\b\x00\x05\x00\x03\x00\x05\xff\x00\x00\x05\x00")21556da7c114b050e80fc1d4321634e12b0ed060-15000066400000000000000000000002251455442221600337740ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x00@\x00\x00\x00\x00\x00#\f\x00\b\x00\b\x00\x0e\x00\x00\x00\x00#\f\x00\b\x00\b\x00\x0e\x00\x00\x00\x01\x00")2217804429294cc73a19c314ee12ee857954396c-20000066400000000000000000000002571455442221600336410ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\x00[\x01\x00\x03\b\x04\x17\x80\xff\x00\b\x00\x01\x00\x03\x00\x01\x00\b\x00\a\x00\x01\xf5\x01#\f\x00\t\x00\b\x00\x00\x00\x00\x06\n\x01\x00\x00\b\x00")23fec56e989465f14d4200d67b1c3cf3d1cf802c-3000066400000000000000000000001021455442221600341730ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("QQ\xef\xbf��\x00\x01\x00\x00\xbd\xef")247381ad62228d98975f619602d70df7a7ac8221-6000066400000000000000000000002321455442221600336370ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x80\x00\x00\x00\x00\x01\x00\x03\x00\x01\xfa\xff\x14\x00\x01\x00\x00\x00\x02\x00\x01\x00\x03\x00\x03\x01\x01\xdf\x03\x00\x01\x00")2485b6955408f3646e20fba7b7ed3118393efc78-7000066400000000000000000000001451455442221600340110ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\b\x00\x04\x00\x03\x00\x05\xff")253c8a65e8611f06178a69a590ba57187fb1c4f3-12000066400000000000000000000004661455442221600340570ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x01@\x02\x00\x01\x00\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\x01\x00\x00\b\x0e\x00\x00\x01\b\x00\x00\x00\b\x00\x00\x00\x01\x00\x00\b\x0e\x00\x00\x01\b\x00\x00!\x00")263b6e783270cf25bb87da132856b36b72deb465-8000066400000000000000000000001501455442221600340450ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x01@\x02\x00\x01\x00\x03\x00\x01\x01\x00\x00\b\x00\x00\x00\b\x00\x00SRV")2665491b00cae87014bdef90db18c9cc579ff402-18000066400000000000000000000002301455442221600342630ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x01\x00\x00\x00\x00\x00\x00#\x18\x00\t\x00\b\x00\x00\x00\x00\x00\x00#\f\x00\t\x00\b\x00\v\x00\x00\x00\x15\x00")2908abe986a855bc2f52868af5144469fadf3522-18000066400000000000000000000004561455442221600341570ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\f\x00\b\x00\b\x00\x0e\x00\x00\x00\x01#\f\x00\b\x00\b\x00\x0e\x00\x00\x00\x00#\f\x00\b\x00\b\x00\x0e\x00\x00\x00\x00#\f\x00\b\x00\b\x00\x0e\x00\x00\x00\x00#\f\x00\b\x00\b\x00\x0e\x00\x00\x00\x01#\f\x00\b\x00\b\x00\x0e\x00\x00\x00\x00#\f\x00\b\x00\b\x00\x0e\x00\x00\x00\x01\x00")2a7727f0f7b34f24516ca2314f71ff0d85585da8-11000066400000000000000000000001441455442221600341240ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\x00\x01\b\x00\x10\x00\x00\x00\b\x00")2c52383aca9d00f291c7bec507e266e79cb0822b-19000066400000000000000000000004241455442221600342600ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x01\xf1\x1d\x00\x00\x00\x00#\f\x00\t\x00\b\x00\x00\x00\x00\x00\x00#\f\x00\t\x00\b\x00\x1a\x00\x00\xf5\x01#\f\x00\t\x00\b\x00\x00\x00\x00\x00\b#\f\x00\t\x00\b\x00\x1a\x00\x00\xf5\x00#\f\x00\t\x00\b\x00\x1a\x00\x00\xf5\x01#\f\x00\t\x00")2d7b25367948b2ab3348a4a0221dd1ab7bb97640-13000066400000000000000000000001571455442221600341040ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\x00#\f\x00\b\x00\x00\x00\f\x00\x00\x00\x01\x00")2dc32992ee4125ab26886daa3c77a5a940167a3e-16000066400000000000000000000002741455442221600342050ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00@\x00\x00\x00\x00\x00\x00\x00\x00\x00#\f\x00\b\x00\b\x00\x0e\x00\x00\x00\x01#\f\x00\b\x00\b\x00\x0e\x00\x00\x00\x00#\f\x00\b\x00\b\x00\x0e\x00\x00\x00\x01\x00")3024170af8c1e71cb4db7c1842c363f4e60ae71b-14000066400000000000000000000003421455442221600342360ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\b\xf7\x00\x00\x00\b\x00\x00\x00\x00\b\x00\x01\x00\x00\b\x00\x01\b\x00\x01\x00\x00\b\x00\x00\b\x00\x01\x00\x00\b\x00\x00\b\x00\x01\x00\x00\b\x00\x00\b\x00\x01\x00\x00\b\x00\x00\x00\x00\x01\x00")312f48386c485177e75755d670c015454d448593-8000066400000000000000000000004101455442221600333520ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x01\x00\b\x00\x00\x00\x1c\x01\x00\x00\b\x00\x06\x00\x00\x00\x00\x01\b\x00\x06\x00\x00\x01\x00\x00\b\x00\x06\x00\x00\x00\x00\x01\b\x00\x06\x00\x00\f\x00\xe6\b\x00\x06\x00\x03\f\x00\xe6\b\x00\x06\x00\x03\x00\x00\x04\x00\x00\x06\x00")31cf3639ca482484323d1cb3026769a11b9f0e06-4000066400000000000000000000001301455442221600336610ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x03\x00\x02\x00\x01\x00\x03\x00\x01\x00\x00\x00\x14\x00")31ec62b95c0502267680be0699244088ffcba8da-15000066400000000000000000000001561455442221600341300ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x00@\x00\x00\x00\x00\x00#\f\x00\b\x00\b\x00\x02\x00\x00\x00\x01\x00")31f3e65213ed3b94209cb9045ba89627b73f8d7d-9000066400000000000000000000002531455442221600340620ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x01@\n\x00\x01\x00\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\x00\x01\x00\x00\x00\x01\b\x00\x00\x01\x00\xe2\b\x00\x00\x00\x01\b\x00\x00\x01\x00")3430a9f65fc7ddb5540e41a4b9a5f88675085cba-10000066400000000000000000000002241455442221600342640ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\\\xff\xff\xff\u007f\x01\x00\x03\x00\x01@\xff\x14\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\xea\x03\x00\x01@\xff\x14\x00")352173e067070bae811791181ce71d55fedb1b18-15000066400000000000000000000003201455442221600340240ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\\f\x00\x00\x00\x01\x00\x03\x00\x01@\xff\x14\x00\x01\x00\x01 \x03\x00\x03\x01\x01\xdf\x03\x00\x00\x00\x00\x00\x00\x01\b\x00\x0f\x00\x00\x00\x00\x01\b\x00\x10\x00�\x10\x00\x00\b\x00")3808b96f1f76dd1a1f630391bdd0eac769aecb86-12000066400000000000000000000002021455442221600344210ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\x00\x01\b\x00\x10\x00\x00\x00\x00\x01\b\x00\x10\x00\x00\x00\b\x00")380f7a27641588baf7dbddeda8dc501ca50d9b5c-8000066400000000000000000000001431455442221600345020ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\x00\x01\x00\x03\x00\x01\x00\x03\x00\x01\x00\b\x00\a\x00\x02\x00\x05\xff")3ccf2a7d1902dcee6d7ff47e4ab9d627eb15e150-14000066400000000000000000000010441455442221600345630ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x01\x01\x00\x00\x00\x01\x00\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\x19\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\x00\b")3d453ae3499bf809d1c05d118265c97a757dac42-4000066400000000000000000000001661455442221600340540ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\x00\x01\b\x00\x06\x00\x03\x00\x00\x04\x00\x00\x04\x00")3e929826ce34091800b8d2ec3d99a57ac909574b-14000066400000000000000000000001561455442221600340670ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x00@\x00\x00\x00\x00\x00#\f\x00\b\x00\b\x00\x0e\x00\x00\x00\x01\x00")403661816ef8c211682960c6bd59e13364455388-19000066400000000000000000000004051455442221600335060ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x00@\x00\x00\x00\x00\x00#\f\x00\b\x00\b\x00\f\x00\x00\x00\x00#\f\x00\b\x00\b\x00\f\x00\x00\x00\x00#\f\x00\b\x00\b\x00\f\x00#\f\x00\b\f\x00\b\x00\b\x00\f\x00\x00\x00\x00#\f\x00\b\x00\b\x00\f\x00\x00\x00\x00\b\x00\f\x00#")40d5057aa8ffac08d7724c84d26fdf2c13d13a7e-9000066400000000000000000000002171455442221600343420ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\\f\x00\x00\x00\x01\x00\x03\x00\x01@\xff\x14\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x03\x00\x01@\xff\x14\x00")424d44f3ee09bd05fbc9d4eff495dc5a05a22cba-8000066400000000000000000000002371455442221600345600ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\\f\x00\x00\x00\x01\x00\x03\x00\x01@\xff\x14\x00\x01\x00\x00\x00\x00\x00\x01 \x03\x00\x03\x01\x01\xdf\x03\x00\x00\x00\x00\x00\x01\x00")44fedff760de6c6ccad5e99f77995ca7027ed476-15000066400000000000000000000002121455442221600345460ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\x00[\x01\x00\x03\b\x04\x17\x80\xff\x00\b\x00\x01\x00\x03\x00\x01\x00\b\x00\a\x00\x02\x00\xbd\x10\x00\x00\b\x00")4645c742dcb8d8dce4a57e435fdef69332184d59-14000066400000000000000000000002701455442221600343120ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\x00[\x01\x00\x03\b\x04\x00\x00\x00d\b\x00\a\x00\x03\x00\x01\x00\b\x00\a\x00\x00\x00\x00d\b\x00\a\x00\x03\x00\x01\x00\b\x00\a\x00\x00\x00\b\x00\x00\b\x00\x00")4696ef8f2d4535d24700ae02e916b57b487a7968-18000066400000000000000000000003341455442221600340170ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x00@\x00\x00\x00\x00\x00#\f\x00\b\x00\b\x00\f\x00\x00\x00\x00#\f\x00\b\x00\b\x00\f\x00\x00\x00\x00#\f\x00\b\x00\b\x00\f\x00#\f\x00\b\f\x00\b\x00\b\x00\f\x00#\f\x00\b\x00\b\x00\f")46a4cc94e2a8f1e1e16e56c07d170229d948791f-13000066400000000000000000000002021455442221600341310ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\x00\x01\b\x00\x0f\x00\x00\x00\x00\x01\b\x00\x10\x00\x00\x00\b\x00")46bc84ae594755bd326ddb95a7891dd687d94fd5-10000066400000000000000000000002021455442221600343140ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\x01\x00")46dae0ef99d636a03fd2c9fa8d7e55426c450b3c-6000066400000000000000000000002241455442221600343520ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x01\x01\x00\x00\x00\b\x00\x00\x00\x01\b\x00\x06\x00\x00\x00\x00\x01\b\x00\x06\x00\x03\x00\x00\x04\x00\x00\x06\x00")48dd9eeb6a5743e939aad24b5ee75b78ce01291f-23000066400000000000000000000003511455442221600344430ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\x00[\x01\x00\x03\b\x04\x17\x80\xff\x00\b\x00\x01\x00\x03\x00\x01\x00\b\x00\a\x00\x01\xf5\x01#\f\x00\t\x00\b\x00\x00\a\xe0\x00\x00\x01\b\x00\x05\x00\x00\x00\x00\x01\b\x00\x0f\x00\x00\x06\n\x01\x00\x00\b\x00")494b53eb91ebfb8967de724740d392dbe1033c0c-7000066400000000000000000000002271455442221600342110ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x01@\x02\x00\x01\x00\x03\xe0\x01\x01\x00\x00\x00\b\x00\x00\x00\x01\x00\x00\x00\"\x00\x00\x00\x00\x00\x00\b\x00\b\x00SR")4958b1d1aac27443dbb47f00e32c4a55032b4e7a-11000066400000000000000000000003251455442221600342270ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\x00\x01(\x00\b\x00\x00\x00\b\b\x00\x00\x00\xff\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\x01\b\x00\x00\x01\x00")4a5e40f9b909799db2ad00e12a7a4ab9fa219c5a-4000066400000000000000000000001651455442221600343340ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\x00\x01\x00\x02\x00\x01\x01\x03\x00\x00\x00\b\x00\x01\x00\x03\x00\x05\x00\x00\x00\x01\x00")4a7a2308e96eb46f9284d29a405de384d37ac6b7-21000066400000000000000000000004531455442221600342200ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x01\xf1\x1d\x00\x00\x00\x00#\f\x00\t\x00\b\x00\x1d\x00\x00\x00\x00#\f\x00\t\x00\b\x00\x00\x00\x00\x00\x00#\f\x00\t\x00\b\x00\x1a\x00\x00\xf5\x01#\f\x00\t\x00\b\x00\x00\x00\x00\x00\b#\f\x00\t\x00\b\x00\x1a\x00\x00\xf5\x00#\f\x00\t\x00\b\x00\x01#\f\x00\t\x00")4a8c4575f073d0571e093ca09aaccafb3a5e2b93-1000066400000000000000000000000471455442221600343220ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte(".in-addr.arpa")4e3424e8ef7167660ae3637af831646ded7a5c41-16000066400000000000000000000011221455442221600341350ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x01\x01\x00\x00\x00\x01\x00\x00\x01\b\x00\x10\x00\x00\x00\x00\x01\b\x00\x10\x00\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\b\x00")4f812e9d34f7456cb4fd17ec8602ff067d25ed91-18000066400000000000000000000003641455442221600343150ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x00@\x00\x00\x00\x00\x00#\f\x00\b\x00\b\x00\x02\x00\x00\x00\x00#\f\x00\b\x00\b\x00\x02\x00\x00\x00\x00#\f\x00\b\x00\b\x00\x02\x00\x00\x00\x01\x00\f\x00\b\x00\b\x00\x02\x00\x00\x00\x00\x00\x00\x01\x00\f")50c1fac0b2b6dd5399d3433d50a7486492196ad7-15000066400000000000000000000010461455442221600341240ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x01\x01\x00\x00\x00\x01\x00\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\b\x00\x00\x01")50c5a82d9f859fab5a63f93fb2d53755539d0687-21000066400000000000000000000003131455442221600341510ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\x00[\x01\x00\x03\b\x04\x17\x80\xff\x00\b\x00\x01\x00\x03\x00\x01\x00\b\x00\a\x00\x01\xf5\x01#\f\x00\t\x00\b\x00\x00\a\xe0\x00\x00\x01\b\x00\x0f\x00\x00\x06\n\x01\x00\x00\b\x00")510f0488fd72536c7951f87f1f39e0ad984e30d9-24000066400000000000000000000005761455442221600341070ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\f\x00\t\x00\b\x00\x00\x00\x00\x00\x00#d\x00\t\x00\b\x00\x1a\x00\x00\xf5\x01#\f\x00\t\x00\b\x00\x00\x00\x00\x00\b#\f\x00\t\x00\b\x00\x00#\x00\x00\x00#\f\x00\t\x00\b\x00\x1d\x00\x00\x00\x00#\f\x00\t\x00\b\x00\x00\x00\x00\x00\x00#\f\x00\t\x00\b\x00\x1a\x00\x00\x00\x01#\f\x00\t\x00\b\x00\x00\x00\x00\x00\b#\f\x00\t\x00\b\x00\x1a\x00\x00\xf5\f\x00\t\x00\b\x00")5127567353b3506600f4569949652767207cfb38-2000066400000000000000000000001771455442221600332720ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x13\xff\u007f\xff\x01\x00\x02\xff\xe6\x00\f\x00\xe66\x92\x9b\xbd\x89\xbe\x00\x02\x00P\xc6P\xef")5189d1cc0aca4c795376bd06929e6925b7b2879b-5000066400000000000000000000001411455442221600340630ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x81N\x02\x00\x01\x00\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\b\x04")5200c84e19de10a0892651c6e376297e997a8a15-20000066400000000000000000000004041455442221600337120ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x01\xf1\x1d\x00\x00\x00\x00#\f\x00\t\x00\b\x00\x00\x00\x00\x00\x00#\f\x00\t\x00\b\x00\x1a\x00\x00\xf5\x01#\f\x00\t\x00\b\x00\x00\x00\x00\x00\b#\f\x00\t\x00\b\x00\x1a\x00\x00\xf5\x00#\f\x00\t\x00\b\x00\x01#\f\x00\t\x00")5368a648b9df576cfec09bbcad28b8b3a23e5543-10000066400000000000000000000002561455442221600344340ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x01\x00\x03\x00\x01\x01\x00\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x01\x00\x00")55ec8d9880b929551028d496beb638aa60f863ee-3000066400000000000000000000001301455442221600340660ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x03\x00\x02\x00\x01\x00\x03\x00\x01\x00\x00\x00\x10\x00")55fbbc10b9a6d51ad9c3b3998a0e8f183f27a611-11000066400000000000000000000001671455442221600343420ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\x00[\x01\x00\x03\b\x04\x00\x00\x00d\b\x00\a\x00\x03\x00\x01\x00\b\x00\a\x00\x02\x00\x05\xff")562852d6b1d69da6b9bb7ab787d1bc32663985c1-11000066400000000000000000000002161455442221600342140ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\b\x00\x01\x00\x00\b\x00\x00\x00\x01\b\x00\x01\x00\x00\b\x00\x00\b\x00\x01\x00\x00\b\x00\x00\x00\x00\x01\x00")574f47974ca40d8827bfb747ee217f34c28bab7f-10000066400000000000000000000001741455442221600343060ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x02\x00\x01\x00\xff\x00\x00\b\x00\x00\x00\x01\x05\x00\x14\x00\x00\x00\x00\x01\x05\x00\x14\x00\x00")575ad01d44856ee0cf3ac75acf11dcd8858d59a0-6000066400000000000000000000001511455442221600343430ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x01N\x02\x00\x01\x00\x03\x00\x01\x01\x00\x00\x00\x80\x00\x00\x00\x00SRV ")591c6aea5a0f67e2978fb973163038599f8448b2-15000066400000000000000000000001551455442221600340240ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00#\f\x00\b\x00\b\x00\b\x00\v\x00\x00\x00")5a5f9c7e160e624bc8be309b2070dff1b1c95a0a-12000066400000000000000000000002521455442221600344020ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\b\x00\x01\x00\x00\b\x00\x00\x00\x00\b\x00\x01\x00\x00\b\x00\x01\b\x00\x01\x00\x00\b\x00\x00\b\x00\x01\x00\x00\b\x00\x00\x00\x00\x01\x00")5ad6b538c56663329f696a04ffc0c7a34d7ee188-12000066400000000000000000000003551455442221600342270ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\b\x00\x05\x00\x03\x00\x01\x00\b\x00\x05\x00\x03\x00\x01\x00\b\x00\x05\x00\x03\x00\x05\x00\b\x00\x05\x00\x03\x00\x01\x00\b\x00\x05\x00\x03\x00\x05\xff\x00\x00\x05\x00")5df65977b4fdfcd774c9b0dc434c268f32c6a3bd-10000066400000000000000000000001441455442221600345160ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x01\x01\x00\x19\x80\b\x00\x00\x00\x01\b\x00\x17\x00\x00\x00\b\x00")5e06cd61799e8e2f302b6885ffe3c46d7e658a4a-10000066400000000000000000000003371455442221600343160ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x01@\x02\x00\x01\x00\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\x01\b\x00\x00\x01V\xa33\xa6\x82")5f05d7f6c5411e98d4b51f16ad6130b13a9aeef7-14000066400000000000000000000003261455442221600343420ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x01\x01\x00\x19\x80\b\x00\x00\b\x00\b\x00\x17\x00\x14\x00\x00\x01\b\x00\x17\x00\x00\x00\b\x00\b\x00\x17\x00\x00\x00\b\x01\b\x00\x17\x00\x00\x00\x00\x01\b\x00\x17\x00\x00\x00\b\x00")5f13d3829b9e78cb1b12e8b021822f06ed4fa136-5000066400000000000000000000002441455442221600341150ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x13\xff\u007f\xff\x01\x00\x00\xe66\x00\f\x00\xe62\x92\x9b\x00d\xbe\x00\x00\b\x04\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00SR\x00P\xc6")60f5868244a6a03e21d6bf514f814d97710b15eb-17000066400000000000000000000002301455442221600340360ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x01\x00\x00\x00\x00\x00\x00#\x18\x00\t\x00\b\x00\x00\x00\x00\x00\x00#\f\x00\t\x00\b\x00\v\x00\x00\x00\x01\x00")639c021eb8cb00e666d854bd65a382512a0d20b4-11000066400000000000000000000002241455442221600340710ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\\\xff\xff\xff\u007f\x01\x00\x03\x00\x01@\xff\x14\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01@\xff\x14\x00")655bed9cec67a8396b46b303b5645b813eee6ae2-15000066400000000000000000000002441455442221600343570ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00#\f\x00\b\x00\b\x00\v\x00\x00\x00\x00#\f\x00\b\x00\b\x00\v\x00\x00\x00\x00\x00\x01\xbd\xbf\xef")6580ab04dfe857dcb39e3c394c60ecbcc0d5fec1-6000066400000000000000000000001451455442221600345610ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\b\x00\x05\x00\x03\x00\x05\xff")6624a6bbb276ca8eaf672abdbb9436267aca4e6c-8000066400000000000000000000003001455442221600344720ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x13\xffo\xff\x01\xe9\xff\xe56\x00\f\x00\x00\x00\x00\x9b\xbd\x89\xbe\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00")665d6d3c5e22e55aa3f5c6b8ff4e7634cfe07013-8000066400000000000000000000002641455442221600342760ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x00\xe7\x00\x00\x00\x00\x00\x00\x01\b\x00\x04\x00\x00\x00\x00\x01\b\x00\x04\x00\x03\x00\x00\x01\b\x00\x04\x00\x03\x00\x00\x04\x00\x00\x04\x00")67bc350b4396d73cc4680c9feeb4f838fa45da1a-17000066400000000000000000000004571455442221600344450ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\\\xffd\b\x00\a\x00\x03\x00\x00\x00d\b\x00\a\x00\x03\x00\x00\x00\b\x00\a\x00\x03\x00\x01\x00\b\x00\a\x00\x00\x00\x00d\b\x00\a\x00\x03\x00\x00\x00\b\x00\a\x00\x03\x00\x01\x00\b\x00\a\x00\x00\x00\x00d\b\x00\a\x00\x03\x00\x01\x00\b\x00\a\x00\x00\x00\x00d\b\x00\a\x00\x00\b\x00\x00")68d068b13deeb0c5eb39baca45c4cde9c096236b-9000066400000000000000000000003221455442221600344770ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x00\xe7\x00\x00\x00\x00\x00\x00\x01\b\x00\x04\x00\x00\x00\x00\x01\b\x00\x04\x00\x03\x00\x00\x04\b\x00\x04\x00\x03\x00\x00\x01\b\x00\x04\x00\x03\x00\x00\x04\x00\x00\x04\x00")69966d08607c6dcabb932a498fc9d3fc31b399bc-18000066400000000000000000000002301455442221600343710ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x01\x00\x00\x00\x00\x00\x00#\x18\x00\t\x00\b\x00\x00\x00\x00\x00\x00#\f\x00\t\x00\b\x00\v\x00\x00\x00\x16\x00")6ab8741bf0e62712c335565318c7f7f4b0f68c4b-2000066400000000000000000000001521455442221600340430ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x03\x00\x02\x00\x01\x00\x03\x00\x01\x00\x02\x00\x01\x00\xff\xff\u007f\xff")6ad83f353cd1a316d365061968fff446e483843b-13000066400000000000000000000010641455442221600340610ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x01\x01\x00\x00\x00\x01\x00\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\x19\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\x01\xfa\x00\x00\xfa\x00\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\x00\x00\b\x00\x00\x01")6c491717285f967c34c7749b408f19b6e879964d-7000066400000000000000000000002221455442221600336230ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\\f\x00\x00\x00\x01\x00\x03\x00\x01@\xff\x14\x00\x01\x00\x00\x00\x00\x00\x01\x00\x03\x00\x03\x01\x01\xdf\x03\x00\x01\x00")6dfe5412438c71bb659a48065843aa956b48da3b-15000066400000000000000000000003561455442221600341370ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x01\x00\u007f\x00\x00\b\x00\x00\x00\x01\b\x00\x0f\x00\x00\x00\x00\x01\b\x00\x10\x00\x00\x00\x00\x01\b\x00\x0f\x00\x00\x00\x00\x01\b\x00\x10\x00\x00\x00\x00\x01\b\x00\x0f\x00\x0f\x00\x00\x00\x00\x01\b\x00")6e6c74275b9a662584851823631c4a204c936495-3000066400000000000000000000002101455442221600334130ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x01\x02\x00\x01\x00\x03\x00\x01\xfa\xff\x01\x00\x01\x00\x03\x00\x01\x00\x03\x00\x01\x00\x01\x01\x00\x00")6f6f04fb565bf694d00ebc0e6693c79cac2e7506-10000066400000000000000000000002501455442221600343500ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\xa4\x01\x1b\x02\x00\x01\x00\x03\x00#\x00\x00\x00\t\x00\x00\x00\t\x00\x00\x00\t\x00\x00\x00\t\x00\x00\x00\t\x00\x00\x00\t\x00\x01\x01\x03\xbf")6fb6588cdf0bd1753bef987b5404e05070b39053-13000066400000000000000000000003061455442221600341270ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\b\xf7\x00\x00\x00\b\x00\x00\x00\x00\b\x00\x01\x00\x00\b\x00\x01\b\x00\x01\x00\x00\b\x00\x00\b\x00\x01\x00\x00\b\x00\x00\b\x00\x01\x00\x00\b\x00\x00\x00\x00\x01\x00")706309a8ffbdab3f7bcfbae5d715e6a062cf8928-17000066400000000000000000000003561455442221600346010ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x01\x00\u007f\x00\x00\b\x00\x00\x00\x01\b\x00\x0f\x00\x00\x00\x00\x01\b\x00\x0f\x00\x00\x00\x00\x01\b\x00\x0f\x00\x00\x02\x00\x01\b\x00\x0f\x00\x00\x00\x00\x01\b\x00\x0f\x00\x0f\x00\x00\x00\x00\x01\b\x00")70b4680e86b8948c48812bfe0248ea1951bdfc24-9000066400000000000000000000001741455442221600340650ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\x00[\x01\x00\x03\b\x04\x17\x00\x00\x00\b\x00\x01\x00\x03\x00\x01\x00\b\x00\a\x00\x02\x00\x05\xff")714dda2f8c5f54e8411eb093cbffd9e7bf109194-12000066400000000000000000000002361455442221600344350ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\x01\x00")71559b308dce709bc847951044e064fa05c2964d-9000066400000000000000000000005341455442221600337220ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x01\x00\b\x00\x00\x00\x1c\x01\x00\x00\b\x00\x06\x00\x00\x00\x00\x01\b\x00\x06\x00\x00\x01\x00\x00\b\x00\x06\x00\x00\x00\x00\x01\b\x00\x06\x00\x00\f\x00\xe6\b\x00\x06\x00\x03\f\x00\xe6\b\x00\x06\x00\x03\x00\x00\n\b\x00\x06\x00\x00\f\x00\xe6\b\x00\x06\x00\x03\f\x00\xe6\b\x00\x06\x00\x00\x00\x06\x04\x00\x00\x06\x00")71be32b18c173dd744fbd1e9b09f7a232001ca5a-3000066400000000000000000000001721455442221600342320ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\x00\x01pM\xf7\x91Iw\xd5B\x9c\x00\x00\x04\x00\x03\x00\x01\x00\x02\x00\x01\x00\xff\xff\u007f\xff")723c47c5b2f81edad65df08d83834e5c9aa025fd-14000066400000000000000000000011541455442221600344320ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x01\x01\x00\x00\x00\x01\x00\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\x19\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\x01\xfa\x00\x00\xfa\x00\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\x00\x00\b\x00\x00\x01")7244cea55dce756dd3408c2140efe4be4ca286e2-2000066400000000000000000000001301455442221600343260ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x01\x00\x00\x00\x00")730909f7faabc356fef9a6e1fbc6d097ebb72866-10000066400000000000000000000001621455442221600345230ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x02\x00\x01\x00\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00")746b10a0024309e56b01f184186d0606648b7de2-4000066400000000000000000000002451455442221600335240ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\x00\x00\x03\x00\x01\x00\x00\x00\x01\x01\x00\x02\x00\x01\x00\x03\x00\xe5\x00\x01\x00\x02\x00\x01\x00\x03\x00\x03\x00\x01\x00\x03\x00\r\x00")753bdaeeedd2a9356c65b3fb819e5e48808d7887-2000066400000000000000000000001061455442221600343150ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("QQ\xef\xbf��\x00\x01\x00\x00\xbd\xef\xbf")7624d5644f8d598be71db90da98f9b1aec334017-16000066400000000000000000000002371455442221600342310ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x01\x00\x00\x00\x00\x00\x00#\x18\x00\t\x00\x14\x00\x00\x01\b\x00\x17\x00\x00\x00\b\x00\x04\x00\x17\x00\x00\x00\b\x01")7849b43356745d3a9347cc51525c1b5350e66228-12000066400000000000000000000002361455442221600335530ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x01\x01\x00\x19\x80\b\x00\x00\x00\x01\b\x00\x17\x00\x00\x00\b\x01\b\x00\x17\x00\x00\x00\x00\x01\b\x00\x17\x00\x00\x00\b\x00")7851a535f8611c464c2a46888df7c6de74d5256c-16000066400000000000000000000005701455442221600340770ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\x00\x01\b\x00\x10\x00\x00\x00\x00\x01\b\x00\x10\x00 \x00\x00\x01\b\x00\x10\x00\x00\x00\x00\x01\b\x00\x10\x00\x00\x00\x00\x01\b\x00\x10\x00 \x00\x00\x01\b\x00\x10\x00\x00\x00\x00\x01\b\x00\x10\x00\x00\x00\xe0\x00\b\x00\x10\x00d\x00\xe0\x00\b\x00\x10\x00d\x00\x00\x01\b\x00\x10\x00\x00\x00\x00\x01\x10\x00\x00\x00")78ae8ae7ab60cfe159712704b056c73a8daf34d0-9000066400000000000000000000003251455442221600342640ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x01@\x02\x00\x01\x00\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\x01\b\x00\x00\x01\x00")7a4645d71be7fdeddbb033879614cb7b21306db8-14000066400000000000000000000003041455442221600343400ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03 \x01\x01\x00\x00\x00\x00\x00\x00\x00\x01(\x00\b\x00\b\x00\b\x00\b\x00\x00\x00\b\x00\b\x00\b\x00\b\xff\b\x00\b\x00\b\x00\b\x00\x00\x00\b\x00\b\x00\b\x00\b\xff\x00\x00")7c4c841826df44b4cc44fb7fd28cd86bda3c2011-6000066400000000000000000000002321455442221600343350ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x10\x00\x00\x01\x00\x03\x00\x01\xfa\xff\x14\x00\x10\x00\x00\x01\x02\x00\x01\x00\x03\x00\x03\x00\x01\xdf\x03\x00\x01\x00")7cac4e5cecb1f2938661dd1cebb5c49cd6e8a1cf-10000066400000000000000000000003251455442221600350000ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x01@\x02\x00\x01\x00\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\x01\x00\x00\b\x0e\x00\x00\x01\b\x00\x00\x01\x00")7eb5756f580ae435236776573737952108a4d18d-15000066400000000000000000000002351455442221600335730ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x01\x00\x00\x00\x00\x00\x00#\x18\x00\t\x00\x14\x00\x00\x01\b\x00\x17\x00\x00\x00\b\x00\b\x00\x17\x00\x00\x00\b\x01")7f4b86eefb67e8f1f1d3e5974ec2ca7e4b76b409-3000066400000000000000000000002101455442221600344450ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x01\x02\x00\x01\x00\x03\x00\x01\xfa\xff\x01\x00\x01\x00\x03\x00\x01\x00\x03\x00\x17\x00\x00\x00\x01\x00")8037509b225dd24d2b89597387d7e9454dba811e-10000066400000000000000000000001431455442221600340010ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\xc9\x01\"\x02\xe8\x00\x00\x03\x00\x01\x00\b\x00\x0f\x00\x02\xe7\x05\xff")817d7d835e78e998621c5d65622d21b6255df159-12000066400000000000000000000002761455442221600337450ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x02\x00\x01\x00\xff\x00\x01\x00\x00\x00\x00\x01\x05\x00\x14\x00\x00\x00\x00\x01\x05\x00\x14\x00\x00\x00\x00\x01\x05\x00\x14\x00\x00\x00\x00\x01\x05\x00\x14\x00\x00")82addf3f6041f1a4d2ab8fc8852a5c3901e66ef8-15000066400000000000000000000004061455442221600344270ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\x00\x01\b\x00\x10\x00\x00\x00\x00\x01\b\x00\x10\x00d\x00\x00\x01\b\x00\x10\x00\x00\x00\x00\x01\b\x00\x10\x00\x00\x00\x00\x01\b\x00\x10\x00d\x00\x00\x01\b\x00\x10\x00\x00\x00\x00\x01\x10\x00\x00\x00")835adb793a33c819fddefa125c9d57b77b06bf6f-8000066400000000000000000000002171455442221600344450ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x01@\x02\x00\x01\x00\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\x01\b\x00\x00\x01\x00")83b3e1b25d8d9bd7e62e2f95d30a94a793e7422e-13000066400000000000000000000003761455442221600343060ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x02\x00\x01\x00\xff\x00\x01\x00\x00\x00\x00\x01\x05\x00\x14\x00\x00\x00\x00\x01\x05\x00\x14\x00\x00\x00\x00\x01\x05\x00\x14\x00\x00\x00\x00\x01\x05\x00\x14\x00\x00\x00\x00\x01\x05\x00\x14\x00\x00\x00\x00\x01\x05\x00\x14\x00\x00")85c64f08fc4e429a1caa46998527fab2dd6222c4-22000066400000000000000000000007231455442221600342730ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x01\xf1\x1d\x00\x00\x00\x00#\f\x00\t\x00\b\x00\x1d\x00\x00\x00\x00#\f\x00\t\x00\b\x00\x00\x00\x00\x00\x00#\f\x00\t\x00\b\x00\x1a\x00\x00\xf5\x01#\f\x00\t\x00\b\x00\x00\x00\x00\x00\b#\f\x00\t\x00\b\x00\x00#\x00\x00\x00#\f\x00\t\x00\b\x00\x1d\x00\x00\x00\x00#\f\x00\t\x00\b\x00\x00\x00\x00\x00\x00#\f\x00\t\x00\b\x00\x1a\x00\x00\xf5\x01#\f\x00\t\x00\b\x00\x00\x00\x00\x00\b#\f\x00\t\x00\b\x00\x1a\x00\x00\xf5\f\x00\t\x00\b\x00")876cd74941c198670a2552fcf87b5166014525bd-6000066400000000000000000000002321455442221600336370ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x80\x00\x00\x00\x00\x01\x00\x03\x00\x01\xfa\xff\x14\x00\x01\x00\x00\xff\xf3\x00\x01\x00\x03\x00\x03\x00\x01\xdf\x03\x00\x01\x00")883100f7fee00384ee7a1117f269cb018bb3731a-2000066400000000000000000000001261455442221600340220ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x16\x02\xb7pM\xf7\x91Iw\xd5B\x9c\x00\x00\x04\x00\n\x83\xecr")88c21b92716b23c468e6525f1cd674066ab45b8e-11000066400000000000000000000005071455442221600340530ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\x00\x00\x00\xe7\x00\x00\x00\x00\x00\x00\x01\b\x00\x04\x00\x03\x00\x00\x01\b\x00\x04\x00\x00\x00\x00\x01\b\x00\x04\x00\x03\x00\x00\x01\b\x00\x04\x00\x03\x00\x00\x04\b\x00\x04\x00\x03\x00\x00\x01\b\x00\x04\x00\x03\x00\x00\x04\b\x00\x04\x00\x03\x00\x00\x01\b\x00\x04\x00\x03\x00\x00\x04\x00\x00\x04\x00")8a627a54274d8918268d9be4a7ec6c4108f7c88d-11000066400000000000000000000003301455442221600341520ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x01\x01\x00\x00\x00\x01\x00\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x01\x00\x00")8ae9885e12a6842bf61603f152e7c867fb8b82f5-8000066400000000000000000000001641455442221600341000ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\xa4\x01\x00\x02\x00\x01\x00\x03\x00#\x00\r\x00\t\x00\x00\x00\x03\x00\x01\x01\x03\xbf\xff")8b6523ae0b3ae48d8ddcd2c29a8a988bada54884-5000066400000000000000000000003531455442221600344350ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\x00\x00\x03\x00\x01\x00\x00\x00\x01\x01\x00\x01\x00\x01\x00\x03\x00\x03\x00\x01\x00\x01\x00\x03\x00\xe5\x00\x01\x00\x02\x00\x01\x00\x03\x00\x03\x00\x01\x00\x03\x00\x01\x00\x03\x00\x03\x00\x01\x00\x03\xea\x00")8c4ad651c5f8df66d8ad46646b8e8c35873026de-8000066400000000000000000000001601455442221600342360ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\xa4\x01\x00\x02\x00\x01\x00\x03\x00#\x00\x00\x00\t\x00\x00\x00\t\x00\x01\x01\x03\xbf")8dbd416bc45b7ca7c1c3a86530dc5b4f460d2177-13000066400000000000000000000001571455442221600343330ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\x00#\f\x00\b\x00\x00\x00\v\x00\x00\x00\x01\x00")8fe51a831d1dd7ab0e781aa6167c12bfbd453bfb-18000066400000000000000000000005651455442221600345560ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00X\x00\b\x00\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\b\x00\x00")902c3156817df11f9f2be1361c3225078aaf262c-9000066400000000000000000000002141455442221600337500ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\xa4\x01\x00\x02\x00\x01\x00\x03\x00#\x00\x00\x00\t\x00\x00\x00\t\x00\x00\x00\t\x00\x00\x00\t\x00\x01\x01\x03\xbf")915c1b885773bb913c7f616e0ea25ac6ec538b5f-15000066400000000000000000000007361455442221600343030ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00#\f\x00\b\x00\b\x00\v\x00\x00\x00\x00#\f\x00\b\x00\b\x00\v\x00\x00\x00\x00#\f\x00\b\x00\b\x00\v\x00\x00\x00\x00#\f\x00\b\x00\b\x00\v\x00\x01\x00\x00\x00\x04\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x01\x00\x00")919ea2e36a31e64b913167b9ead8afa4f9feefaa-16000066400000000000000000000002451455442221600346570ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x00@\x00\x00\x00\x00\x00#\f\x00\b\x00\b\x00\x02\x00\x00\x00\x00#\f\x00\b\x00\b\x00\x02\x00\x00\x00\x01\x00\x00\x00\x01\x00")92d3772ee33d5cc4d4642d8eb4fa20a970c0c046-7000066400000000000000000000002561455442221600342010ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x01\x00\b\x00\x00\x00\b\x01\x00\x00\b\x00\x06\x00\x00\x00\x00\x01\b\x00\x06\x00\x00\f\x00\xe6\b\x00\x06\x00\x03\x00\x00\x04\x00\x00\x06\x00")951832c42eacb3e95a3e18fb1a2a72258fd130ee-13000066400000000000000000000002351455442221600343260ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\x00\x01\b\x00\x10\x00d\x00\x00\x01\b\x00\x10\x00\x00\x00\x00\x01\b\x00\x10\x00\x00\x00\b\x00")9694aae7110256fc650239e87d494bd04eaf5284-9000066400000000000000000000001411455442221600337770ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x01@\x02\x00\x01\x00\x03\x00\x01\x01\x00\x00\b\x00\x00\x00\b\x00")9821a7348835da58d612732be53340893c38588b-14000066400000000000000000000002111455442221600335610ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\x00\x01\b\x00\x0f\x00\x00\x00\x00\x01\b\x00\x10\x00�\x10\x00\x00\b\x00")9a9e19d0080548d48914791537dda54c63efcd43-7000066400000000000000000000002741455442221600340130ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x13\xff\u007f\xff\x01\xe9\xff\xe56\x00\f\x00\x00\x00\x00\x9b\xbd\x89\xbe\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00SR\x00P")9b4e08201f89015170af3379f7f1b4f3458f113a-17000066400000000000000000000002771455442221600337740ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x00@\x00\x00\x00\x00\x00#\f\x00\b\x00\b\x00\x02\x00\x00\x00\x00#\f\x00\b\x00\b\x00\x02\x00\x00\x00\x01\x00\f\x00\b\x00\b\x00\x02\x00\x00\x00\x01\x00")9c5a28bc57ccc233e43f76f7e6a4b60e26b387fb-11000066400000000000000000000002201455442221600344240ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\x01\x00")9c5ee8b92b1ebbda08968c15cba4b7a9d99bbd6d-4000066400000000000000000000001651455442221600346610ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\b\x00\x01\x00\x03\x00\x05\xff\xff\x05\x01\x00")9cbb4643df83c23871500cfed02e00f603a80771-6000066400000000000000000000001421455442221600340230ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\xa4\x01\x00\x02\x00\x01\x00\x03\x00#\x00\x00\x00\t\x00\x00\x03\xbf\xff")9edeecfef566c1e14280c48a33f046a6814d88ca-4000066400000000000000000000001671455442221600343600ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\x00\x01\x00\x02\x00\x00\xf2\xef\x00\x01\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x01\x00")9f5639dd6cc46803b9898aa6e56d408476958ddf-10000066400000000000000000000001621455442221600341750ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\xa4\x01\x00\x02\x00\x01\x00\x03\x00#\x00\r\x00\t\x00\b\x00\x03\x00\x01\x01\x03\xbf\xff")a17e9532742a93f329dbad270f60664bfea94a8f-2000066400000000000000000000001271455442221600342100ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\x00\x00\x01\x00")a214492685193abeb385ca08853a0f9d33c0f7da-11000066400000000000000000000002001455442221600341630ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00")a504f347786b9857398616b67bbd1681994a4924-23000066400000000000000000000006361455442221600336130ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x01\xf1\x1d\x00\x00\x00\x00#\f\x00\t\x00\b\x00\x1d\x00\x00\x00\x00#\f\x00\t\x00\b\x00\x00\x00\x00\x00\x00#\f\x00\t\x00\b\x00\x1a\x00\x00\xf5\x01#\f\x00\t\x00\b\x00\x00\x00\x00\x00\b#\f\x00\t\x00\b\x00\x00#\x00\x00\x00#\f\x00\t\x00\b\x00\x1d\x00\x00\x00\x00#\f\x00\t\x00\b\x00\x00\x00\x00\x00\x00#\f\x00\t\x00\b\x00\x1a\x00\x00\xf5\x01#\f\x00\t\x00\b\x00\f\x00\t\x00\b\x00")a5f6826add25b0ecb7b7f607f926569e0eaf8b51-12000066400000000000000000000005121455442221600344330ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x01\x01\x00\x00\x00\x01\x00\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x01\x00\x00")a5ffba50c6fd02ff00e971f9f65a37451bf31eb8-5000066400000000000000000000002401455442221600344170ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x13\xff\u007f\xff\x01\xe9\xff\xe56\x00\f\x00\x00\x00\x00\x9b\xbd\x89\xbe\x00\x02\x00\x00\x00\x00\x00\x04\x00\x00\x00SR\x00P\xc6")a8f458e73793dd6fcfe1964ef0455856fe90e57f-17000066400000000000000000000004111455442221600343400ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\b\x00\b\x00\x0e\x00\x00\x00\x01#\f\x00\b\x00\b\x00\x0e\x00\x00\x00\x00#\f\x00\b\x00\b\x00\x0e\x00\x00\x00\x00#\f\x00\b\x00\b\x00\x0e\x00\x00\x00\x01#\f\x00\b\x00\b\x00\x0e\x00\x00\x00\x00#\f\x00\b\x00\b\x00\x0e\x00\x00\x00\x01\x00")aa0140b6d0d5bcb180509939a15b6da2a637e443-4000066400000000000000000000001411455442221600340630ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x01N\x02\x00\x01\x00\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\b\x00")ac697fe2e14683badbd6590361f9a9780af4a800-13000066400000000000000000000003141455442221600342700ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03 \x01\x01\x00\x00\x00\x00\x00\x00\x00\x01(\x00\b\x00\b\x00\b\x00\b\x00\x00\x00\b\x00\b\x00\b\x00\b\xff\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\x01\x00\x00\b\x00")ad65ecb8e9f2dd7bcce04ed7691784806cf462af-9000066400000000000000000000003601455442221600345320ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x13\xffo\xff\x01\xe9\xff\xe50\x00\f\x00\x00\x00\x00\x9b\xbd\x89\xbe\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00")ad95f450cfac497bd062673506178fb2e61afd52-19000066400000000000000000000003471455442221600342770ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\x00\x01\b\x00\x0f\x00\x00\x00\x00\x01\b\x00\x17\x00\x00\x00\x00\x01\b\x00\x10\x00\x00\x00\x00\x01\b\x00\x06\x00\x00\x00\x00#\f\x00\b\x00\b\x00\x0e\x00\x00\x00\x01\x00")ae1f5be7c6174a4ade510523aabf0f2347934bc1-15000066400000000000000000000001541455442221600343750ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x00@\x00\x00\x00\x00\x00#\f\x00\b\x00\b\x00\f\x00\x00\x00\x01\x00")aefb9b5f22b5bea0d929cc9695a36e4b8cd7a06f-15000066400000000000000000000004021455442221600346510ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x01\x01\x00\x19\x80\b\x00\x00\b\x00\b\x00\x17\x00\x14\x00\x00\x01\b\x00\x17\x00\x00\x00\b\x00\b\x00\x17\x00\x00\x00\b\x01\b\x00\x17\x00\x00\x00\x00\x01\b\x00\x17\x00\x00\x00\b\x00\b\x00\x17\x00\x14\x00\x00\x01\b\x00\x00\x00")b0fc037933b2a8f0a94f0ea752eac25ea6fe5bf3-11000066400000000000000000000001571455442221600345500ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\x00#\f\x00\b\x00\x00\x00\x01\b\x00\x00\x01\x00")b11254a7f7486e514de1357195d708f2fa7d71ba-9000066400000000000000000000001421455442221600340500ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\x00\x01\b\x00\b\x00\x00\x00\b\x00")b62966c59121c293e75ed977e59858344e6a4f80-16000066400000000000000000000002261455442221600337530ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x01\x00\x00\x00\x00\x00\x00#\f\x00\t\x00\b\x00\x00\x00\x00\x00\x00#\f\x00\t\x00\b\x00\v\x00\x00\x00\x01\x00")b63b5472ef3877c87cfb003913845f1d1fe49572-5000066400000000000000000000001301455442221600337770ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x01\x00\x00\x00\x01\x01\x00\x00\x00\x01\x00\x00\a\x00")b6ae5354dbce8d6786865557e35d119b1c178f45-13000066400000000000000000000005121455442221600341500ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x01\x01\x00\x19\x80\x00\x03\x00\x01\x00\b\x00\x05\x00\x03\x00\x01\x00\b\x00\x05\x00\x03\x00\x01\x00\b\x00\x05\x00\x03\x00\x05\x00\b\x00\x05\x00\x03\x00\x01\x00\b\x00\x05\x00\x03\x00\x01\x00\b\x00\x05\x00\x03\x00\x05\x00\b\x00\x05\x00\x03\x00\x01\x00\b\x00\x05\x00\x03\x00\x05\xff\x00\x00\x05\x00")b7f3ee843c7c6bf7e7ec54d9dc01ab0e837b00be-11000066400000000000000000000003221455442221600346360ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x01@\x02\x00\x01\x00\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\b\x00\xa30\xa6\x82")b9937b9fee48b80de54a1e3d7c0e6ec37c4c4261-1000066400000000000000000000001301455442221600343450ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\x02\x00\x01\x00")ba7ab05882998ae0b3126207e40ee9112d823894-14000066400000000000000000000003131455442221600337600ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\x00\x01\b\x00\x10\x00\x00\x00\x00\x01\b\x00\x10\x00d\x00\x00\x01\b\x00\x10\x00\x00\x00\x00\x01\b\x00\x10\x00\x00\x01\b\x00\x10\x00\x00\x00")bac36169d9f0480595a1b291b45f88331814b32c-15000066400000000000000000000003041455442221600337600ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03 \x01\x01\x00\x00\x00\x00\x00\x00\x00\x01(\x00\b\x00\b\x00\b\x00\b\x00\x00\x00\b\x00\b\x00\b\x00\b\xff\b\x00\b\x00\b\x00\x00\x00\b\x00\b\x00\b\x00\b\x00\x00\x00\b\x00")bec0293ab31473ab0fb9e5f4a8cfad30ca0f1c02-8000066400000000000000000000001321455442221600345200ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x02\x00\x01\x00\xff\x00\x00\b\x00\x00\x00\x01\x05\x00\b\x00\x00")bfa2733e7254d6e4063c2d1b756d2bd86f9853b1-16000066400000000000000000000002351455442221600342110ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x01\x00\x00\x00\x00\x00\x00#\x18\x00\t\x00\x14\x00\x00\x01\b\x00\x17\x00\x00\x00\b\x00\b\x00\x05\x00\x00\x00\b\x01")bfee908e0d86cc7b8a8247cadcaf8d844f2118fc-4000066400000000000000000000001271455442221600346010ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\x00\x01\x00\x02\x00\x01\x00\x03\xf5\x00\x00\x00\x00\x06\x00")c188e7f2ac1e4f6e4f94a9447ac4bc88a6971b75-14000066400000000000000000000007661455442221600344050ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x01\x00\x00")c3721bb7c0ee0d22366049d4a47a0d5c513b33d8-5000066400000000000000000000001451455442221600340740ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x01N\x02\x00\x01\x00\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\b\x00SRV ")c3c81941018b608f41490c259a39e76d18e5c07a-20000066400000000000000000000004051455442221600337630ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\x00\x01\b\x00\x04\x00\x03\x00\x00\x01\b\x00\x0f\x00\x00\x00\x00\x01\b\x00\x17\x00\x00\x00\x00\x01\b\x00\x10\x00\x00\x00\x00\x01\b\x00\x06\x00\x00\x00\x00#\f\x00\b\x00\b\x00\x0e\x00\x00\x00\x01\x00")c5d7db453ef5a289efbee044b3232d9a571a9259-22000066400000000000000000000005531455442221600343550ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\xa4\x01\x1b\x025\x01\x00\x03\x00#\x00\x00\x00\t\x00\x00\x00\t\x00\x00\x00\t\x00\x00\x00\t\x00\x00\x00\t\x00\x00\x00\t\x00\x00\x00\t\x00\f\x00\t\x00\b\x00\x00\x00\x00\x00\b#\f\x00\t\x00\b\x00\t\x00\x00\x00\t\x00\x00\x00\t\x00\f\x00\t\x00\b\x00\x00\x00\x00\x00\b#\f\x00\t\x00\b\x00\x1a\x00\x00\xf5\x00#\f\x00\t\x00\b\x00\x01#\f\x00\t\x00")c677dbbb51186345da388d27c78c975d012d9b89-10000066400000000000000000000002131455442221600341420ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00f\xba\b\x00")c6e6d0be9597bccdf72815f5de3938e6d114dc71-9000066400000000000000000000002231455442221600343700ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\b\x00\x05\x00\x03\x00\x01\x00\b\x00\x05\x00\x03\x00\x05\xff\x00\x00\x05\x00")c72135d8b52ed7a2e5dd50b056abebeb563c39bb-16000066400000000000000000000002211455442221600345420ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x00@\x00\x00\x00\x00\x00#\f\x00\b\x00\b\x00\f\x00\x00\x00\x00#\f\x00\b\x00\b\x00\f\x00\x00\x00\x01\x00")c736584a35409c3fc5f0b833131a9afd2444c31d-21000066400000000000000000000004071455442221600341100ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\xa4\x01\x1b\x02\x00\x01\x00\x03\x00#\x00\x00\x00\t\x00\x00\x00\t\x00\x00\x00\t\x00\x00\x00\t\x00\x00\x00\t\x00\x00\x00\t\x00\f\x00\t\x00\b\x00\x00\x00\x00\x00\b#\f\x00\t\x00\b\x00\x1a\x00\x00\xf5\x00#\f\x00\t\x00\b\x00\x01#\f\x00\t\x00")c79e9886ba2dde581b4b4039fca502fde101b463-8000066400000000000000000000002221455442221600342610ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\\f\x00\x00\x00\x01\x00\x03\x00\x01@\xff\x14\x00\x01\x00\x00\x00\x00\x00\x00\x01\x00\x00\x03\x01\x01\xdf\x03\x00\x01\x00")c7a33e6e86f9270b5053ba0fb7c6f2b6facb2b6c-8000066400000000000000000000001651455442221600345010ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\b\x00\x05\x00\x03\x00\x05\xff\x00\x00\x05\x00")ca8a9ed860ab3cd49993d349812777990ace86c9-12000066400000000000000000000005771455442221600342560ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x01@\x02\x00\x01\x00\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x01\x00\x00\b\x0e\x00\x00\x01\b\x00\x00\x00\b\x00\x00\x00\x01\x00\x00\b\x0e\x00\x00\x01\b\x00\x00\x01\x00")cb86b2f169921c29a7826d3fb2d6522e725065f8-12000066400000000000000000000002271455442221600340600ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\\\xff\xff\xff\u007f\x01\x00\x03\x00\x01@\xff\x14\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x80\x00\x14\x00")ceeb0b4d074909a7e25f6e78dc471f6cf6860726-6000066400000000000000000000003041455442221600342250ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x13\xff\u007f\xff\x01\x00\x00\xe66\x00\f\x00\xe62\x92\x9b\x00d\xbe\x00\x00\b\x04\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00SR\x00P\xc6")d19ef7c783ed0eb20ba1ad98e098d9d8910ffb39-18000066400000000000000000000002151455442221600345300ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x01\x00\x00\x00\x00\x00\x00#\x18\x00\t\x00\b\x00\x00\x00\x00\x00\x00#\f\x00\v\x00\x00fregs\x00\x01")d26838b927c4519f4ae53b60299bddcc0a003864-8000066400000000000000000000001511455442221600340450ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\x00\x01\b\x00\b\x00\x00\x00\x01\b\x00SRV")d28600c5c23cb1786cb3bb256c592067d4ee5519-4000066400000000000000000000002511455442221600340350ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x13\xff\u007f\xff\x01\x00\x00\xe66\x00\f\x00\xe62\x92\x9b\xbd\x89\xbe\x00\x02\x00\x00\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00SR\x00P\xc6")d4fd7d2a155c114123fb9a2cdb750a531ec32fe8-17000066400000000000000000000002731455442221600344040ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x00@\x00\x00\x00\x00\x00#\f\x00\b\x00\b\x00\f\x00\x00\x00\x00#\f\x00\b\x00\b\x00\f\x00\x00\x00\x00#\f\x00\b\x00\b\x00\f\x00#\f\x00\b\x00\b\x00\f")d5933755ddaf09bb1b45409f6fdc4259f171ae86-11000066400000000000000000000001631455442221600342750ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\x00\x01\x00\x02\x00\x01\x01\x03\x00\x00\x00\b\x00\x01\x00\x03\x00\x05\x00\x00\x00\b\x00")d596441991528d799ada560b544e2ab063cd0ad6-7000066400000000000000000000001431455442221600340470ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x01@\x02\x00\x01\x00\x03\x00\x01\x01\x00\x00\b\x00\x00\x00\x01\x00")d6c8e5233409b56267181535c31496a57c7cebcc-10000066400000000000000000000002531455442221600340460ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x01@\n\x00\x01\x00\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\x00\x01\x00\x00\x00\x01\b\x00\xcd\x01\x00\xe2\b\x00\x00\x00\x01\b\x00\x00\x00\xff")d6f6f0c0d9fe5695aedfa4d747e762dd49fb872f-5000066400000000000000000000001451455442221600345450ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\b\x00\x01\x00\x03\x00\x05\xff")da39a3ee5e6b4b0d3255bfef95601890afd80709000066400000000000000000000000321455442221600341210ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("")dacf068bc8da64ef8dbe293b3c7c3b78de9bde9b-19000066400000000000000000000003111455442221600351040ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x01\xf1\x1d\x00\x00\x00\x00#\f\x00\t\x00\b\x00\x00\x00\x00\x00\x00#\f\x00\t\x00\b\x00\v\x00\x00\xf5\x01#\f\x00\t\x00\b\x00\x00\x00\x00\x06\n\x01\x00\x00\b\x00")dda80b9974435254aa6aece83640f86cd93316f4-4000066400000000000000000000002071455442221600341350ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\xa4\x01\x00\x02\x00\x01\x00\x03\x00\x01\x00\x00\x00\x01\x01\x00\x00\x00\x01\x00\x00\x03\x00\x01\xbd\xbf\xef")dfadf3c0c35c6735f6c16920a0094ec105c46751-2000066400000000000000000000001741455442221600341060ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x01\x01\x00\x03\x00\x01\x00\x00\x00\x00\x02\x00\x01\x00\x03\x00\x01\x02\x00\x00\x02\x00\x01")e1028221645cb44301f033d8d34b526e8c396c9a-18000066400000000000000000000005461455442221600337610ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x01\x00\u007f\x00\x00\b\x00\x00\x00\x01\b\x00\x0f\x00\x00\x00\x00\x01\b\x00\x0f\x00\x00\x00\x00\x01\b\x00\x0f\x00\x00\x02\x00\x01\b\x00\x0f\x00\x00\x00\x00\x01\b\x00\x0f\x00\x00\x00\x00\x01\b\x00\x0f\x00\x00\x00\x00\x01\b\x00\x0f\x00\x00\x00\x00\x01\b\x00\x0f\x00\x00\x02\x00\x01\b\x00\x0f\x00\x00\x00\x00\x01\b\x0f\x00\x00")e1c951e71df930f3c48b84332a1c04f9a4e0e802-4000066400000000000000000000001321455442221600341070ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x03\x00\x02\x00\xe9\x00\x03\xff\u007f\x00\x00\x00\x05\x00")e1e646858e9c91689c67bed1821e3c97a3c69e34-16000066400000000000000000000006201455442221600341700ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x01\x01\x00\x19\x80\b\x00\x00\b\x00\b\x00\x17\x00\x14\x00\x00\x01\b\x00\x17\x00\x00\x00\b\x00\b\x00\x17\x00\x00\x00\b\x01\b\x00\x17\x00\x00\x00\x00\x01\b\x00\x17\x00\x00\x00\b\x00\b\x00\x17\x00\x14\x00\x00\x01\b\x00\x17\x00\x00\x00\b\x00\b\x00\x17\x00\x00\x00\b\x01\b\x00\x17\x00\x00\x00\x00\x01\b\x00\x17\x00\x00\x00\b\x00\b\x00\x17\x00\x14\x00\x00\x00\b\x00\b\x00")e1f07aa12d2b9827b589170e7b92ad204a63a6ae-15000066400000000000000000000001571455442221600342530ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00#\f\x00\t\x00\b\x00\v\x00\x00\x00\x01\x00")e2b9e3843bee7951c730e3d346419452da587f70-17000066400000000000000000000002441455442221600340650ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x01\xf1\x1d\x00\x00\x00\x00#\f\x00\t\x00\b\x00\x00\x00\x00\x00\x00#\f\x00\t\x00\b\x00\v\x00\x00\xf5\x01\x00\x00\x00\b\x00")e2e94717ae0ad619804f14049715d0a08d3ae4db-10000066400000000000000000000003121455442221600341620ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x01\x01\x00\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\x01\b\x00\x00\x01\x00")e56272ea1a2766d46aed4c8c97b6c7cea7f81f93-6000066400000000000000000000002101455442221600343610ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x01@\x02\x00\x01\x00\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\b\x00SRV")e641621834d08937c4cecff69790d4ca8f81d176-3000066400000000000000000000002341455442221600340700ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x01\x01\x00\x03\x00\x01\x00\x00\x00\x00\x03\x00\x01\x00\x00\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x02\x00\x00\x02\x00\x01")e6add3c6fa4080162b06fdb64cec44a17eb0b84f-11000066400000000000000000000004711455442221600345420ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x01@\x02\x00\x01\x00\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\x01\x00\x00\b\x0e\x00\x00\x01\b\x00\x00\x00\b\x00\x00\x00\x01\x00\x00\b\x0e\x00\x00\x01\b\x00\x00\x01\x00")e8ad37772b295e8aabbac0409c3ba800040a852b-18000066400000000000000000000002301455442221600343120ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x01\x00\x00\x00\x00\x00\x00#\x18\x00\t\x00\b\x00\x00\x00\x00\x00\x00#\f\x00\t\x00\b\x00\v\x00\x00\x00\x05\x00")e8c6392cd414c06f4476fcbf4f3f5dea56eaad81-9000066400000000000000000000002551455442221600345220ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x01@\x02\x00\x01\x00\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\x01\b\x00\x00\x01\x00")e94c0c2875f2840b8bf26ed9f96c157bd54b48a6-3000066400000000000000000000001131455442221600342220ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x16\x02\xb7pM\xf7\x91Iw\xd5B\x9c\x00\x00\x17\x00")ea3ca7a64e9606f7837564fcc8dc3a5ed0f8ad58-19000066400000000000000000000005051455442221600345330ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x00@\x00\x00\x00\x00\x00#\f\x00\b\x00\b\x00\x02\x00\x00\x00\x00#\f\x00\b\x00\b\x00\x02\x00\x00\x00\x14\x00\f\x00\b\x00\b\x00\x02\x00\x00\x00\x00#\f\x00\b\x00\b\x00\x02\x00\x00\x00\x00#\f\x00\b\x00\b\x00\x02\x00\x00\x00\x01\x00\f\x00\b\x00\b\x00\x02\x00\x00\x00\x00\x00\b\x00\x02\x00")eb7789487cdf3412fefc7197d52e1b5cbe71fb29-17000066400000000000000000000004701455442221600344570ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00#\f\x00\b\x00\b\x00\v\x00\x00\x00\x00#\f\x00\b\x00\b\x00\v\x00\x00\x00\x00#\f\x00\b\x00\b\x00\v\x00\x00\x00\x00#\f\x00\b\x00\b\x00\v\x00\x00\x00\x00#\f\x00\b\x00\b\x00\v\x00\x00\x00\x00#\f\x00\b\x00\b\x00\v\x00\x00\x00\x00\x00\x00\x01\xbd\xbf")ed9ec2b36993526e8bf9828a908264df2552498f-8000066400000000000000000000003471455442221600340430ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x13\xff\u007f\xff\x01\x00\x00\xe66\x00\f\x00\xe62\x92\x9b\x00d\xbe\x00\x00\b\x04\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00S\x04\x00P\xc6")f01cdd9b8bf845a89f58c1a09db3454d853a779f-23000066400000000000000000000005761455442221600344030ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\f\x00\t\x00\b\x00\x00\x00\x00\x00\x00#d\x00\t\x00\b\x00\x1a\x00\x00\xf5\x01#\f\x00\t\x00\b\x00\x00\x00\x00\x00\b#\f\x00\t\x00\b\x00\x00#\x00\x00\x00#\f\x00\t\x00\b\x00\x1d\x00\x00\x00\x00#\f\x00\t\x00\b\x00\x00\x00\x00\x00\x00#\f\x00\t\x00\b\x00\x1a\x00\x00\xf5\x01#\f\x00\t\x00\b\x00\x00\x00\x00\x00\b#\f\x00\t\x00\b\x00\x1a\x00\x00\xf5\f\x00\t\x00\b\x00")f025a836e4a6e46fba34bf326812de5e0c9c5fed-15000066400000000000000000000001551455442221600345060ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("Retry: \b\x00\x00\x00\xb7\b\x00\x0f\x00\x00\x00\x00\x01\b\x00\x0f\x00\x00\x00\b\x00")f122d63393eed58bbc25f933f2713dd1a0445c2e-3000066400000000000000000000001261455442221600341700ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x01\x00\x02\x00\x01\x00\x03\x00\x01\x01\x00\x00\b\x00")f198116049b36107436b1a1ebdf3b47a14f08a33-14000066400000000000000000000002401455442221600340140ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\x00\x01\b\x00\x0f\x00\x00\x00\x00\x01\b\x00\x10\x00\x00\x00\x00\x01\b\x00\x06\x00\x00\x00\b\x00")f2416b5a96bcac5cf00b996b0312d27dbc861b8c-9000066400000000000000000000001621455442221600343320ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\xa4\x01\x00\x02\x00\x01\x00\x03\x00#\x00\r\x00\t\x00\t\x00\x03\x00\x01\x01\x03\xbf\xff")f317fb40ce76c1510e032d2f3ae1139056c8f695-2000066400000000000000000000001701455442221600340260ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x01\x02\x00\x01\x00\x03\x00\x01\xfa\xff\x01\x00\x01\x00\x03\x00\x01\x00\x03\x00\x01\x00")f323effa4d8b6869ccf3a02ed6d486fd620669ce-13000066400000000000000000000001611455442221600345240ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\x00\x00\b\x00\x00\x00\x00#\f\x00\b\x00\x00\x00\x02\x00\x00\x00\x01\x00")f371896368a16b3772ef58d28741ec07fe95e240-8000066400000000000000000000001431455442221600337360ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("'\x00\x01\x00\x02\xe8\x00\x00\x03\x00\x01\x00\b\x00\t\x00\x02\xe7\x05\xff")f41638aa01d238e4e52eced2a8134e2096c26036-17000066400000000000000000000003561455442221600341140ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x01\b\x00\x10\x00\x00\x00\x00\x01\u007f\x00\x10\x00 \x00\x00\x01\b\x00\x10\x00\x00NoMatchEmptyMatchLiteralCharClassAnyCharN\xf5otNLAnyCharBeginLineEndLineBeginTextEndTextWordBoundaryoNWordBoundaryCap")f61b5e8d03f66329fd03f4690c71161241ecdb26-13000066400000000000000000000002411455442221600341140ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x05\x00\b\x00\x05\x00\x03\x00\x00#\x18\x00\t\x00\x14\x00\x00\x03\x00\x02\x01\x00\b\x00\x05\x00\x03\x00\x05\xff\x00\x00\x05\x00")f71e41cf2a4177acea0ed55ef67936a91489b03d-10000066400000000000000000000001441455442221600343440ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x03\x00\x01\x01\x00\x00\x00\b\x00\x00\x00\x01\b\x00\x06\x00\x00\x00\b\x00")fa378263958dc427cd58c3a823c5ad04f74fe4fc-5000066400000000000000000000002241455442221600343000ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x01\x01\x00\x00\x00\b\x00\x00\x00\x01\b\x00\x06\x00\x00\x00\x00\x01\b\x00\x06\x00\x03\x00\x00\x04\x00\x00\x04\x00")fabeb6cf6ddb69c3a3457a50bf545d6956d6d547-7000066400000000000000000000002261455442221600344440ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\b\x00\x04\x00\x00\x00\x00\x01\b\x00\x04\x00\x03\x00\x00\x04\x00\x00\x04\x00")fb301606323e2bd299caa6f50bc378f09fd2580d-9000066400000000000000000000001341455442221600341760ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\x02\x00\x01\x00\xff\x00\x00\b\x00\x00\x00\x01\x05\x00\x14\x00\x00")fb7d8517a5ab2d93597fb9dae4277752cd595ea3-3000066400000000000000000000002301455442221600343030ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRouteMessagego test fuzz v1 []byte("\b\x00\x01\x02\x00\x01\x00\x03\x00\x01\xfa\xff\x01\x00\x01\x00\x01\x00\x02\x00\x01\x00\x03\x00\x03\x00\x01\x00\x03\x00\x01\x00")golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessage/000077500000000000000000000000001455442221600263465ustar00rootroot000000000000000000425fd0ae670913e4b35005b123eff1cd12de-12000066400000000000000000000003261455442221600337440ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x00`sdN@\x14n\x00\x00\x15\x10\b\x00\x0e\x00\x00\x00\x01\x10\b\x00\x0e\x00\x00\x00\x01\x10\b\x00\x0e\x00\x00\x00\x01\x10\b\x00\x0e\x00\x00\x00v\x10\b\x00\x0e\x00\x00\x00v\b\x00\x00\x0e\x00")00396c796d67b628713575c4c30cc7c4fdb83534-9000066400000000000000000000003021455442221600335300ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x00\x80sd\x03\xbd\xbf\xef\x00\x00\x01\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00")029ab698b7650a5d8e5b69484a2985270f56b1aa-11000066400000000000000000000003501455442221600336640ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x00`sdN@\x14n\x00\x00\x01\x10\b\x00\x18\x00\x00\x00\x01\x10\b\x00\x18\x00\x00\x00\x01\x10\b\x00\x18\x00\x00\x00\x01\x10\b\x00\x18\x00\x00\x00\x01\xf2\b\x00\x18\x00\x00\x00\x01\x10\a\x00\x18\x00\x10\x00\x00")0460f48e234c3a915f8b079c08f5c029fdebbf93-16000066400000000000000000000005761455442221600341160ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\xef\x00\x00\u007fN\x01\x14n\x00\x00\x01\x10\x05\x00\x13\x00\x00\x00\x01\x10\x05\x00\x13\x00\x00\x00\x01\x10\x05\x00\x13\x00\x00\x00:\x10\x05\x00\x13\x00\x00\x00\x01\x10\x05\x00\x13\x00\x00\x00\x01\x10\x05\x00\x13\x00\x00\x00\x01\x10\x05\x00\x13\x00\x00\x00:\x10\x05\x00\x13\x00\x00\x00\x01\x10\x05\x00\x13\x00\x00\x00\x01\x10\b\x00\x13\x00\x13\x00\x00\x00")078f35431987968c9897ac83843604051d0bffcc-10000066400000000000000000000001511455442221600335420ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x00\x00\u007f\xff\x04\x00\x00\x00\x04\x00\x00\x00\f\x00\f\x00\x00\x01\xffrefle")08413e7dabc80b105b56153905a9299c9054b024-15000066400000000000000000000005741455442221600335070ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x00`sd\x00\x00\x00\x80 \x00\x01\x10\b\x00\x18\x00\x00\xff\x01\x10\b\x00\x18\x00\x00n\x00\x10\b\x00\x17\x00\x01\x00\x01\x10\b\x00\x18\x00e\x00\x01\x10\b\x00\x18\x00\x00\x00\x00\x10\b\x00\x18\x00\x00\x00\x01\x10\b\x00\x18\x00\x00n\x00\x10\b\x00\x17\x00\x01\x00\x01\x10\b\x00\x18\x00e\x00\x01\x10\b\x00\x18\x00\x00\x00\x01\x10\b\x00\x18\x00\x00\x10\x00\x00")085ee718b110fabbe999661e6cc9196cfefdf071-6000066400000000000000000000001211455442221600341710ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x00\x80sdN@\x14n\x00\x00\x01\x10\b\x00\v\x00\x00\x00lo")090afa4e752a08a629b85ea7a7cb5397812f2c7e-10000066400000000000000000000004621455442221600340770ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x00\x80sd\x03\xbd\xbf\xef\x00\x00\x01\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00")0949ca1c6eb23ae29cd6e8b9a6e82bc744a82626-9000066400000000000000000000003041455442221600341050ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x00\x80siNg n\x00\x00\x01\x00\x00\x00\t\x00\x00\x00\t\x00\x00\x00\t\x00\x00\x00\t\x00\x00\x00\t\x00\x00\x00\t\x00\x00\x00\t\x00\x00\x00\t\x00\t\x00\t\x00\t\x00\x00\x00\t")096ec10c27ea9591febd04b16e1fec46bb6b0797-10000066400000000000000000000002141455442221600342250ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x00\x80sd\x1c!N@\x14n\x00\x10\b\x00\x17\x00\x01\x00\x00\x10\b\x00\x17\x00\x01\x00\x00\x10\b\x00\x17\x00\x01\x00do")0a81e74ec1f83ba38af07be7ef14ae90bc8d60be-10000066400000000000000000000002141455442221600344370ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x00\x01\x00\x00[@\x14n\xbd\xbf\xef`\b\x00\n\x00\x00\x00\x01\x10\b\x00\n\x00\x00\x00\x01\x10\b\x00\r\x00\x00\x00v[")0be197746ace78f533ee0a7daf8f476873f52cff-9000066400000000000000000000001651455442221600342150ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x02\x80siNg \u007f\xff\x00\x01\x00\x00\x00\x03\x00\x00\x00\x11\x00\b\x00\x14\x00\x00\x00lo")0bf5905428ee36eea936b7fa08a58e5c2e3f7f63-5000066400000000000000000000001441455442221600341140ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x00\x80siNg n\x00\x00\x01\x00\x00\x00\t\x00\x00\x00\t\x00\x00\x00\x10\x00")0c1b6b5bd3be0616b6718e80d87b8d1627361f02-11000066400000000000000000000002501455442221600337150ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\uf7b9Ȁ\xff\xff\xff\x00\x00\u007f\xff\f\x00\x03\x00\x04\x00\x02\xff\x04\x00\x00\x00\f\x00\x03\x00\x01\x00\x02\xff\x00\x00\u007f\xff\x04\x00re")0dc87255a75d71bea5e9ac25294ca6ffbb7ac2af-11000066400000000000000000000003521455442221600344460ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\uf7b9Ȁ\xff\xff\xff\x00\x00\u007f\xff\x04\x00\x00\x00\x04\x00\x00\x00\f\x00\x03\x00\x01\x00\x02\xff\x00\x00\u007f\xff\x04\x00\x00\x00\x04\x00\x00\x00\f\x00\x03\x00\x01\x00\x02\xff\x00\x00\u007f\xff\x04\x00re")117ffdc56f20df53ca0ebcff5bf99e524a36e4bc-9000066400000000000000000000002451455442221600344620ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x00\x80sdNc\x14n\x00\x00\x01\x10\b\x00\v\x00\x00\x00\x01\x10\b\x00\v\x00\x00\x00\x01\x10\b\x00\v\x00\x00\x00\x01\x10\b\x00\v\x00\x00\x00lo")118238f90941983c6b855e946968ac4873557dfa-6000066400000000000000000000001271455442221600334260ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x02\x80siNy \u007f\xff\x00\x01\x00\a\x00\x03\x80\x00\x00\x00")13c7ab77dac6860b7f8c9933e4ce9cecd005ea03-7000066400000000000000000000002421455442221600342370ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x00\x80s\x02\x80siiNg n\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00\x00\x00\x12\x00")1438e05b40c4435cb72e27c029023c5b519fd0a8-12000066400000000000000000000003261455442221600336300ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x02\x80s\x00\x00\x00\x80\u007f\xff\x00\x01\x00\x00\x00\x03\x00\x00\x00\x11\x00\b\x00\r\x00\x00\x00\x01\x10\b\x00\x17\x00@\x00\x01\x10\b\x00\x18\x00\x00\x00\x01\x10\b\x00\x06\x00\x00\x00vo")14b8a7412b946df0a6bea3e1bc8c3035cc15f75b-12000066400000000000000000000003351455442221600342120ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\uf7b94\x04\x00\xbd\b\x98\x9aaA\x14\x00\x01\x00\x00\x00\x00\x00j\x01\x00\x02\x00\x00\x00 \x80\x01\x00\x00\b\x00\x01\x00\x02\x01\x00\x00\b\x00\x01\x00\x03\x01\x00\x00\b\x00\x01\x00\x02\x00\x01\x00")14dfe792be9b5128ee022bbf89ad7bf042538eec-4000066400000000000000000000001411455442221600342360ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x02\x80siNg \u007f\xff\x00\x01\x00\x00\x00\x03\x00\x00\x00\x03\x00 H H")16e11f760a0d36dabadaf12c41fe8adf39674c53-4000066400000000000000000000001651455442221600342170ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\uf7b9\xbd�\x00\x00\x00\xbf\x00\x00\x00\xbf\xbd\x00\x00\xbd\x00\x00\x00\x15\xec\xfbl\x01<")19b29b4276157655f55b958d78192ce5114a8647-2000066400000000000000000000000551455442221600333250ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("m\x00\x80sing closi")1ad939af11cdccc2605f57d7a7bc3f6f0191e825-4000066400000000000000000000001041455442221600341440ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\uf7b9\xc8�\b&\x9a\xf3\xb9\x04\x00\v\x00")1b23bc33ed5907dc9d4a0102a2176f0c7bf7f2c3-14000066400000000000000000000004671455442221600341350ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\uf7b94\x04\x00\xbd\b\x98\x9aaA\x14\x00\x01\x00\x80\x00\x00\x00j\x01\x00\x02\x00\x00\x00 \x80\x01\x00\x00\b\x00\x01\x00\x02\x01\x00\x00\b\x00\x01\x00\x03\x01\x00\x00\b\x00\x01\x00\x02\x01\x00\x00\b\x00\x01\x00\x02\x01\x00\x00\b\x00\x01\x00\x02\x00\x01\x00\b\x00\x01\x00\x02\x00\x01\x00")1b5896dc8dc0abf54c1883c14b3cdc049ac411dd-12000066400000000000000000000004201455442221600342710ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\uf7b9Ȁ\xff\xff\xff\x00\x00\u007f\xff\x04\x00\x00\x00\x04\x00\x00\x00\f\x00\x03\x00\x01\x00\x02\xff\x00\x00\u007f\xff\x04\x00\x00\x00\x04\x00\x00\x00\x04\x00\x00\x00\f\x00\x03\x00\x01\x00\x02\xff\x00\x00\u007f\xff\x04\x00\x00\x03\x00\x01\x00\x00")1b87e9a9d9152e637eeffc8bb363dbaf2810a54f-13000066400000000000000000000002551455442221600343310ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x00`sONX\x14n\x00\x00\x01\x10\b\x00\x14\x00\x00\x00\x01\x10\b\x00\x18\x00\x00\x00\x01\x10\b\x00\x17\x00@\x00\x01\x10\b\x00\x18\x00\x00\x10\x00\x00")1c4cbe97d144bf6ee4b0c2569f9c3e4b5c4948c4-13000066400000000000000000000005421455442221600342510ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x02\x01\x00\x00\x00@\x14n\x00\x00\x01\x10\b\x00\x06\x00\x00\x00\x01\x10\b\x00\x06\x00\x00\x00\x01\x10\b\x00\x06\x00\x00\x00\x01\x10\b\x00\x06\x00\x00\x00\x01\x10\b\x00\x06\x00\x00\x00\x01\x10\b\x00\x06\x00\x00\x00\x01\x10\b\x00\x06\x00\x00\x00\x01\x10\b\x00\x06\x00\x00\x00\x01\x10\b\x00\x06\x00\x00\x00\x00\x01\x10\x00\x06\x00")1efd08f1850d58ecee1845e869f9ce539c678fa2-13000066400000000000000000000005011455442221600342140ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x00\x80sdNc\x01 \x00\x00\x80\x10\b\x00\v\x00\x00\x00\x01\x10\b\x00\v\x00\x00\x00\x01\x10\b\x00\v\x00\x00\x00\x01\x10\b\x00\v\x00\x00\x00\x01\x10\b\x00\v\x00\x00\x00\x01\x10\b\x00\v\x00\x00\x00\x01\x10\b\x00\v\x00\x00\x00\x01\x10\b\x00\v\x00\x00\x00\x01\x10\b\x00\v\x00\x00\x00\x01\x10\b\x00\v\b")1efdca29ca27d1843e2108f47f3d2f381a466cc2-6000066400000000000000000000001711455442221600340660ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\uf7b9Ȁ\xff\xff\xff&\x9a\xf3\xb9\x04\x00\x00\x00\f\x00\x01\x00\x03\x00\x01\x00\x02\x01\x00\xff")1efff603fefaa0fb99924cffde360f669e4ec5a4-13000066400000000000000000000011131455442221600345520ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x02\x80siingMyH o\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00e\a\x80")20557a8e9fe3c33bdba52d8e7d11cb34d13c21c9-3000066400000000000000000000001121455442221600341300ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x00\x80siNg n\x00\x00\x01\x00\x00\x00\t\x00Eg H")217df99e149bee7c1f99daf08ba961d4230bc726-10000066400000000000000000000003121455442221600341620ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x00`sdN@\x14n\x00\x00\x01\x10\b\x00\x18\x00\x00\x00\x01\x10\b\x00\x18\x00\x00\x00\x01\x10\b\x00\x18\x00\x00\x00\x01\x10\b\x00\x18\x00\x00\x00\x01\xf2\a\x00\x18\x00\x10\x00\x00")2238b55c414ffd7f7e682267000aaba61ff6aa48-12000066400000000000000000000003671455442221600340720ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x00\x80sd\x1c!N\x01\x14n\x00\x10\b\x00\x17\x00@\x00\x00\x10\b\x00\x17\x00\x01\x00\x00\x10\b\x00\x17\x00@\x00\x00\x10\b\x00\x17\x00\x01\x00\x00\x10\b\x00\x17\x00\x01\x00\x00\x10\b\x00\x17\x00\x01\x00\x01\x00\x00\x10\b\x00")22b9b32709dc0844240cc52cfe4983faa13de10e-8000066400000000000000000000001661455442221600340020ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x00\x01\x00\x00\x00@\x14n\x00\x00\x01\x10\b\x00\r\x00\x00\x00\x01\x10\b\x00\r\x00\x00\x00v[")23f24fa6fb71516e43c6892945dee7ed8a07fa12-11000066400000000000000000000001621455442221600341030ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x00\x01\x00\x00\x00@\x14n\x00\x00\x01\x10\b\x00\x04\x00\x01\x00\x03\x00\x00\x00\x04\x00")2428eef67ce020ea1c6682c52de777de9c8a3e92-8000066400000000000000000000002171455442221600341160ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\uf7b9\xc8\x04\x00\xbd\b&\x9b\x06\xb9\x14\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x00\x00")2500151f8ec901f25d6668956fec78f53c40dcc6-4000066400000000000000000000002011455442221600336620ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\uf7bf\xbd\xef\x00\x00\x00\x01\xbf\xbd\x00\x00\x00\xb9\x00\x00\x00\xbf\xbd\x00\x00\xbd\x00\x00\x00\x01<")25580c75dc960c1ec95e6e952962c545e1628af1-19000066400000000000000000000006771455442221600337150ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\xef\x00\x00\u007fN\x01\x14n\x00\x00\x01\x10\x05\x00\x13\x00\x00\x00\x01\x10\x05\x00\x13\x00\x00\x00\x01\x10\x05\x00\x13\x00\x00\x00:\x10\x05\x00\x13\x00\x00\x00\x01\x10\x05\x00\x13\x00\x00\x00\x01\x10\x05\x00\x13\x00\x00\x00\x01\x10\x05\x00\x13\x00\x00\x00\a\x00\x04\x00\a\x00\x04\x00\a\x00\x04\x00\a\x00\x04\x00\a\x00\x04\x00\a\x00\x04\x00\a\x00\x04\x00\a\x00\x04\x00\a\x00\x04\x00\a\x00\x04\x00\x00\x00\x00\x01\x05\x00")2574c06e0648eb1e076333e4d9b2beb49867f748-7000066400000000000000000000002031455442221600336130ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\uf7b9\xc8\x04\x00\xbd\b&\x9a\xf3\xb9\x14\x00\x01\x00\x03ip4j\x01\x00\x02\x00\x00\x00\x01\x00\x01\x00\x00")25f571519800025a1c863c9e4b9a67a41d146ebc-7000066400000000000000000000001341455442221600335660ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x00\x01\x00\x00\x00@\x14n\x00\x00\x01\x10\b\x00\x0f\x00\x00\x00vo")26e5ec2bdfa23b5802a3b0a72185863aa40440ad-12000066400000000000000000000003621455442221600340330ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("@\x00\x00\x00\xff\x00\x14d\x00\x00\x01\x10\b\x00\x14\x00\x00\x00\x01\x10\b\x00\x14\x00\x00\x00\x01\x10\b\x00\x14\x00\x00\x00\x01\x10\b\x00\x14\x00\x00\x00\x01\x10\b\x00\x14\x00\x00\x00\x01\x10\b\x00\x14\x00\x00\x00`o")27d4fbc2a3db7e98e53d67f66639fe4b69a48d40-7000066400000000000000000000002201455442221600341230ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\uf7b9\xc8\xef]\xbd\b&\x9a\xf3\x00\x04\x00\a\x00\x04\x00\a\x00\x04\x00\a\x00\x04\x00\a\x00\x04\x00\a\x00\x04\x00\a\x00")2869527f8eb3c02069bdbb4685d9210d0415d696-11000066400000000000000000000002031455442221600335760ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x00\x01\x00\xe8[@\x14n\xbd\xbf\xef`\b\x00\n\x00\x00\xbf\xef`\b\x00\n\x00\x00\x00v`\b\x00\n\x00\x00\x00v[")2c05915886cc8b8c4d5b35d247533d0d58044c23-6000066400000000000000000000001421455442221600335130ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x00\x80sdNg Z\x00\x00\x01\x00\x00\x00\b\x00\x00\x00\b\x00\x00\x00\b\x00")2c84b9cca25d3a323fc663d652b0a8e353e25039-11000066400000000000000000000002601455442221600337740ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x00`sdN@\x14n\x00\x00\x01\x10\b\x00\x18\x00\x00\x00\x01\x10\b\x00\x18\x00\x00\x00\x01\x10\b\x00\x18\x00\x00\x00\x01\x10\b\x00\x18\x00\x00\x10\x00\x00")2cb1295adb46b337fbb17dc25a7099a888bace11-11000066400000000000000000000002241455442221600342160ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x00\x01\x00\x00\x00@\x14n\x00\x00\x01\x10\b\x00\x0f\x00\x00\x00\x01\x10\b\x00\n\x00\x00\x00\x01\x10\b\x00\r\x00\x00\x00v[")2ccfab2e01d4000aa5e2e99cde02fc5dfc31ab26-7000066400000000000000000000002311455442221600344070ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x02\x80s\x00\x00\x00\x80\u007f\xf6\x00\x01\x00\x00\x00\x03\x00\x00\x00\x11\x00\x00\x00\x11\x00\x00\x00\x11\x00\x00\x00\x11\x00")2db039205b45709333004bb78867c8731c531e58-14000066400000000000000000000002171455442221600333520ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x00`sdN\x01\x14n\x00\x00\x01\x10\x05\x00\x16\x00\x00\x00\x01\x10\x05\x00\x16\x00\x00\x00\x01\x10\x05\x00\x16\x00\x00")2fe232e5604943d942c03e273208f09c5ddbea34-6000066400000000000000000000002261455442221600336460ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\uf7b94\x04\x00\xbd\b\x98\x9aaA\x14\x00\x01\x00\x00\x00\x00\x01j\x01\x00\x02\x01\xff\xff\xeb\x01\x00\x01\xea\x00\x00\x01\x00")30846f501a311f1baabb22850639b493308cbacf-3000066400000000000000000000001141455442221600336720ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x00\x80sdNg n\x00\x00\x01\x00\x00\x00\x05\x00 Hlo")31837001a46016647184b6700562a269c7d874be-7000066400000000000000000000001141455442221600332060ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("N\x80sd\x00@\x14n \x01\xf5\a\x00\x18\x00\x00\x00d")32f6c5e2b7d7a336e1f7c9e5bd88fc93b10b3eee-5000066400000000000000000000001741455442221600343310ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x02\x80siingMXH o\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbf\xbd\x00")32f750378417f1976541e1729b9f11269e8c8574-8000066400000000000000000000001721455442221600332560ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x00\x01\x00\x00\x00@\x14n\x00\x00\x01\x10\b\x00\x0e\x00\x00\x00\x01\x10\b\x00\x0e\x00\x00\x00vo")33708f2bcdad420501bdc4c6a999c5a42af26fea-9000066400000000000000000000001641455442221600342230ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\x00`sdN@\x14n\x00\x00\x01\x10\b\x00\x17\x00\x00\x00\x01\x10\b\x00\x18\x00\xbf\x00\x00\x00")340293229806047fd120d54c1d2dc3d76ef1bdfb-2000066400000000000000000000001221455442221600337070ustar00rootroot00000000000000golang-github-jsimonetti-rtnetlink-1.4.1/testdata/fuzz/FuzzRuleMessagego test fuzz v1 []byte("\xef\x9e\x00-�dnsm\x00\x10\x00\x01